Fix failing array testcases for typechecker

Author: bryanlohxz

src/ast/astExtractor/expression-extractor.ts

@@ -24,15 +24,18 @@ import {
   UnaryExpressionCstNode,
   UnaryExpressionCtx,
   UnqualifiedClassInstanceCreationExpressionCtx,
+  ArrayAccessSuffixCtx,
 } from "java-parser";
 import { Location } from "../types/ast";
 import {
+  ArrayAccess,
   Assignment,
   BinaryExpression,
   ClassInstanceCreationExpression,
   Expression,
   ExpressionName,
   MethodInvocation,
+  Primary,
 } from "../types/blocks-and-statements";
 
 export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
@@ -201,10 +204,24 @@ export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
     return node;
   }
 
-  primary(ctx: PrimaryCtx) {
+  primary(ctx: PrimaryCtx): Primary {
     let primary = this.visit(ctx.primaryPrefix);
-
     if (ctx.primarySuffix) {
+      const lastSuffix = ctx.primarySuffix[ctx.primarySuffix.length - 1];
+      if (lastSuffix.children.arrayAccessSuffix) {
+        const newPrimaryCtx: PrimaryCtx = { primaryPrefix: ctx.primaryPrefix };
+        if (ctx.primarySuffix.length - 1 > 0) {
+          const newSuffixArray = ctx.primarySuffix.filter(
+            (_, index) => index !== ctx.primarySuffix!.length - 1
+          );
+          newPrimaryCtx.primarySuffix = newSuffixArray;
+        }
+        return {
+          ...this.visit(lastSuffix.children.arrayAccessSuffix),
+          primary: this.primary(newPrimaryCtx) as Primary,
+        };
+      }
+
       for (const s of ctx.primarySuffix.filter(
         (s) => !s.children.methodInvocationSuffix
       )) {
@@ -417,4 +434,12 @@ export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
   parenthesisExpression(ctx: ParenthesisExpressionCtx) {
     return this.visit(ctx.expression);
   }
+
+  arrayAccessSuffix(ctx: ArrayAccessSuffixCtx): Omit<ArrayAccess, "primary"> {
+    const expresionExtractor = new ExpressionExtractor();
+    return {
+      kind: "ArrayAccess",
+      expression: expresionExtractor.extract(ctx.expression[0]),
+    };
+  }
 }

src/ast/astExtractor/type-extractor.ts

@@ -87,7 +87,7 @@ export class TypeExtractor extends BaseJavaCstVisitorWithDefaults {
     return ctx.Identifier[0].image;
   }
 
-  dims(_: DimsCtx) {
-    return "[]";
+  dims(ctx: DimsCtx) {
+    return "[]".repeat(ctx.LSquare.length);
   }
 }

src/types/checker/__tests__/arrays.test.ts

@@ -19,7 +19,6 @@ const testcases: {
   {
     input: `int[] numbers = {1, 2, 3, 4, 5};`,
     result: { type: null, errors: [] },
-    only: true,
   },
   {
     input: `double[] values;`,
@@ -46,6 +45,13 @@ const testcases: {
     `,
     result: { type: null, errors: [] },
   },
+  {
+    input: `
+      int[][] numbers = {{1, 2, 3, 4, 5}};
+      int number = numbers[0][2]; // Accessing the third nested element
+    `,
+    result: { type: null, errors: [] },
+  },
   {
     input: `
       String[] names = {"Alice", "Bob", "Charlie"};

src/types/checker/index.ts

@@ -1,10 +1,14 @@
-import { ExpressionName } from "../../ast/types/blocks-and-statements";
+import {
+  ExpressionName,
+  VariableInitializer,
+} from "../../ast/types/blocks-and-statements";
 import { Frame } from "./environment";
 import { Method } from "../types/methods";
 import { Node } from "../../ast/types/ast";
-import { String } from "../types/nonPrimitives";
+import { Integer, String } from "../types/nonPrimitives";
 import { Type } from "../types/type";
 import {
+  ArrayRequiredError,
   BadOperandTypesError,
   IncompatibleTypesError,
   VariableAlreadyDefinedError,
@@ -25,6 +29,7 @@ import {
   getFloatType,
   getNumberType,
 } from "../types/primitives";
+import { Array as ArrayType } from "../types/arrays";
 
 export type Result = {
   currentType: Type | null;
@@ -43,6 +48,28 @@ export const check = (
   frame: Frame = Frame.globalFrame()
 ): Result => {
   switch (node.kind) {
+    case "ArrayAccess": {
+      const primaryCheck = check(node.primary, frame);
+      if (primaryCheck.errors.length > 0)
+        return newResult(null, primaryCheck.errors);
+      if (!(primaryCheck.currentType instanceof ArrayType))
+        return newResult(null, [new ArrayRequiredError()]);
+      const expressionCheck = check(node.expression, frame);
+      if (expressionCheck.errors.length > 0)
+        return newResult(null, expressionCheck.errors);
+      if (!expressionCheck.currentType)
+        throw new Error("Expression check should return a type.");
+      const integerType = new Integer();
+      const intType = new Int();
+      if (
+        !(
+          integerType.equals(expressionCheck.currentType) ||
+          intType.equals(expressionCheck.currentType)
+        )
+      )
+        return newResult(null, [new IncompatibleTypesError()]);
+      return newResult(primaryCheck.currentType.getContentType());
+    }
     case "Assignment": {
       const left = node.left as ExpressionName;
       const right = node.right;
@@ -253,31 +280,51 @@ export const check = (
     case "LocalVariableDeclarationStatement": {
       if (!node.variableDeclaratorList)
         throw new Error("Variable declarator list is undefined.");
+      const errors: Error[] = [];
       const results = node.variableDeclaratorList.map((variableDeclarator) => {
         const declaredType = frame.getType(node.localVariableType);
         if (declaredType instanceof Error)
           return newResult(null, [declaredType]);
         const { variableInitializer } = variableDeclarator;
-        if (!variableInitializer)
-          throw new Error("Variable initializer is undefined.");
-        if (Array.isArray(variableInitializer)) {
-          // Is array initializer
-        } else {
-          // Is not array initializer
-          const { currentType, errors } = check(variableInitializer, frame);
-          if (errors.length > 0) return { currentType: null, errors };
-          if (currentType == null)
-            throw new Error(
-              "Variable initializer in local variable declaration statement should return a type."
-            );
-          if (!declaredType.canBeAssigned(currentType))
-            return newResult(null, [new IncompatibleTypesError()]);
+        if (variableInitializer) {
+          const checkInitialization = (
+            declaredType: Type | ArrayType,
+            variableInitializer: VariableInitializer
+          ): void => {
+            if (errors.length > 0) return;
+            if (!Array.isArray(variableInitializer)) {
+              if (declaredType instanceof ArrayType) {
+                errors.push(new IncompatibleTypesError());
+                return;
+              }
+              const checkResult = check(variableInitializer, frame);
+              if (checkResult.errors.length > 0) {
+                errors.push(...checkResult.errors);
+                return;
+              }
+              if (checkResult.currentType == null)
+                throw new Error("Variable initializer should return a type.");
+              if (!declaredType.canBeAssigned(checkResult.currentType))
+                errors.push(new IncompatibleTypesError());
+              return;
+            }
+            if (!(declaredType instanceof ArrayType)) {
+              errors.push(new IncompatibleTypesError());
+              return;
+            }
+            const arrayContentType = declaredType.getContentType();
+            variableInitializer.forEach((variableInitializer) => {
+              checkInitialization(arrayContentType, variableInitializer);
+            });
+          };
+          checkInitialization(declaredType, variableInitializer);
         }
+        if (errors.length > 0) return newResult(null, errors);
         const error = frame.setVariable(
           variableDeclarator.variableDeclaratorId,
           declaredType
         );
-        if (error) return newResult(null, [error]);
+        if (error) return newResult(null, [...errors, error]);
         return OK_RESULT;
       });
       return results.reduce((previousResult, currentResult) => {
@@ -472,6 +519,7 @@ export const check = (
       return OK_RESULT;
     }
     default:
+      console.log(node);
       throw new Error(
         `Check is not implemented for this type of node ${node.kind}.`
       );

src/types/errors.ts

@@ -1,3 +1,9 @@
+export class ArrayRequiredError extends Error {
+  constructor() {
+    super("array required");
+  }
+}
+
 export class BadOperandTypesError extends Error {
   constructor() {
     super("bad operand");

src/types/inputs/Main.java

@@ -1,5 +1,7 @@
 public class Main {
   public static void main(String[] args) { 
-    int test1, test2 = 1, 2;
+    int test = 3;
+    int[] numbers = {1, 2, 3, 4, 5};
+    int number = test[2]; // Accessing the third element
   }
 }

src/types/types/arrays.ts

@@ -11,4 +11,8 @@ export class Array extends Type {
     if (!(type instanceof Array)) return false;
     return this._type.equals(type._type);
   }
+
+  public getContentType(): Type {
+    return this._type;
+  }
 }

src/types/types/primitives.ts

@@ -149,6 +149,10 @@ export class Int extends Type {
       type instanceof Byte
     );
   }
+
+  public equals(object: unknown): boolean {
+    return object instanceof Int;
+  }
 }
 
 export class Long extends Type {