Add type cast support to the type checker

src/ast/__tests__/expression-extractor.test.ts

@@ -1035,3 +1035,142 @@ describe("extract ClassInstanceCreationExpression correctly", () => {
     expect(ast).toEqual(expectedAst);
   });
 });
+
+describe("extract CastExpression correctly", () => {
+  it("extract CastExpression int to char correctly", () => {
+    const programStr = `
+      class Test {
+        void test() {
+          char c = (char) 65;
+        }
+      }
+    `;
+
+    const expectedAst: AST = {
+      kind: "CompilationUnit",
+      importDeclarations: [],
+      topLevelClassOrInterfaceDeclarations: [
+        {
+          kind: "NormalClassDeclaration",
+          classModifier: [],
+          typeIdentifier: "Test",
+          classBody: [
+            {
+              kind: "MethodDeclaration",
+              methodModifier: [],
+              methodHeader: {
+                result: "void",
+                identifier: "test",
+                formalParameterList: [],
+              },
+              methodBody: {
+                kind: "Block",
+                blockStatements: [
+                  {
+                    kind: "LocalVariableDeclarationStatement",
+                    localVariableType: "char",
+                    variableDeclaratorList: [
+                      {
+                        kind: "VariableDeclarator",
+                        variableDeclaratorId: "c",
+                        variableInitializer: {
+                          kind: "CastExpression",
+                          type: "char",
+                          expression: {
+                            kind: "Literal",
+                            literalType: {
+                              kind: "DecimalIntegerLiteral",
+                              value: "65",
+                            },
+                            location: expect.anything(),
+                          },
+                          location: expect.anything(),
+                        },
+                      },
+                    ],
+                    location: expect.anything(),
+                  },
+                ],
+                location: expect.anything(),
+              },
+              location: expect.anything(),
+            },
+          ],
+          location: expect.anything(),
+        },
+      ],
+      location: expect.anything(),
+    };
+
+    const ast = parse(programStr);
+    expect(ast).toEqual(expectedAst);
+  });
+
+  it("extract CastExpression double to int correctly", () => {
+    const programStr = `
+      class Test {
+        void test() {
+          int x = (int) 3.14;
+        }
+      }
+    `;
+
+    const expectedAst: AST = {
+      kind: "CompilationUnit",
+      importDeclarations: [],
+      topLevelClassOrInterfaceDeclarations: [
+        {
+          kind: "NormalClassDeclaration",
+          classModifier: [],
+          typeIdentifier: "Test",
+          classBody: [
+            {
+              kind: "MethodDeclaration",
+              methodModifier: [],
+              methodHeader: {
+                result: "void",
+                identifier: "test",
+                formalParameterList: [],
+              },
+              methodBody: {
+                kind: "Block",
+                blockStatements: [
+                  {
+                    kind: "LocalVariableDeclarationStatement",
+                    localVariableType: "int",
+                    variableDeclaratorList: [
+                      {
+                        kind: "VariableDeclarator",
+                        variableDeclaratorId: "x",
+                        variableInitializer: {
+                          kind: "CastExpression",
+                          type: "int",
+                          expression: {
+                            kind: "Literal",
+                            literalType: {
+                              kind: "DecimalFloatingPointLiteral",
+                              value: "3.14",
+                            }
+                          },
+                          location: expect.anything(),
+                        },
+                      },
+                    ],
+                    location: expect.anything(),
+                  },
+                ],
+                location: expect.anything(),
+              },
+              location: expect.anything(),
+            },
+          ],
+          location: expect.anything(),
+        },
+      ],
+      location: expect.anything(),
+    };
+
+    const ast = parse(programStr);
+    expect(ast).toEqual(expectedAst);
+  });
+});

src/ast/astExtractor/expression-extractor.ts

@@ -93,10 +93,9 @@ export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
       const primitiveCast = ctx.primitiveCastExpression[0];
       const type = this.extractType(primitiveCast.children.primitiveType[0]);
       const expression = this.visit(primitiveCast.children.unaryExpression[0]);
-      console.debug({primitiveCast, type, expression});
       return {
         kind: "CastExpression",
-        castType: type,
+        type: type,
         expression: expression,
         location: this.location,
       };
@@ -105,13 +104,41 @@ export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
     throw new Error("Invalid CastExpression format.");
   }
 
