From 613f37a0d089d5930dd6278b79100c62d40f6751 Mon Sep 17 00:00:00 2001
From: "Sidra S.Ali" <s928309@gmail.com>
Date: Sun, 27 Jul 2025 19:28:21 +0200
Subject: [PATCH 1/7] feat: Add data classes for AST nodes #4

---
 .idea/.name                          | 1 +
 .idea/gradle.xml                     | 1 +
 .idea/ktlint-plugin.xml              | 7 +++++++
 src/main/kotlin/Main.kt              | 1 +
 src/main/kotlin/{ => lexer}/Lexer.kt | 8 +++++---
 src/main/kotlin/parser/ASTNode.kt    | 3 +++
 src/main/kotlin/parser/Expression.kt | 9 +++++++++
 src/main/kotlin/parser/Functions.kt  | 8 ++++++++
 src/main/kotlin/parser/Identifier.kt | 7 +++++++
 src/main/kotlin/parser/Programs.kt   | 7 +++++++
 src/main/kotlin/parser/Statement.kt  | 7 +++++++
 src/test/kotlin/LexerTest.kt         | 2 ++
 12 files changed, 58 insertions(+), 3 deletions(-)
 create mode 100644 .idea/.name
 create mode 100644 .idea/ktlint-plugin.xml
 rename src/main/kotlin/{ => lexer}/Lexer.kt (97%)
 create mode 100644 src/main/kotlin/parser/ASTNode.kt
 create mode 100644 src/main/kotlin/parser/Expression.kt
 create mode 100644 src/main/kotlin/parser/Functions.kt
 create mode 100644 src/main/kotlin/parser/Identifier.kt
 create mode 100644 src/main/kotlin/parser/Programs.kt
 create mode 100644 src/main/kotlin/parser/Statement.kt

diff --git a/.idea/.name b/.idea/.name
new file mode 100644
index 0000000..b71e6e5
--- /dev/null
+++ b/.idea/.name
@@ -0,0 +1 @@
+CompilerLogic
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 14746e7..2a65317 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
diff --git a/.idea/ktlint-plugin.xml b/.idea/ktlint-plugin.xml
new file mode 100644
index 0000000..e8bd90c
--- /dev/null
+++ b/.idea/ktlint-plugin.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="com.nbadal.ktlint.KtlintProjectSettings">
+    <ktlintMode>DISTRACT_FREE</ktlintMode>
+    <ktlintRulesetVersion>DEFAULT</ktlintRulesetVersion>
+  </component>
+</project>
\ No newline at end of file
diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt
index f05bc13..a8b0f37 100644
--- a/src/main/kotlin/Main.kt
+++ b/src/main/kotlin/Main.kt
@@ -1,6 +1,7 @@
 package org.example
 
 import Lexer
