Test/TestParser.hs

@@ -50,23 +50,23 @@ testClassWithMethodAndField = TestCase $
     assertEqual "expect class with method and field" [Class "WithMethodAndField" [MethodDeclaration "void" "foo" [] (Block []), MethodDeclaration "int" "bar" [] (Block [])] [VariableDeclaration "int" "value" Nothing]] $
     parse [CLASS,IDENTIFIER "WithMethodAndField",LBRACKET,VOID,IDENTIFIER "foo",LBRACE,RBRACE,LBRACKET,RBRACKET,INT,IDENTIFIER "value",SEMICOLON,INT,IDENTIFIER "bar",LBRACE,RBRACE,SEMICOLON,RBRACKET]
 testClassWithConstructor = TestCase $
-    assertEqual "expect class with constructor" [Class "WithConstructor" [MethodDeclaration "void" "<init>" [] (Block [])] []] $
+    assertEqual "expect class with constructor" [Class "WithConstructor" [MethodDeclaration "WithConstructor" "<init>" [] (Block [])] []] $
     parse [CLASS,IDENTIFIER "WithConstructor",LBRACKET,IDENTIFIER "WithConstructor",LBRACE,RBRACE,LBRACKET,RBRACKET,RBRACKET]
 
 
-testEmptyBlock = TestCase $ assertEqual "expect empty block" [Block []] $ parseStatement [LBRACKET,RBRACKET]
+testEmptyBlock = TestCase $ assertEqual "expect empty block" (Block []) $ parseBlock [LBRACKET,RBRACKET]
 testBlockWithLocalVarDecl = TestCase $
-    assertEqual "expect block with local var delcaration" [Block [LocalVariableDeclaration $ VariableDeclaration "int" "localvar" Nothing]] $
-    parseStatement [LBRACKET,INT,IDENTIFIER "localvar",SEMICOLON,RBRACKET]
+    assertEqual "expect block with local var delcaration" (Block [LocalVariableDeclaration $ VariableDeclaration "int" "localvar" Nothing]) $
+    parseBlock [LBRACKET,INT,IDENTIFIER "localvar",SEMICOLON,RBRACKET]
 testBlockWithMultipleLocalVarDecls = TestCase $
-    assertEqual "expect block with multiple local var declarations" [Block [LocalVariableDeclaration $ VariableDeclaration "int" "var1" Nothing, LocalVariableDeclaration $ VariableDeclaration "boolean" "var2" Nothing]] $
-    parseStatement [LBRACKET,INT,IDENTIFIER "var1",SEMICOLON,BOOLEAN,IDENTIFIER "var2",SEMICOLON,RBRACKET]
+    assertEqual "expect block with multiple local var declarations" (Block [LocalVariableDeclaration $ VariableDeclaration "int" "var1" Nothing, LocalVariableDeclaration $ VariableDeclaration "boolean" "var2" Nothing]) $
+    parseBlock [LBRACKET,INT,IDENTIFIER "var1",SEMICOLON,BOOLEAN,IDENTIFIER "var2",SEMICOLON,RBRACKET]
 testNestedBlocks = TestCase $
-    assertEqual "expect block with block inside" [Block [Block []]] $
-    parseStatement [LBRACKET,LBRACKET,RBRACKET,RBRACKET]
+    assertEqual "expect block with block inside" (Block [Block []]) $
+    parseBlock [LBRACKET,LBRACKET,RBRACKET,RBRACKET]
 testBlockWithEmptyStatement = TestCase $
-    assertEqual "expect empty block" [Block []] $
-    parseStatement [LBRACKET,SEMICOLON,SEMICOLON,RBRACKET]
+    assertEqual "expect empty block" (Block []) $
+    parseBlock [LBRACKET,SEMICOLON,SEMICOLON,RBRACKET]
 
 testExpressionIntLiteral = TestCase $
     assertEqual "expect IntLiteral" (IntegerLiteral 3) $
@@ -75,14 +75,14 @@ testFieldWithInitialization = TestCase $
     assertEqual "expect Class with initialized field" [Class "WithInitField" [] [VariableDeclaration "int" "number" $ Just $ IntegerLiteral 3]] $
     parse [CLASS,IDENTIFIER "WithInitField",LBRACKET,INT,IDENTIFIER "number",ASSIGN,INTEGERLITERAL 3,SEMICOLON,RBRACKET]
 testLocalBoolWithInitialization = TestCase $
