Add extractor for array local variable declarations

Author: bryanlohxz

src/ast/astExtractor/block-statement-extractor.ts

@@ -1,64 +1,101 @@
 import {
+  ArrayInitializerCtx,
   BaseJavaCstVisitorWithDefaults,
   BlockStatementCstNode,
+  LocalVariableDeclarationCtx,
+  LocalVariableDeclarationStatementCtx,
   LocalVariableTypeCtx,
+  VariableDeclaratorCtx,
   VariableDeclaratorIdCtx,
+  VariableDeclaratorListCtx,
   VariableInitializerCtx,
+  VariableInitializerListCtx,
 } from "java-parser";
 import {
   BlockStatement,
-  Expression,
+  LocalVariableDeclarationStatement,
   VariableDeclarator,
 } from "../types/blocks-and-statements";
-import { Identifier, UnannType } from "../types/classes";
 import { ExpressionExtractor } from "./expression-extractor";
 import { StatementExtractor } from "./statement-extractor";
 import { TypeExtractor } from "./type-extractor";
 
 export class BlockStatementExtractor extends BaseJavaCstVisitorWithDefaults {
-  private type: UnannType;
-  private identifier: Identifier[] = [];
-  private value: Expression[] = [];
-
   extract(cst: BlockStatementCstNode): BlockStatement {
     this.visit(cst);
     if (cst.children.localVariableDeclarationStatement) {
-      const variableDeclaratorList = this.identifier.map(
-        (identifier, index): VariableDeclarator => ({
-          kind: "VariableDeclarator",
-          variableDeclaratorId: identifier,
-          variableInitializer: this.value[index],
-        })
-      );
-      return {
-        kind: "LocalVariableDeclarationStatement",
-        localVariableType: this.type,
-        variableDeclaratorList,
-        location: cst.location,
-      };
+      return this.visit(cst.children.localVariableDeclarationStatement);
     } /* if (cst.children.statement) */ else {
       const statementExtractor = new StatementExtractor();
       return statementExtractor.extract(cst.children.statement![0]);
     }
   }
 
+  localVariableDeclarationStatement(
+    ctx: LocalVariableDeclarationStatementCtx
+  ): LocalVariableDeclarationStatement {
+    return {
+      kind: "LocalVariableDeclarationStatement",
+      ...this.visit(ctx.localVariableDeclaration),
+    };
+  }
+
+  localVariableDeclaration(
+    ctx: LocalVariableDeclarationCtx
+  ): Omit<LocalVariableDeclarationStatement, "kind"> {
+    return {
+      localVariableType: this.visit(ctx.localVariableType),
+      variableDeclaratorList: this.visit(ctx.variableDeclaratorList),
+    };
+  }
+
   localVariableType(ctx: LocalVariableTypeCtx) {
     const typeExtractor = new TypeExtractor();
     if (ctx.unannType) {
-      this.type = typeExtractor.extract(ctx.unannType[0]);
+      return typeExtractor.extract(ctx.unannType[0]);
+    } else if (ctx.Var) {
+      throw new Error("Not implemented");
     }
   }
 
+  variableDeclaratorList(ctx: VariableDeclaratorListCtx) {
+    return ctx.variableDeclarator.map((variableDeclarator) => {
+      return this.visit(variableDeclarator);
+    });
+  }
+
+  variableDeclarator(ctx: VariableDeclaratorCtx): VariableDeclarator {
+    return {
+      kind: "VariableDeclarator",
+      variableDeclaratorId: this.visit(ctx.variableDeclaratorId),
+      variableInitializer: ctx.variableInitializer
+        ? this.visit(ctx.variableInitializer)
+        : undefined,
+    };
+  }
+
   variableDeclaratorId(ctx: VariableDeclaratorIdCtx) {
-    this.identifier.push(ctx.Identifier[0].image);
+    return ctx.Identifier[0].image;
   }
 
   variableInitializer(ctx: VariableInitializerCtx) {
     if (ctx.expression) {
       const expressionExtractor = new ExpressionExtractor();
-      ctx.expression.forEach((expression) => {
-        this.value.push(expressionExtractor.extract(expression));
-      });
+      return expressionExtractor.extract(ctx.expression[0]);
+    } else if (ctx.arrayInitializer) {
+      return this.visit(ctx.arrayInitializer);
     }
   }
+
+  arrayInitializer(ctx: ArrayInitializerCtx) {
+    if (ctx.variableInitializerList) {
+      return this.visit(ctx.variableInitializerList);
+    }
+  }
+
+  variableInitializerList(ctx: VariableInitializerListCtx) {
+    return ctx.variableInitializer.map((variableInitializer) => {
+      return this.visit(variableInitializer);
+    });
+  }
 }

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