+import lexer.Lexer
 
 fun main() {
     val code = """
diff --git a/src/main/kotlin/Lexer.kt b/src/main/kotlin/lexer/Lexer.kt
similarity index 97%
rename from src/main/kotlin/Lexer.kt
rename to src/main/kotlin/lexer/Lexer.kt
index a737099..5ef87bd 100644
--- a/src/main/kotlin/Lexer.kt
+++ b/src/main/kotlin/lexer/Lexer.kt
@@ -1,3 +1,5 @@
+package lexer
+
 // a sealed class that can't be inherited and includes distinct objects for each category
 // instead of instantiating objects, we use them directly
 
@@ -60,10 +62,10 @@ class Lexer(val source: String) {
 
     // check if we are at end of the source code
     private fun isAtEnd(): Boolean {
-        if (current >= source.length) {
-            return true
+        return if (current >= source.length) {
+            true
         } else {
-            return false
+            false
         }
     }
 
diff --git a/src/main/kotlin/parser/ASTNode.kt b/src/main/kotlin/parser/ASTNode.kt
new file mode 100644
index 0000000..3fb6bf0
--- /dev/null
+++ b/src/main/kotlin/parser/ASTNode.kt
@@ -0,0 +1,3 @@
+package org.example.parser
+
+sealed class ASTNode
diff --git a/src/main/kotlin/parser/Expression.kt b/src/main/kotlin/parser/Expression.kt
new file mode 100644
index 0000000..a686694
--- /dev/null
+++ b/src/main/kotlin/parser/Expression.kt
@@ -0,0 +1,9 @@
+package org.example.parser
+
+import lexer.Token
+
+sealed class Expression : ASTNode()
+
+data class IntExpression(
+    val value: Token
+) : Expression()
diff --git a/src/main/kotlin/parser/Functions.kt b/src/main/kotlin/parser/Functions.kt
new file mode 100644
index 0000000..49b83c8
--- /dev/null
+++ b/src/main/kotlin/parser/Functions.kt
@@ -0,0 +1,8 @@
+package org.example.parser
+
+sealed class FunctionDefinition : ASTNode()
+
+data class SimpleFunction(
+    val name: Identifier,
+    val body: Statement
+) : FunctionDefinition()
diff --git a/src/main/kotlin/parser/Identifier.kt b/src/main/kotlin/parser/Identifier.kt
new file mode 100644
index 0000000..3d6eee4
--- /dev/null
+++ b/src/main/kotlin/parser/Identifier.kt
@@ -0,0 +1,7 @@
+package org.example.parser
+
+import lexer.Token
+
+data class Identifier(
+    val token: Token
+) : ASTNode()
diff --git a/src/main/kotlin/parser/Programs.kt b/src/main/kotlin/parser/Programs.kt
new file mode 100644
index 0000000..416a263
--- /dev/null
+++ b/src/main/kotlin/parser/Programs.kt
@@ -0,0 +1,7 @@
+package org.example.parser
+
+sealed class Program : ASTNode()
+
+data class SimpleProgram(
+    val functionDefinition: FunctionDefinition
+) : Program()
diff --git a/src/main/kotlin/parser/Statement.kt b/src/main/kotlin/parser/Statement.kt
new file mode 100644
index 0000000..f2eaa9a
--- /dev/null
+++ b/src/main/kotlin/parser/Statement.kt
@@ -0,0 +1,7 @@
+package org.example.parser
+
+sealed class Statement : ASTNode()
+
+data class ReturnStatement(
+    val expression: Expression
+) : Statement()
diff --git a/src/test/kotlin/LexerTest.kt b/src/test/kotlin/LexerTest.kt
index 34158b2..944d557 100644
--- a/src/test/kotlin/LexerTest.kt
+++ b/src/test/kotlin/LexerTest.kt
@@ -1,4 +1,6 @@
 
+import lexer.Lexer
+import lexer.TokenType
 import org.junit.jupiter.api.Test
 import kotlin.test.assertEquals
 

From bfd5d2d4e235c6e7461442bb232d0bd8bda89fc7 Mon Sep 17 00:00:00 2001
From: "Sidra S.Ali" <s928309@gmail.com>
Date: Sun, 27 Jul 2025 19:29:35 +0200
Subject: [PATCH 2/7] feat: Implement pretty-printing for AST nodes #4

---
 src/main/kotlin/parser/ASTNode.kt    |  5 ++++-
 src/main/kotlin/parser/Expression.kt |  6 +++++-
 src/main/kotlin/parser/Functions.kt  | 12 +++++++++++-
 src/main/kotlin/parser/Identifier.kt |  6 +++++-
 src/main/kotlin/parser/Programs.kt   | 10 +++++++++-
 src/main/kotlin/parser/Statement.kt  | 10 +++++++++-
 6 files changed, 43 insertions(+), 6 deletions(-)

diff --git a/src/main/kotlin/parser/ASTNode.kt b/src/main/kotlin/parser/ASTNode.kt
index 3fb6bf0..11f82f4 100644
--- a/src/main/kotlin/parser/ASTNode.kt
+++ b/src/main/kotlin/parser/ASTNode.kt
@@ -1,3 +1,6 @@
 package org.example.parser
 
-sealed class ASTNode
+sealed class ASTNode {
+    abstract fun prettyPrint(indent: Int = 0): String
+    fun indent(level: Int): String = "    ".repeat(level) // 4 spaces per level
+}
diff --git a/src/main/kotlin/parser/Expression.kt b/src/main/kotlin/parser/Expression.kt
index a686694..6709de6 100644
--- a/src/main/kotlin/parser/Expression.kt
+++ b/src/main/kotlin/parser/Expression.kt
@@ -6,4 +6,8 @@ sealed class Expression : ASTNode()
 
 data class IntExpression(
     val value: Token
-) : Expression()
+) : Expression() {
+    override fun prettyPrint(indent: Int): String {
+        return "${indent(indent)}Int(${value.lexeme})"
+    }
+}
diff --git a/src/main/kotlin/parser/Functions.kt b/src/main/kotlin/parser/Functions.kt
index 49b83c8..18ea668 100644
--- a/src/main/kotlin/parser/Functions.kt
+++ b/src/main/kotlin/parser/Functions.kt
@@ -5,4 +5,14 @@ sealed class FunctionDefinition : ASTNode()
 data class SimpleFunction(
     val name: Identifier,
     val body: Statement
-) : FunctionDefinition()
+) : FunctionDefinition() {
+    override fun prettyPrint(indent: Int): String {
+        return buildString {
+            appendLine("${indent(indent)}SimpleFunction(")
+            append("${indent(indent + 1)}name=${name.prettyPrint(0)}")
+            appendLine("${indent(indent + 1)}body=")
+            append("${indent(indent)}${body.prettyPrint(indent + 1)}")
+            appendLine("${indent(indent)})")
+        }
+    }
+}
diff --git a/src/main/kotlin/parser/Identifier.kt b/src/main/kotlin/parser/Identifier.kt
index 3d6eee4..788d1ba 100644
--- a/src/main/kotlin/parser/Identifier.kt
+++ b/src/main/kotlin/parser/Identifier.kt
@@ -4,4 +4,8 @@ import lexer.Token
 
 data class Identifier(
     val token: Token
-) : ASTNode()
+) : ASTNode() {
+    override fun prettyPrint(indent: Int): String {
+        return buildString { appendLine("${indent(indent)}\"${token.lexeme}\"") }
+    }
+}
diff --git a/src/main/kotlin/parser/Programs.kt b/src/main/kotlin/parser/Programs.kt
index 416a263..008cdef 100644
--- a/src/main/kotlin/parser/Programs.kt
+++ b/src/main/kotlin/parser/Programs.kt
@@ -4,4 +4,12 @@ sealed class Program : ASTNode()
 
 data class SimpleProgram(
     val functionDefinition: FunctionDefinition
-) : Program()
+) : Program() {
+    override fun prettyPrint(indent: Int): String {
+        return buildString {
+            appendLine("${indent(indent)}SimpleProgram(")
+            append(functionDefinition.prettyPrint(indent + 1))
+            appendLine("${indent(indent)})")
+        }
+    }
+}
diff --git a/src/main/kotlin/parser/Statement.kt b/src/main/kotlin/parser/Statement.kt
index f2eaa9a..64e1866 100644
--- a/src/main/kotlin/parser/Statement.kt
+++ b/src/main/kotlin/parser/Statement.kt
@@ -4,4 +4,12 @@ sealed class Statement : ASTNode()
 
 data class ReturnStatement(
     val expression: Expression
-) : Statement()
+) : Statement() {
+    override fun prettyPrint(indent: Int): String {
+        return buildString {
+            appendLine("${indent(indent)}ReturnStatement(")
+            appendLine(expression.prettyPrint(indent + 1))
+            appendLine("${indent(indent)})")
+        }
+    }
+}

From cc5e8c666e774111e8be89f75c22a98455559464 Mon Sep 17 00:00:00 2001
From: "Sidra S.Ali" <s928309@gmail.com>
Date: Sun, 27 Jul 2025 19:30:57 +0200
Subject: [PATCH 3/7] feat: Implement parsing for a simple AST definition #4

---
 src/main/kotlin/Exceptions/SyntaxError.kt | 20 +++++
 src/main/kotlin/Main.kt                   | 19 +++--
 src/main/kotlin/parser/Parser.kt          | 91 +++++++++++++++++++++++
 3 files changed, 122 insertions(+), 8 deletions(-)
 create mode 100644 src/main/kotlin/Exceptions/SyntaxError.kt
 create mode 100644 src/main/kotlin/parser/Parser.kt

diff --git a/src/main/kotlin/Exceptions/SyntaxError.kt b/src/main/kotlin/Exceptions/SyntaxError.kt
new file mode 100644
index 0000000..795a668
--- /dev/null
+++ b/src/main/kotlin/Exceptions/SyntaxError.kt
@@ -0,0 +1,20 @@
+package org.example.Exceptions
+
+class SyntaxError(
+    message: String,
+    val line: Int? = null,
+    val column: Int? = null
+) : Exception(buildMessage(message, line, column)) {
+    companion object {
+        private fun buildMessage(
+            message: String,
+            line: Int?,
+            column: Int?
+        ): String =
+            when {
+                line != null && column != null -> "Syntax error at line $line, column $column: $message"
+                line != null -> "Syntax error at line $line: $message"
+                else -> "Syntax error: $message"
+            }
+    }
+}
diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt
index a8b0f37..50305ce 100644
--- a/src/main/kotlin/Main.kt
+++ b/src/main/kotlin/Main.kt
@@ -1,16 +1,15 @@
 package org.example
 
-import Lexer
 import lexer.Lexer
+import org.example.parser.Parser
 
 fun main() {
-    val code = """
-    int main(void){
-    int x = 5
-    int y = 3
-    int z = 5+3
-    }
-    """.trimIndent()
+    val code =
+        """
+        int main(void){
+        return 5;
+        }
+        """.trimIndent()
     val lexer = Lexer(code)
     val tokens = lexer.tokenize()
     tokens.forEach { token ->
@@ -20,4 +19,8 @@ fun main() {
                 "Position: [L:${token.line}, C:${token.column}]"
         )
     }
+
+    val parser = Parser()
+    val ast = parser.parseTokens(tokens)
+    println(ast.prettyPrint())
 }
diff --git a/src/main/kotlin/parser/Parser.kt b/src/main/kotlin/parser/Parser.kt
new file mode 100644
index 0000000..c478469
--- /dev/null
+++ b/src/main/kotlin/parser/Parser.kt
@@ -0,0 +1,91 @@
+package org.example.parser
+
+import lexer.Token
+import lexer.TokenType
+import org.example.Exceptions.SyntaxError
+
+class Parser {
+    fun parseTokens(tokens: List<Token>): ASTNode {
+        val tokens = tokens.toMutableList()
+        val ast = parseProgram(tokens)
+
+        val lastToken = tokens.removeFirst()
+        if (lastToken.type != TokenType.EOF) {
+            throw SyntaxError(
+                line = lastToken.line,
+                column = lastToken.column,
+                message = "Expected end of file"
+            )
+        }
+        return ast
+    }
+
+    private fun parseProgram(tokens: MutableList<Token>): SimpleProgram {
+        val function = parseFunction(tokens)
+
+        return SimpleProgram(functionDefinition = function)
+    }
+
+    private fun parseFunction(tokens: MutableList<Token>): FunctionDefinition {
+        expect(TokenType.KEYWORD_INT, tokens)
+        val name = parseIdentifier(tokens)
+        expect(TokenType.LEFT_PAREN, tokens)
+        expect(TokenType.KEYWORD_VOID, tokens)
+        expect(TokenType.RIGHT_PAREN, tokens)
+        expect(TokenType.LEFT_BRACK, tokens)
+        val body = parseStatement(tokens)
+        expect(TokenType.RIGHT_BRACK, tokens)
+
+        return SimpleFunction(name = name, body = body)
+    }
+
+    private fun expect(
+        expected: TokenType,
+        tokens: MutableList<Token>
+    ): Token {
+        val token = tokens.removeFirst()
+
+        if (token.type != expected) {
+            throw SyntaxError(
+                line = token.line,
+                column = token.column,
+                message = "Expected token: $expected, got ${token.type}"
+            )
+        }
+
+        return token
+    }
+
+    private fun parseIdentifier(tokens: MutableList<Token>): Identifier {
+        val token = tokens.removeFirst()
+        if (token.type != TokenType.IDENTIFIER) {
+            throw SyntaxError(
+                line = token.line,
+                column = token.column,
+                message = "Expected token: ${TokenType.IDENTIFIER}, got ${token.type}"
+            )
+        }
+
+        return Identifier(token = token)
+    }
+
+    private fun parseStatement(tokens: MutableList<Token>): Statement {
+        expect(TokenType.KEYWORD_RETURN, tokens)
+        val expression = parseExpression(tokens)
+        expect(TokenType.SEMICOLON, tokens)
+
+        return ReturnStatement(expression = expression)
+    }
+
+    private fun parseExpression(tokens: MutableList<Token>): Expression {
+        val token = tokens.removeFirst()
+        if (token.type != TokenType.INT_LITERAL) {
+            throw SyntaxError(
+                line = token.line,
+                column = token.column,
+                message = "Expected token: ${TokenType.INT_LITERAL}, got ${token.type}"
+            )
+        }
+        return IntExpression(value = token)
+    }
+}

From dd8456ac91394da79b0b0a6e0e3a1f3fb6fb4b17 Mon Sep 17 00:00:00 2001
From: "Sidra S.Ali" <s928309@gmail.com>
Date: Sun, 27 Jul 2025 20:45:25 +0200
Subject: [PATCH 4/7] feat: Add unit tests for the parser #4

---
 src/test/kotlin/parser/ParserTest.kt | 167 +++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
 create mode 100644 src/test/kotlin/parser/ParserTest.kt

diff --git a/src/test/kotlin/parser/ParserTest.kt b/src/test/kotlin/parser/ParserTest.kt
new file mode 100644
index 0000000..9287407
--- /dev/null
+++ b/src/test/kotlin/parser/ParserTest.kt
@@ -0,0 +1,167 @@
+package parser
+
+import lexer.Token
+import lexer.TokenType
+import org.example.Exceptions.SyntaxError
+import org.example.parser.Parser
+import org.example.parser.SimpleProgram
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+
+class ParserTest {
+
+    @Test
+    fun `test basic program parsing`() {
+        // Create a list of tokens for a simple program: int main(void) { return 42; }
+        val tokens = listOf(
+            Token(TokenType.KEYWORD_INT, "int", 1, 1),
+            Token(TokenType.IDENTIFIER, "main", 1, 5),
+            Token(TokenType.LEFT_PAREN, "(", 1, 9),
+            Token(TokenType.KEYWORD_VOID, "void", 1, 10),
+            Token(TokenType.RIGHT_PAREN, ")", 1, 14),
+            Token(TokenType.LEFT_BRACK, "{", 1, 16),
+            Token(TokenType.KEYWORD_RETURN, "return", 1, 18),
+            Token(TokenType.INT_LITERAL, "42", 1, 25),
+            Token(TokenType.SEMICOLON, ";", 1, 27),
+            Token(TokenType.RIGHT_BRACK, "}", 1, 29),
+            Token(TokenType.EOF, "", 1, 30)
+        )
+
+        val parser = Parser()
+        val ast = parser.parseTokens(tokens)
+
+        // Verify the AST structure
+        assertIs<SimpleProgram>(ast)
+    }
+
+    @Test
+    fun `test detailed AST structure`() {
+        // Create a list of tokens for a simple program: int main(void) { return 42; }
+        val tokens = listOf(
+            Token(TokenType.KEYWORD_INT, "int", 1, 1),
+            Token(TokenType.IDENTIFIER, "main", 1, 5),
+            Token(TokenType.LEFT_PAREN, "(", 1, 9),
+            Token(TokenType.KEYWORD_VOID, "void", 1, 10),
+            Token(TokenType.RIGHT_PAREN, ")", 1, 14),
+            Token(TokenType.LEFT_BRACK, "{", 1, 16),
+            Token(TokenType.KEYWORD_RETURN, "return", 1, 18),
+            Token(TokenType.INT_LITERAL, "42", 1, 25),
+            Token(TokenType.SEMICOLON, ";", 1, 27),
+            Token(TokenType.RIGHT_BRACK, "}", 1, 29),
+            Token(TokenType.EOF, "", 1, 30)
+        )
+
+        val parser = Parser()
+        val ast = parser.parseTokens(tokens)
+
+        // Verify the AST structure in detail
+        assertIs<SimpleProgram>(ast)
+        val program = ast
+
+        // Check function definition
+        val function = program.functionDefinition
+        assertIs<org.example.parser.SimpleFunction>(function)
+        val simpleFunction = function
+
+        // Check function name
+        assertEquals("main", simpleFunction.name.token.lexeme)
+
+        // Check return statement
+        val returnStatement = simpleFunction.body
+        assertIs<org.example.parser.ReturnStatement>(returnStatement)
+        val returnStmt = returnStatement
+
+        // Check return expression
+        val expression = returnStmt.expression
+        assertIs<org.example.parser.IntExpression>(expression)
+        val intExpr = expression
+        assertEquals("42", intExpr.value.lexeme)
+    }
+
+    @Test
+    fun `test syntax error - missing int keyword`() {
+        // Missing the int keyword at the beginning
+        val tokens = listOf(
+            Token(TokenType.IDENTIFIER, "main", 1, 1),
+            Token(TokenType.LEFT_PAREN, "(", 1, 5),
+            Token(TokenType.KEYWORD_VOID, "void", 1, 6),
+            Token(TokenType.RIGHT_PAREN, ")", 1, 10),
+            Token(TokenType.LEFT_BRACK, "{", 1, 12),
+            Token(TokenType.KEYWORD_RETURN, "return", 1, 14),
+            Token(TokenType.INT_LITERAL, "42", 1, 21),
+            Token(TokenType.SEMICOLON, ";", 1, 23),
+            Token(TokenType.RIGHT_BRACK, "}", 1, 25),
+            Token(TokenType.EOF, "", 1, 26)
+        )
+
+        val parser = Parser()
+        val exception = assertThrows<SyntaxError> {
+            parser.parseTokens(tokens)
+        }
+
+        // Check that the error message contains the expected text
+        assert(exception.message!!.contains("Expected token: KEYWORD_INT, got IDENTIFIER"))
+        assertEquals(1, exception.line)
+        assertEquals(1, exception.column)
+    }
+
+    @Test
+    fun `test syntax error - missing return keyword`() {
+        // Missing the return keyword
+        val tokens = listOf(
+            Token(TokenType.KEYWORD_INT, "int", 1, 1),
+            Token(TokenType.IDENTIFIER, "main", 1, 5),
+            Token(TokenType.LEFT_PAREN, "(", 1, 9),
+            Token(TokenType.KEYWORD_VOID, "void", 1, 10),
+            Token(TokenType.RIGHT_PAREN, ")", 1, 14),
+            Token(TokenType.LEFT_BRACK, "{", 1, 16),
+            // Missing KEYWORD_RETURN here
+            Token(TokenType.INT_LITERAL, "42", 1, 18),
+            Token(TokenType.SEMICOLON, ";", 1, 20),
+            Token(TokenType.RIGHT_BRACK, "}", 1, 22),
+            Token(TokenType.EOF, "", 1, 23)
+        )
+
+        val parser = Parser()
+        val exception = assertThrows<SyntaxError> {
+            parser.parseTokens(tokens)
+        }
+
+        // Check that the error message contains the expected text
+        assert(exception.message!!.contains("Expected token: KEYWORD_RETURN, got INT_LITERAL"))
+        assertEquals(1, exception.line)
+        assertEquals(18, exception.column)
+    }
+
+    @Test
+    fun `test syntax error - extra tokens after program`() {
+        // Extra tokens after the program
+        val tokens = listOf(
+            Token(TokenType.KEYWORD_INT, "int", 1, 1),
+            Token(TokenType.IDENTIFIER, "main", 1, 5),
+            Token(TokenType.LEFT_PAREN, "(", 1, 9),
+            Token(TokenType.KEYWORD_VOID, "void", 1, 10),
+            Token(TokenType.RIGHT_PAREN, ")", 1, 14),
+            Token(TokenType.LEFT_BRACK, "{", 1, 16),
+            Token(TokenType.KEYWORD_RETURN, "return", 1, 18),
+            Token(TokenType.INT_LITERAL, "42", 1, 25),
+            Token(TokenType.SEMICOLON, ";", 1, 27),
+            Token(TokenType.RIGHT_BRACK, "}", 1, 29),
+            // Extra tokens here
+            Token(TokenType.IDENTIFIER, "extra", 1, 31),
+            Token(TokenType.EOF, "", 1, 36)
+        )
+
+        val parser = Parser()
+        val exception = assertThrows<SyntaxError> {
+            parser.parseTokens(tokens)
+        }
+
+        // Check that the error message contains the expected text
+        assert(exception.message!!.contains("Expected end of file"))
+        assertEquals(1, exception.line)
+        assertEquals(31, exception.column)
+    }
+}

From 0674cc662291906a5970692f10b5a4657ce6944d Mon Sep 17 00:00:00 2001
From: "Sidra S.Ali" <s928309@gmail.com>
Date: Mon, 28 Jul 2025 11:17:20 +0200
Subject: [PATCH 5/7] chore: Cache gradle dependencies #4

---
 .github/workflows/kotlin-checks.yml | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/kotlin-checks.yml b/.github/workflows/kotlin-checks.yml
index 93ff4a3..5e04024 100644
--- a/.github/workflows/kotlin-checks.yml
+++ b/.github/workflows/kotlin-checks.yml
@@ -19,14 +19,19 @@ jobs:
           distribution: 'temurin'
           cache: gradle
           
+      - name: Cache Gradle dependencies
+        uses: actions/cache@v3
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
         
       - name: Build with Gradle
         run: ./gradlew build
         
-      - name: Run ktlint
-        run: ./gradlew ktlintCheck
-        
       - name: Kotlin Kover
         run: ./gradlew koverXmlReport

From 7982069039d69de37173b155f6ed642232605c18 Mon Sep 17 00:00:00 2001
From: "Sidra S.Ali" <s928309@gmail.com>
Date: Mon, 28 Jul 2025 11:17:59 +0200
Subject: [PATCH 6/7] chore: Enable single class imports #4

---
 .idea/inspectionProfiles/Project_Default.xml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index 5b03e1e..40927b2 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -31,6 +31,7 @@
     <inspection_tool class="ReplaceCollectionCountWithSize" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="ReplaceNotNullAssertionWithElvisReturn" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="RestrictReturnStatementTargetMigration" enabled="true" level="ERROR" enabled_by_default="true" />
+    <inspection_tool class="SingleClassImport" enabled="true" level="INFORMATION" enabled_by_default="true" editorAttributes="INFORMATION_ATTRIBUTES" />
     <inspection_tool class="UnusedMainParameter" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="WarningOnMainUnusedParameterMigration" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="WhenWithOnlyElse" enabled="true" level="WEAK WARNING" enabled_by_default="true" />

From eb7b2d50478743d9d6da19fdcde1bab0e013180e Mon Sep 17 00:00:00 2001
From: "Sidra S.Ali" <s928309@gmail.com>
Date: Mon, 28 Jul 2025 11:18:31 +0200
Subject: [PATCH 7/7] feat: Add integration test for lexer and parser #4

---
 .../integration/LexerParserIntegrationTest.kt | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 src/test/kotlin/integration/LexerParserIntegrationTest.kt

diff --git a/src/test/kotlin/integration/LexerParserIntegrationTest.kt b/src/test/kotlin/integration/LexerParserIntegrationTest.kt
new file mode 100644
index 0000000..30a7918
--- /dev/null
+++ b/src/test/kotlin/integration/LexerParserIntegrationTest.kt
@@ -0,0 +1,48 @@
+package integration
+
+import lexer.Lexer
+import org.example.parser.IntExpression
+import org.example.parser.Parser
+import org.example.parser.ReturnStatement
+import org.example.parser.SimpleFunction
+import org.example.parser.SimpleProgram
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+
+class LexerParserIntegrationTest {
+
+    @Test
+    fun `test lexer and parser integration`() {
+        // Source code for a simple program
+        val source = "int main(void) { return 42; }"
+
+        // Use the lexer to tokenize the source
+        val lexer = Lexer(source)
+        val tokens = lexer.tokenize()
+
+        // Parse the tokens
+        val parser = Parser()
+        val ast = parser.parseTokens(tokens)
+
+        // Verify the AST structure
+        assertIs<SimpleProgram>(ast)
+        val program = ast
+
+        // Check function name
+        val function = program.functionDefinition
+        assertIs<SimpleFunction>(function)
+        val simpleFunction = function
+        assertEquals("main", simpleFunction.name.token.lexeme)
+
+        // Check return value
+        val returnStatement = simpleFunction.body
+        assertIs<ReturnStatement>(returnStatement)
+        val returnStmt = returnStatement
+
+        val expression = returnStmt.expression
+        assertIs<IntExpression>(expression)
+        val intExpr = expression
+        assertEquals("42", intExpr.value.lexeme)
+    }
+}