-    assertEqual "expect block with with initialized local var" [Block [LocalVariableDeclaration $ VariableDeclaration "boolean" "b" $ Just $ BooleanLiteral False]] $
-    parseStatement [LBRACKET,BOOLEAN,IDENTIFIER "b",ASSIGN,BOOLLITERAL False,SEMICOLON,RBRACKET]
+    assertEqual "expect block with with initialized local var" (Block [LocalVariableDeclaration $ VariableDeclaration "boolean" "b" $ Just $ BooleanLiteral False]) $
+    parseBlock [LBRACKET,BOOLEAN,IDENTIFIER "b",ASSIGN,BOOLLITERAL False,SEMICOLON,RBRACKET]
 testFieldNullWithInitialization = TestCase $
     assertEqual "expect Class with initialized field" [Class "WithInitField" [] [VariableDeclaration "Object" "bar" $ Just NullLiteral]] $
     parse [CLASS,IDENTIFIER "WithInitField",LBRACKET,IDENTIFIER "Object",IDENTIFIER "bar",ASSIGN,NULLLITERAL,SEMICOLON,RBRACKET]
 testReturnVoid = TestCase $
-    assertEqual "expect block with return nothing" [Block [Return Nothing]] $
-    parseStatement [LBRACKET,RETURN,SEMICOLON,RBRACKET]
+    assertEqual "expect block with return nothing" (Block [Return Nothing]) $
+    parseBlock [LBRACKET,RETURN,SEMICOLON,RBRACKET]
 
 testExpressionNot = TestCase $
     assertEqual "expect expression not" (UnaryOperation Not (Reference "boar")) $
@@ -132,18 +132,6 @@ testExpressionXor = TestCase $
 testExpressionOr = TestCase $
     assertEqual "expect or expression" (BinaryOperation Or (Reference "bar") (Reference "baz")) $
     parseExpression [IDENTIFIER "bar",OR,IDENTIFIER "baz"]
