Revert ast module

Author: bryanlohxz

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

@@ -1,101 +1,64 @@
 import {
-  ArrayInitializerCtx,
   BaseJavaCstVisitorWithDefaults,
   BlockStatementCstNode,
-  LocalVariableDeclarationCtx,
-  LocalVariableDeclarationStatementCtx,
   LocalVariableTypeCtx,
-  VariableDeclaratorCtx,
   VariableDeclaratorIdCtx,
-  VariableDeclaratorListCtx,
   VariableInitializerCtx,
-  VariableInitializerListCtx,
 } from "java-parser";
 import {
   BlockStatement,
-  LocalVariableDeclarationStatement,
+  Expression,
   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) {
-      return this.visit(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,
+      };
     } /* 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) {
-      return typeExtractor.extract(ctx.unannType[0]);
-    } else if (ctx.Var) {
-      throw new Error("Not implemented");
+      this.type = typeExtractor.extract(ctx.unannType[0]);
     }
   }
 
-  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) {
-    return ctx.Identifier[0].image;
+    this.identifier.push(ctx.Identifier[0].image);
   }
 
   variableInitializer(ctx: VariableInitializerCtx) {
     if (ctx.expression) {
       const expressionExtractor = new ExpressionExtractor();
-      return expressionExtractor.extract(ctx.expression[0]);
-    } else if (ctx.arrayInitializer) {
-      return this.visit(ctx.arrayInitializer);
+      ctx.expression.forEach((expression) => {
+        this.value.push(expressionExtractor.extract(expression));
+      });
     }
   }
-
-  arrayInitializer(ctx: ArrayInitializerCtx) {
-    if (ctx.variableInitializerList) {
-      return this.visit(ctx.variableInitializerList);
-    }
-  }
-
-  variableInitializerList(ctx: VariableInitializerListCtx) {
-    return ctx.variableInitializer.map((variableInitializer) => {
-      return this.visit(variableInitializer);
-    });
-  }
 }

src/ast/astExtractor/expression-extractor.ts

@@ -24,18 +24,15 @@ 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 {
@@ -204,24 +201,10 @@ export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
     return node;
   }
 
-  primary(ctx: PrimaryCtx): Primary {
+  primary(ctx: PrimaryCtx) {
     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,
-        };
-      }
 
+    if (ctx.primarySuffix) {
       for (const s of ctx.primarySuffix.filter(
         (s) => !s.children.methodInvocationSuffix
       )) {
@@ -434,12 +417,4 @@ 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/statement-extractor.ts

@@ -39,7 +39,6 @@ import {
   ExpressionStatement,
   IfStatement,
   MethodInvocation,
-  Primary,
   Statement,
   StatementExpression,
   VariableDeclarator,
@@ -159,26 +158,10 @@ export class StatementExtractor extends BaseJavaCstVisitorWithDefaults {
     return this.visit(ctx.primary);
   }
 
-  primary(ctx: PrimaryCtx): Primary {
+  primary(ctx: PrimaryCtx) {
     // Assignment LHS, MethodInvocation identifier
     let { name, location } = this.visit(ctx.primaryPrefix);
     if (ctx.primarySuffix) {
-      const lastSuffix = ctx.primarySuffix[ctx.primarySuffix.length - 1];
-      if (lastSuffix.children.arrayAccessSuffix) {
-        const expressionExtractor = new ExpressionExtractor();
-        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 {
-          ...expressionExtractor.visit(lastSuffix.children.arrayAccessSuffix),
-          primary: this.primary(newPrimaryCtx) as Primary,
-        };
-      }
-
       for (const s of ctx.primarySuffix.filter(
         (s) => !s.children.methodInvocationSuffix
       )) {

src/ast/astExtractor/type-extractor.ts

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

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

@@ -134,24 +134,24 @@ const testcases: {
         }
     `,
     result: { type: null, errors: [] }
-  },
-  {
-    input: `
-        class AccessControl {
-          private void privateMethod() { System.out.println("Private method."); }
-          public void attemptAccess() { privateMethod(); }
-        }
-        
-        public class Main {
-          public static void main(String[] args) {
-            AccessControl obj = new AccessControl();
-            obj.attemptAccess();
-            obj.privateMethod(); // Should be flagged as an error
-          }
-        }
-    `,
-    result: { type: null, errors: [new CannotFindSymbolError()] }
   }
+  // {
+  //   input: `
+  //       class AccessControl {
+  //         private void privateMethod() { System.out.println("Private method."); }
+  //         public void attemptAccess() { privateMethod(); }
+  //       }
+
+  //       public class Main {
+  //         public static void main(String[] args) {
+  //           AccessControl obj = new AccessControl();
+  //           obj.attemptAccess();
+  //           obj.privateMethod(); // Should be flagged as an error
+  //         }
+  //       }
+  //   `,
+  //   result: { type: null, errors: [new CannotFindSymbolError()] }
+  // }
 ]
 
 describe('Type Checker', () => {