-  private extractType(typeCtx: any) {
-    if (typeCtx.Identifier) {
-      return typeCtx.Identifier[0].image;
-    }
-    if (typeCtx.unannPrimitiveType) {
-      return this.visit(typeCtx.unannPrimitiveType);
+  private extractType(typeCtx: any): string {
+    // Check for the 'primitiveType' node
+    if (typeCtx.name === "primitiveType" && typeCtx.children) {
+      const { children } = typeCtx;
+
+      // Handle 'numericType' (e.g., int, char, float, double)
+      if (children.numericType) {
+        const numericTypeCtx = children.numericType[0];
+
+        if (numericTypeCtx.children.integralType) {
+          // Handle integral types (e.g., char, int)
+          const integralTypeCtx = numericTypeCtx.children.integralType[0];
+
+          // Extract the specific type (e.g., 'char', 'int')
+          for (const key in integralTypeCtx.children) {
+            if (integralTypeCtx.children[key][0].image) {
+              return integralTypeCtx.children[key][0].image;
+            }
+          }
+        }
+
+        if (numericTypeCtx.children.floatingPointType) {
+          // Handle floating-point types (e.g., float, double)
+          const floatingPointTypeCtx = numericTypeCtx.children.floatingPointType[0];
+
+          // Extract the specific type (e.g., 'float', 'double')
+          for (const key in floatingPointTypeCtx.children) {
+            if (floatingPointTypeCtx.children[key][0].image) {
+              return floatingPointTypeCtx.children[key][0].image;
+            }
+          }
+        }
+      }
     }
+
     throw new Error("Invalid type context in cast expression.");
   }
 
@@ -204,6 +231,10 @@ export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
   }
 
   unaryExpression(ctx: UnaryExpressionCtx) {
+    if (ctx.primary[0].children.primaryPrefix[0].children.castExpression) {
+      return this.visit(ctx.primary[0].children.primaryPrefix[0].children.castExpression);
+    }
+
     const node = this.visit(ctx.primary);
     if (ctx.UnaryPrefixOperator) {
       return {

src/ast/types/blocks-and-statements.ts

@@ -119,7 +119,6 @@ export type Expression =
   | BinaryExpression
   | UnaryExpression
   | TernaryExpression
-  | CastExpression
   | Void;
 
 export interface Void extends BaseNode {
@@ -260,7 +259,7 @@ export interface Assignment extends BaseNode {
 }
 
 export type LeftHandSide = ExpressionName | ArrayAccess;
-export type UnaryExpression = PrefixExpression | PostfixExpression;
+export type UnaryExpression = PrefixExpression | PostfixExpression | CastExpression;
 
 export interface PrefixExpression extends BaseNode {
   kind: "PrefixExpression";

src/types/checker/index.ts

@@ -1,7 +1,7 @@
 import { Array as ArrayType } from '../types/arrays'
 import { Integer, String, Throwable, Void } from '../types/references'
 import { CaseConstant, Node } from '../ast/specificationTypes'
-import { Type } from '../types/type'
+import { PrimitiveType, Type } from '../types/type'
 import {
   ArrayRequiredError,
   BadOperandTypesError,
@@ -63,6 +63,33 @@ export const check = (node: Node, frame: Frame = Frame.globalFrame()): Result =>
   return typeCheckBody(node, typeCheckingFrame)
 }
 
+const isCastCompatible = (fromType: Type, toType: Type): boolean => {
+  // Handle primitive type compatibility
+  if (fromType instanceof PrimitiveType && toType instanceof PrimitiveType) {
+    const fromName = fromType.constructor.name;
+    const toName = toType.constructor.name;
+
+    console.log(fromName, toName);
+
+    return !(fromName === 'char' && toName !== 'int');
+  }
+
+  // Handle class type compatibility
+  if (fromType instanceof ClassType && toType instanceof ClassType) {
+    // Allow upcasts (base class to derived class) or downcasts (derived class to base class)
+    return fromType.canBeAssigned(toType) || toType.canBeAssigned(fromType);
+  }
+
+  // Handle array type compatibility
+  if (fromType instanceof ArrayType && toType instanceof ArrayType) {
+    // Ensure the content types are compatible
+    return isCastCompatible(fromType.getContentType(), toType.getContentType());
+  }
+
+  // Disallow other cases by default
+  return false;
+};
+
 export const typeCheckBody = (node: Node, frame: Frame = Frame.globalFrame()): Result => {
   switch (node.kind) {
     case 'ArrayAccess': {
@@ -192,6 +219,55 @@ export const typeCheckBody = (node: Node, frame: Frame = Frame.globalFrame()): R
     case 'BreakStatement': {
       return OK_RESULT
     }
+
+    case 'CastExpression': {
+      let castType: Type | TypeCheckerError;
+      let expressionType: Type | null = null;
+      let expressionResult: Result;
+
+      if ('primitiveType' in node) {
+        castType = frame.getType(unannTypeToString(node.primitiveType), node.primitiveType.location);
+      } else {
+        throw new Error('Invalid CastExpression: Missing type information.');
+      }
+
+      if (castType instanceof TypeCheckerError) {
+        return newResult(null, [castType]);
+      }
+
+      if ('unaryExpression' in node) {
+        expressionResult = typeCheckBody(node.unaryExpression, frame);
+      } else {
+        throw new Error('Invalid CastExpression: Missing expression.');
+      }
+
+      if (expressionResult.hasErrors) {
+        return expressionResult;
+      }
+
+      expressionType = expressionResult.currentType;
+      if (!expressionType) {
+        throw new Error('Expression in cast should have a type.');
+      }
+
+      if (
+        (castType instanceof PrimitiveType && expressionType instanceof PrimitiveType)
+      ) {
+        if (!isCastCompatible(expressionType, castType)) {
+          return newResult(null, [
+            new IncompatibleTypesError(node.location),
+          ]);
+        }
+      } else {
+        return newResult(null, [
+          new IncompatibleTypesError(node.location),
+        ]);
+      }
+
+      // If the cast is valid, return the target type
+      return newResult(castType);
+    }
+
     case 'ClassInstanceCreationExpression': {
       const classIdentifier =
         node.unqualifiedClassInstanceCreationExpression.classOrInterfaceTypeToInstantiate