-testExpressionPostIncrement = TestCase $
-    assertEqual "expect PostIncrement" (UnaryOperation PostIncrement (Reference "a")) $
-    parseExpression [IDENTIFIER "a",INCREMENT]
-testExpressionPostDecrement = TestCase $
-    assertEqual "expect PostDecrement" (UnaryOperation PostDecrement (Reference "a")) $
-    parseExpression [IDENTIFIER "a",DECREMENT]
-testExpressionPreIncrement = TestCase $
-    assertEqual "expect PreIncrement" (UnaryOperation PreIncrement (Reference "a")) $
-    parseExpression [INCREMENT,IDENTIFIER "a"]
-testExpressionPreDecrement = TestCase $
-    assertEqual "expect PreIncrement" (UnaryOperation PreDecrement (Reference "a")) $
-    parseExpression [DECREMENT,IDENTIFIER "a"]
 
 
 tests = TestList [
@@ -181,9 +169,5 @@ tests = TestList [
     testExpressionNotEqual,
     testExpressionAnd,
     testExpressionXor,
-    testExpressionOr,
-    testExpressionPostIncrement,
-    testExpressionPostDecrement,
-    testExpressionPreIncrement,
-    testExpressionPreDecrement
+    testExpressionOr
     ]

src/Ast.hs

@@ -20,7 +20,7 @@ data Statement
   deriving (Show, Eq)
 
 data StatementExpression
-  = Assignment Expression Expression
+  = Assignment Identifier Expression
   | ConstructorCall DataType [Expression]
   | MethodCall Expression Identifier [Expression]
   | TypedStatementExpression DataType StatementExpression
@@ -49,10 +49,6 @@ data BinaryOperator
 data UnaryOperator
   = Not
   | Minus
-  | PostIncrement
-  | PostDecrement
-  | PreIncrement
-  | PreDecrement
   deriving (Show, Eq)
 
 data Expression

src/ByteCode/ClassFile/Generator.hs

@@ -206,7 +206,7 @@ assembleMethod (MethodDeclaration _ name _ (TypedStatement _ (Block statements))
             (constants_a, ops_a) = foldr assembleStatement (constants, ops) statements
             init_ops = [Opaload 0, Opinvokespecial 2]
         in
-            (constants_a, init_ops ++ ops_a ++ [Opreturn])
+            (constants_a, init_ops ++ ops_a)
     | otherwise = let
             (constants_a, ops_a) = foldr assembleStatement (constants, ops) statements
             init_ops = [Opaload 0]
@@ -221,15 +221,6 @@ assembleStatement (TypedStatement stype (Return expr)) (constants, ops) = case e
             (expr_constants, expr_ops) = assembleExpression expr (constants, ops)
         in  
             (expr_constants, expr_ops ++ [returnOperation stype])
-assembleStatement (TypedStatement _ (Block statements)) (constants, ops) =
-    foldr assembleStatement (constants, ops) statements
-assembleStatement (TypedStatement _ (If expr if_stmt else_stmt)) (constants, ops) = let
-        (constants_cmp, ops_cmp) = assembleExpression expr (constants, [])
-        (constants_ifa, ops_ifa) = assembleStatement if_stmt (constants_cmp, [])
-        skip_length = sum (map opcodeEncodingLength ops_ifa)
-    in
-        (constants_ifa, ops ++ ops_cmp ++ [Opsipush 0, Opif_icmpeq skip_length] ++ ops_ifa)
-
 
 assembleExpression :: Assembler Expression
 assembleExpression (TypedExpression _ (BinaryOperation op a b)) (constants, ops)

src/Example.hs

@@ -49,7 +49,7 @@ exampleExpression :: Expression
 exampleExpression = BinaryOperation NameResolution (Reference "bob") (Reference "age")
 
 exampleAssignment :: Expression
-exampleAssignment = StatementExpressionExpression (Assignment (Reference "a") (IntegerLiteral 30))
+exampleAssignment = StatementExpressionExpression (Assignment "a" (IntegerLiteral 30))
 
 exampleMethodCall :: Statement
 exampleMethodCall = StatementExpressionStatement (MethodCall (Reference "this") "setAge" [IntegerLiteral 30])
@@ -58,7 +58,7 @@ exampleConstructorCall :: Statement
 exampleConstructorCall = LocalVariableDeclaration (VariableDeclaration "Person" "bob" (Just (StatementExpressionExpression  (ConstructorCall "Person" [IntegerLiteral 30]))))
 
 exampleNameResolution :: Expression
-exampleNameResolution = BinaryOperation NameResolution (Reference "bob2") (Reference "age")
+exampleNameResolution = BinaryOperation NameResolution (Reference "b") (Reference "age")
 
 exampleBlockResolution :: Statement
 exampleBlockResolution = Block [
@@ -80,7 +80,7 @@ exampleMethodCallAndAssignment = Block [
     LocalVariableDeclaration (VariableDeclaration "int" "age" (Just (StatementExpressionExpression (MethodCall (Reference "bob") "getAge" [])))),
     StatementExpressionStatement (MethodCall (Reference "bob") "setAge" [IntegerLiteral 30]),
     LocalVariableDeclaration (VariableDeclaration "int" "a" Nothing),
-    StatementExpressionStatement (Assignment (Reference "a") (Reference "age"))
+    StatementExpressionStatement (Assignment "a" (Reference "age"))
     ]
 
 
@@ -89,18 +89,9 @@ exampleMethodCallAndAssignmentFail = Block [
     LocalVariableDeclaration (VariableDeclaration "Person" "bob" (Just (StatementExpressionExpression  (ConstructorCall "Person" [IntegerLiteral 30])))),
     LocalVariableDeclaration (VariableDeclaration "int" "age" (Just (StatementExpressionExpression (MethodCall (Reference "bob") "getAge" [])))),
     StatementExpressionStatement (MethodCall (Reference "bob") "setAge" [IntegerLiteral 30]),
-    StatementExpressionStatement (Assignment (Reference "a") (Reference "age"))
+    StatementExpressionStatement (Assignment "a" (Reference "age"))
     ]
 
-exampleNameResolutionAssignment :: Statement
-exampleNameResolutionAssignment = Block [
-    LocalVariableDeclaration (VariableDeclaration "Person" "bob" (Just (StatementExpressionExpression  (ConstructorCall "Person" [IntegerLiteral 30])))),
-    StatementExpressionStatement (Assignment (BinaryOperation NameResolution (Reference "bob") (Reference "age")) (IntegerLiteral 30))
-    ]
-
-exampleCharIntOperation :: Expression
-exampleCharIntOperation = BinaryOperation Addition (CharacterLiteral 'a') (IntegerLiteral 1)
-
 testClasses :: [Class]
 testClasses = [
     Class "Person" [
@@ -122,12 +113,10 @@ testClasses = [
         (Block [
             LocalVariableDeclaration (VariableDeclaration "Person" "bob" (Just (StatementExpressionExpression (ConstructorCall "Person" [IntegerLiteral 25])))),
             StatementExpressionStatement (MethodCall (Reference "bob") "setAge" [IntegerLiteral 30]),
-            LocalVariableDeclaration (VariableDeclaration "int" "bobAge" (Just (StatementExpressionExpression (MethodCall (Reference "bob2") "getAge" [])))),
+            LocalVariableDeclaration (VariableDeclaration "int" "bobAge" (Just (StatementExpressionExpression (MethodCall (Reference "bob") "getAge" [])))),
             Return (Just (Reference "bobAge"))
         ])
-    ] [
-        VariableDeclaration "Person" "bob2" Nothing
-    ]
+    ] []
  ]
 
 runTypeCheck :: IO ()
@@ -162,7 +151,7 @@ runTypeCheck = do
 
     catch (do
         print "====================================================================================="
-        evaluatedNameResolution <- evaluate (typeCheckExpression exampleNameResolution [("this", "Main")] testClasses)
+        evaluatedNameResolution <- evaluate (typeCheckExpression exampleNameResolution [("b", "Person")] sampleClasses)
         printSuccess "Type checking of name resolution completed successfully"
         printResult "Result Name Resolution:" evaluatedNameResolution
       ) handleError
@@ -200,7 +189,7 @@ runTypeCheck = do
         let mainClass = fromJust $ find (\(Class className _ _) -> className == "Main") testClasses
         case mainClass of
             Class _ [mainMethod] _ -> do
-                let result = typeCheckMethodDeclaration mainMethod [("this", "Main")] testClasses
+                let result = typeCheckMethodDeclaration mainMethod [] testClasses
                 printSuccess "Full program type checking completed successfully."
                 printResult "Main method result:" result
       ) handleError
@@ -211,18 +200,4 @@ runTypeCheck = do
         printSuccess "Type checking of Program completed successfully"
         printResult "Typed Program:" typedProgram
         ) handleError
-    
-    catch (do
-        print "====================================================================================="
-        typedAssignment <- evaluate (typeCheckStatement exampleNameResolutionAssignment [] sampleClasses)
-        printSuccess "Type checking of name resolution assignment completed successfully"
-        printResult "Result Name Resolution Assignment:" typedAssignment
-        ) handleError
-
-    catch (do
-        print "====================================================================================="
-        evaluatedCharIntOperation <- evaluate (typeCheckExpression exampleCharIntOperation [] sampleClasses)
-        printSuccess "Type checking of char int operation completed successfully"
-        printResult "Result Char Int Operation:" evaluatedCharIntOperation
-        ) handleError
 

src/Main.hs

@@ -9,9 +9,7 @@ import ByteCode.ClassFile
 import Data.ByteString (pack, writeFile)
 
 main = do
-    file <- readFile "Testklasse.java"
-
-    let untypedAST = parse $ alexScanTokens file
+    let untypedAST = parse $ alexScanTokens "class Testklasse {Testklasse(){} boolean something(){return 5 + 8 - 12 * 22 > 9 - 2 + 3;}}"
     let typedAST = head (typeCheckCompilationUnit untypedAST)
     let abstractClassFile = classBuilder typedAST emptyClassFile
     let assembledClassFile = pack (serialize abstractClassFile)

src/Parser/JavaParser.y

@@ -1,11 +1,11 @@
 {
-module Parser.JavaParser (parse, parseStatement, parseExpression) where
+module Parser.JavaParser (parse, parseBlock, parseExpression) where
 import Ast
 import Parser.Lexer
 }
 
 %name parse
-%name parseStatement statement
+%name parseBlock block
 %name parseExpression expression
 %tokentype { Token }
 %error { parseError }
@@ -127,8 +127,8 @@ classorinterfacetype : name { $1 }
 classmemberdeclaration : fielddeclaration { $1 }
                  | methoddeclaration { $1 }
 
-constructordeclaration : constructordeclarator constructorbody { case $1 of (classname, parameters) -> MethodDecl $ MethodDeclaration "void" "<init>" parameters $2 }
-                 |  modifiers constructordeclarator constructorbody { case $2 of (classname, parameters) -> MethodDecl $ MethodDeclaration "void" "<init>" parameters $3 }
+constructordeclaration : constructordeclarator constructorbody { case $1 of (classname, parameters) -> MethodDecl $ MethodDeclaration classname "<init>" parameters $2 }
+                 |  modifiers constructordeclarator constructorbody { case $2 of (classname, parameters) -> MethodDecl $ MethodDeclaration classname "<init>" parameters $3 }
 
 fielddeclaration : type variabledeclarators  SEMICOLON { FieldDecls $ map (convertDeclarator $1) $2 }
                  | modifiers type variabledeclarators  SEMICOLON { FieldDecls $ map (convertDeclarator $2) $3 }
@@ -275,13 +275,13 @@ assignmentoperator : ASSIGN{ }
                 --  | XOREQUAL { }
                 --  | OREQUAL{ }
 
-preincrementexpression : INCREMENT unaryexpression { UnaryOperation PreIncrement $2 }
+preincrementexpression : INCREMENT unaryexpression { }
 
-predecrementexpression : DECREMENT unaryexpression { UnaryOperation PreDecrement $2 }
+predecrementexpression : DECREMENT unaryexpression { }
 
-postincrementexpression : postfixexpression INCREMENT { UnaryOperation PostIncrement $1 }
+postincrementexpression : postfixexpression INCREMENT { }
 
-postdecrementexpression : postfixexpression DECREMENT { UnaryOperation PostDecrement $1 }
+postdecrementexpression : postfixexpression DECREMENT { }
 
 methodinvocation : name LBRACE   RBRACE  { }
                  | name LBRACE argumentlist RBRACE { }
@@ -296,15 +296,15 @@ conditionalandexpression : inclusiveorexpression { $1 }
 fieldaccess      : primary  DOT IDENTIFIER { }
 
 unaryexpression         : unaryexpressionnotplusminus { $1 }
-                 | predecrementexpression { $1 }
+                --  | predecrementexpression { }
                  | PLUS unaryexpression { $2 }
                  | MINUS unaryexpression { UnaryOperation Minus $2 }
-                 | preincrementexpression { $1 }
+                --  | preincrementexpression { $1 }
 
 postfixexpression : primary { $1 }
                  | name { Reference $1 }
-                 | postincrementexpression { $1 }
-                 | postdecrementexpression{ $1 }
+                --  | postincrementexpression { }
+                --  | postdecrementexpression{ }
 
 primary                 : primarynonewarray { $1 }
 

src/Typecheck.hs

@@ -10,9 +10,9 @@ typeCheckClass :: Class -> [Class] -> Class
 typeCheckClass (Class className methods fields) classes =
     let
         -- Create a symbol table from class fields and method entries
-        -- TODO: Maybe remove method entries from the symbol table?
+        classFields = [(id, dt) | VariableDeclaration dt id _ <- fields]
         methodEntries = [(methodName, className) | MethodDeclaration _ methodName _ _ <- methods]
-        initalSymTab = ("this", className) : methodEntries
+        initalSymTab = ("this", className) : classFields ++ methodEntries
         checkedMethods = map (\method -> typeCheckMethodDeclaration method initalSymTab classes) methods
     in Class className checkedMethods fields
 
@@ -37,46 +37,118 @@ typeCheckExpression (CharacterLiteral c) _ _ = TypedExpression "char" (Character
 typeCheckExpression (BooleanLiteral b) _ _ = TypedExpression "boolean" (BooleanLiteral b)
 typeCheckExpression NullLiteral _ _ = TypedExpression "null" NullLiteral
 typeCheckExpression (Reference id) symtab classes =
-  case lookup id symtab of
-    Just t -> TypedExpression t (LocalVariable id)
-    Nothing ->
-      case lookup "this" symtab of
-        Just className ->
-          let classDetails = find (\(Class name _ _) -> name == className) classes
-          in case classDetails of
-            Just (Class _ _ fields) ->
-              let fieldTypes = [dt | VariableDeclaration dt fieldId _ <- fields, fieldId == id]
-              in case fieldTypes of
-                [fieldType] -> TypedExpression fieldType (FieldVariable id)
-                [] -> error $ "Field '" ++ id ++ "' not found in class '" ++ className ++ "'"
-                _ -> error $ "Ambiguous reference to field '" ++ id ++ "' in class '" ++ className ++ "'"
-            Nothing -> error $ "Class '" ++ className ++ "' not found for 'this'"
-        Nothing -> error $ "Context for 'this' not found in symbol table, unable to resolve '" ++ id ++ "'"
-
+  let type' = lookupType id symtab
+   in TypedExpression type' (Reference id)
 typeCheckExpression (BinaryOperation op expr1 expr2) symtab classes =
   let expr1' = typeCheckExpression expr1 symtab classes
       expr2' = typeCheckExpression expr2 symtab classes
       type1 = getTypeFromExpr expr1'
       type2 = getTypeFromExpr expr2'
-      resultType = resolveResultType type1 type2
    in case op of
-        Addition -> checkArithmeticOperation op expr1' expr2' type1 type2 resultType
-        Subtraction -> checkArithmeticOperation op expr1' expr2' type1 type2 resultType
-        Multiplication -> checkArithmeticOperation op expr1' expr2' type1 type2 resultType
-        Division -> checkArithmeticOperation op expr1' expr2' type1 type2 resultType
-        Modulo -> checkArithmeticOperation op expr1' expr2' type1 type2 resultType
-        BitwiseAnd -> checkBitwiseOperation op expr1' expr2' type1 type2
-        BitwiseOr -> checkBitwiseOperation op expr1' expr2' type1 type2
-        BitwiseXor -> checkBitwiseOperation op expr1' expr2' type1 type2
-        CompareLessThan -> checkComparisonOperation op expr1' expr2' type1 type2
-        CompareLessOrEqual -> checkComparisonOperation op expr1' expr2' type1 type2
-        CompareGreaterThan -> checkComparisonOperation op expr1' expr2' type1 type2
-        CompareGreaterOrEqual -> checkComparisonOperation op expr1' expr2' type1 type2
-        CompareEqual -> checkEqualityOperation op expr1' expr2' type1 type2
-        CompareNotEqual -> checkEqualityOperation op expr1' expr2' type1 type2
-        And -> checkLogicalOperation op expr1' expr2' type1 type2
-        Or -> checkLogicalOperation op expr1' expr2' type1 type2
-        NameResolution -> resolveNameResolution expr1' expr2 symtab classes
+        Addition ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "int" (BinaryOperation op expr1' expr2')
+            else
+              error "Addition operation requires two operands of type int"
+        Subtraction ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "int" (BinaryOperation op expr1' expr2')
+            else
+              error "Subtraction operation requires two operands of type int"
+        Multiplication ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "int" (BinaryOperation op expr1' expr2')
+            else
+              error "Multiplication operation requires two operands of type int"
+        Division ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "int" (BinaryOperation op expr1' expr2')
+            else
+              error "Division operation requires two operands of type int"
+        BitwiseAnd ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "int" (BinaryOperation op expr1' expr2')
+            else
+              error "Bitwise AND operation requires two operands of type int"
+        BitwiseOr ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "int" (BinaryOperation op expr1' expr2')
+            else
+              error "Bitwise OR operation requires two operands of type int"
+        BitwiseXor ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "int" (BinaryOperation op expr1' expr2')
+            else
+              error "Bitwise XOR operation requires two operands of type int"
+        CompareLessThan ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "boolean" (BinaryOperation op expr1' expr2')
+            else
+              error "Less than operation requires two operands of type int"
+        CompareLessOrEqual ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "boolean" (BinaryOperation op expr1' expr2')
+            else
+              error "Less than or equal operation requires two operands of type int"
+        CompareGreaterThan ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "boolean" (BinaryOperation op expr1' expr2')
+            else
+              error "Greater than operation requires two operands of type int"
+        CompareGreaterOrEqual ->
+          if type1 == "int" && type2 == "int"
+            then
+              TypedExpression "boolean" (BinaryOperation op expr1' expr2')
+            else
+              error "Greater than or equal operation requires two operands of type int"
+        CompareEqual ->
+          if type1 == type2
+            then
+              TypedExpression "boolean" (BinaryOperation op expr1' expr2')
+            else
+              error "Equality operation requires two operands of the same type"
+        CompareNotEqual ->
+          if type1 == type2
+            then
+              TypedExpression "boolean" (BinaryOperation op expr1' expr2')
+            else
+              error "Inequality operation requires two operands of the same type"
+        And ->
+          if type1 == "boolean" && type2 == "boolean"
+            then
+              TypedExpression "boolean" (BinaryOperation op expr1' expr2')
+            else
+              error "Logical AND operation requires two operands of type boolean"
+        Or ->
+          if type1 == "boolean" && type2 == "boolean"
+            then
+              TypedExpression "boolean" (BinaryOperation op expr1' expr2')
+            else
+              error "Logical OR operation requires two operands of type boolean"
+        NameResolution ->
+          case (expr1', expr2) of
+              (TypedExpression t1 (Reference obj), Reference member) ->
+                  let objectType = lookupType obj symtab
+                      classDetails = find (\(Class className _ _) -> className == objectType) classes
+                  in case classDetails of
+                      Just (Class _ _ fields) ->
+                          let fieldTypes = [dt | VariableDeclaration dt id _ <- fields, id == member]
+                          in case fieldTypes of
+                              [resolvedType] -> TypedExpression resolvedType (BinaryOperation NameResolution expr1' (TypedExpression resolvedType expr2))
+                              [] -> error $ "Field '" ++ member ++ "' not found in class '" ++ objectType ++ "'"
+                              _ -> error $ "Ambiguous reference to field '" ++ member ++ "' in class '" ++ objectType ++ "'"
+                      Nothing -> error $ "Object '" ++ obj ++ "' does not correspond to a known class"
+              _ -> error "Name resolution requires object reference and field name"
 
 typeCheckExpression (UnaryOperation op expr) symtab classes =
   let expr' = typeCheckExpression expr symtab classes
@@ -92,47 +164,8 @@ typeCheckExpression (UnaryOperation op expr) symtab classes =
           if type' == "int"
             then
               TypedExpression "int" (UnaryOperation op expr')
-          else if type' == "char"
-            then
-              TypedExpression "char" (UnaryOperation op expr')
             else
-              error "Unary minus operation requires an operand of type int or char"
-        PostIncrement ->
-          if type' == "int"
-            then
-              TypedExpression "int" (UnaryOperation op expr')
-          else if type' == "char"
-            then
-              TypedExpression "char" (UnaryOperation op expr')
-            else
-              error "Post-increment operation requires an operand of type int or char"
-        PostDecrement ->
-          if type' == "int"
-            then
-              TypedExpression "int" (UnaryOperation op expr')
-          else if type' == "char"
-            then
-              TypedExpression "char" (UnaryOperation op expr')
-            else
-              error "Post-decrement operation requires an operand of type int or char"
-        PreIncrement ->
-          if type' == "int"
-            then
-              TypedExpression "int" (UnaryOperation op expr')
-          else if type' == "char"
-            then
-              TypedExpression "char" (UnaryOperation op expr')
-            else
-              error "Pre-increment operation requires an operand of type int or char"
-        PreDecrement ->
-          if type' == "int"
-            then
-              TypedExpression "int" (UnaryOperation op expr')
-          else if type' == "char"
-            then
-              TypedExpression "char" (UnaryOperation op expr')
-            else
-              error "Pre-decrement operation requires an operand of type int or char"
+              error "Unary minus operation requires an operand of type int"
 
 typeCheckExpression (StatementExpressionExpression stmtExpr) symtab classes =
   let stmtExpr' = typeCheckStatementExpression stmtExpr symtab classes
@@ -141,16 +174,15 @@ typeCheckExpression (StatementExpressionExpression stmtExpr) symtab classes =
 -- ********************************** Type Checking: StatementExpressions **********************************
 
 typeCheckStatementExpression :: StatementExpression -> [(Identifier, DataType)] -> [Class] -> StatementExpression
-typeCheckStatementExpression (Assignment ref expr) symtab classes =
+typeCheckStatementExpression (Assignment id expr) symtab classes =
   let expr' = typeCheckExpression expr symtab classes
-      ref' = typeCheckExpression ref symtab classes
       type' = getTypeFromExpr expr'
-      type'' = getTypeFromExpr ref'
-    in
-      if type'' == type' then
-        TypedStatementExpression type' (Assignment ref' expr')
-      else
-        error $ "Type mismatch in assignment to variable: expected " ++ type'' ++ ", found " ++ type'
+      type'' = lookupType id symtab
+   in if type' == type''
+        then
+          TypedStatementExpression type' (Assignment id expr')
+        else
+          error "Assignment type mismatch"
 
 typeCheckStatementExpression (ConstructorCall className args) symtab classes =
   case find (\(Class name _ _) -> name == className) classes of
@@ -295,55 +327,8 @@ unifyReturnTypes dt1 dt2
     | dt1 == dt2 = dt1
     | otherwise  = "Object"
 
-resolveResultType :: DataType -> DataType -> DataType
-resolveResultType "char" "char" = "char"
-resolveResultType "int" "int" = "int"
-resolveResultType "char" "int" = "int"
-resolveResultType "int" "char" = "int"
-resolveResultType t1 t2
-  | t1 == t2 = t1
-  | otherwise = error $ "Incompatible types: " ++ t1 ++ " and " ++ t2
-
-checkArithmeticOperation :: BinaryOperator -> Expression -> Expression -> DataType -> DataType -> DataType -> Expression
-checkArithmeticOperation op expr1' expr2' type1 type2 resultType
-  | (type1 == "int" || type1 == "char") && (type2 == "int" || type2 == "char") =
-      TypedExpression resultType (BinaryOperation op expr1' expr2')
-  | otherwise = error $ "Arithmetic operation " ++ show op ++ " requires operands of type int or char"
-
-checkBitwiseOperation :: BinaryOperator -> Expression -> Expression -> DataType -> DataType -> Expression
-checkBitwiseOperation op expr1' expr2' type1 type2
-  | type1 == "int" && type2 == "int" =
-      TypedExpression "int" (BinaryOperation op expr1' expr2')
-  | otherwise = error $ "Bitwise operation " ++ show op ++ " requires operands of type int"
-
-checkComparisonOperation :: BinaryOperator -> Expression -> Expression -> DataType -> DataType -> Expression
-checkComparisonOperation op expr1' expr2' type1 type2
-  | (type1 == "int" || type1 == "char") && (type2 == "int" || type2 == "char") =
-      TypedExpression "boolean" (BinaryOperation op expr1' expr2')
-  | otherwise = error $ "Comparison operation " ++ show op ++ " requires operands of type int or char"
-
-checkEqualityOperation :: BinaryOperator -> Expression -> Expression -> DataType -> DataType -> Expression
-checkEqualityOperation op expr1' expr2' type1 type2
-  | type1 == type2 =
-      TypedExpression "boolean" (BinaryOperation op expr1' expr2')
-  | otherwise = error $ "Equality operation " ++ show op ++ " requires operands of the same type"
-
-checkLogicalOperation :: BinaryOperator -> Expression -> Expression -> DataType -> DataType -> Expression
-checkLogicalOperation op expr1' expr2' type1 type2
-  | type1 == "boolean" && type2 == "boolean" =
-      TypedExpression "boolean" (BinaryOperation op expr1' expr2')
-  | otherwise = error $ "Logical operation " ++ show op ++ " requires operands of type boolean"
-
-resolveNameResolution :: Expression -> Expression -> [(Identifier, DataType)] -> [Class] -> Expression
-resolveNameResolution expr1' (Reference ident2) symtab classes =
-  case getTypeFromExpr expr1' of
-    objType ->
-      case find (\(Class className _ _) -> className == objType) classes of
-        Just (Class _ _ fields) ->
-          let fieldTypes = [dt | VariableDeclaration dt id _ <- fields, id == ident2]
-          in case fieldTypes of
-            [resolvedType] -> TypedExpression resolvedType (BinaryOperation NameResolution expr1' (TypedExpression resolvedType (FieldVariable ident2)))
-            [] -> error $ "Field '" ++ ident2 ++ "' not found in class '" ++ objType ++ "'"
-            _ -> error $ "Ambiguous reference to field '" ++ ident2 ++ "' in class '" ++ objType ++ "'"
-        Nothing -> error $ "Class '" ++ objType ++ "' not found"
-resolveNameResolution _ _ _ _ = error "Name resolution requires object reference and field name"
+lookupType :: Identifier -> [(Identifier, DataType)] -> DataType
+lookupType id symtab =
+  case lookup id symtab of
+    Just t  -> t
+    Nothing -> error ("Identifier " ++ id ++ " not found in symbol table")