@@ -19,6 +19,7 @@ const testcases: {
   {
     input: `int[] numbers = {1, 2, 3, 4, 5};`,
     result: { type: null, errors: [] },
+    only: true,
   },
   {
     input: `double[] values;`,

src/types/checker/arrays.ts

@@ -0,0 +1,12 @@
+export const isArrayType = (typeDeclaration: string): boolean => {
+  typeDeclaration = typeDeclaration.trim();
+  if (typeDeclaration.length < 2) return false;
+  const arraySuffix = typeDeclaration.slice(-2);
+  return arraySuffix === "[]";
+};
+
+export const removeArraySuffix = (typeDeclaration: string): string => {
+  typeDeclaration = typeDeclaration.trim();
+  if (!isArrayType(typeDeclaration)) return typeDeclaration;
+  return typeDeclaration.substring(0, typeDeclaration.length - 2);
+};

src/types/checker/environment.ts

@@ -3,6 +3,8 @@ import * as Primitives from "../types/primitives";
 import { Method } from "../types/methods";
 import { Type } from "../types/type";
 import { CannotFindSymbolError, VariableAlreadyDefinedError } from "../errors";
+import { isArrayType, removeArraySuffix } from "./arrays";
+import { Array } from "../types/arrays";
 
 const GLOBAL_TYPE_ENVIRONMENT: { [key: string]: Type } = {
   boolean: new Primitives.Boolean(),
@@ -60,6 +62,13 @@ export class Frame {
   }
 
   public getType(name: string): Type | Error {
+    if (isArrayType(name)) {
+      const typePrefix = removeArraySuffix(name);
+      const prefixType = this.getType(typePrefix);
+      if (prefixType instanceof Error) return prefixType;
+      return new Array(prefixType);
+    }
+
     let frame: Frame | null = this;
     while (frame) {
       const type = frame._types.get(name);

src/types/checker/index.ts

@@ -1,3 +1,4 @@
+import { ExpressionName } from "../../ast/types/blocks-and-statements";
 import { Frame } from "./environment";
 import { Method } from "../types/methods";
 import { Node } from "../../ast/types/ast";
@@ -13,10 +14,6 @@ import {
   createMethod,
   createMethodSignature,
 } from "../typeFactories/methodFactory";
-import {
-  Expression,
-  ExpressionName,
-} from "../../ast/types/blocks-and-statements";
 import {
   Boolean,
   Char,
@@ -263,17 +260,19 @@ export const check = (
         const { variableInitializer } = variableDeclarator;
         if (!variableInitializer)
           throw new Error("Variable initializer is undefined.");
-        const { currentType, errors } = check(
-          variableInitializer as Expression,
-          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 (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()]);
+        }
         const error = frame.setVariable(
           variableDeclarator.variableDeclaratorId,
           declaredType

src/types/inputs/Main.class

@@ -1,4 +1,5 @@
 public class Main {
-  public static void main(String[] args) { getStringLength("Hello World!"); }
-  public static String getStringLength(String input) { return 1; }
+  public static void main(String[] args) { 
+    int test1, test2 = 1, 2;
+  }
 }

src/types/inputs/Main.java

@@ -0,0 +1,14 @@
+import { Type } from "./type";
+
+export class Array extends Type {
+  private _type: Type;
+  constructor(type: Type) {
+    super("array");
+    this._type = type;
+  }
+
+  public canBeAssigned(type: Type): boolean {
+    if (!(type instanceof Array)) return false;
+    return this._type.equals(type._type);
+  }
+}

src/types/types/arrays.ts

@@ -10,7 +10,7 @@
     "moduleResolution": "node",
     "noImplicitAny": true,
     "noImplicitThis": true,
-    "noImplicitReturns": true,
+    "noImplicitReturns": false,
     "noUnusedLocals": true,
     "outDir": "./dist",
     "removeComments": false,