Format code in typechecker to follow prettier standard

Author: bryanlohxz

.eslintignore

@@ -2,6 +2,5 @@ node_modules
 dist
 
 src/ast
-src/types
 
 **/__tests__/*

.prettierignore

@@ -3,4 +3,3 @@ dist
 
 src/ast
 src/ec-evaluator
-src/types

src/types/ast/astExtractor/ast-extractor.ts

@@ -1,30 +1,28 @@
-import { BaseJavaCstVisitorWithDefaults, CstNode, TypeDeclarationCtx } from "java-parser";
+import { BaseJavaCstVisitorWithDefaults, CstNode, TypeDeclarationCtx } from 'java-parser'
 
-import { NormalClassDeclaration } from "../types/classes";
-import { AST } from "../types/packages-and-modules";
-import { ClassExtractor } from "./class-extractor";
+import { NormalClassDeclaration } from '../types/classes'
+import { AST } from '../types/packages-and-modules'
+import { ClassExtractor } from './class-extractor'
 
 export class ASTExtractor extends BaseJavaCstVisitorWithDefaults {
-  private topLevelClassOrInterfaceDeclarations: NormalClassDeclaration[] = [];
+  private topLevelClassOrInterfaceDeclarations: NormalClassDeclaration[] = []
 
   extract(cst: CstNode): AST {
-    this.visit(cst);
+    this.visit(cst)
     return {
-      kind: "CompilationUnit",
+      kind: 'CompilationUnit',
       importDeclarations: [],
       topLevelClassOrInterfaceDeclarations: this.topLevelClassOrInterfaceDeclarations,
-      location: cst.location,
+      location: cst.location
     }
   }
 
   typeDeclaration(ctx: TypeDeclarationCtx) {
     if (ctx.classDeclaration) {
-      ctx.classDeclaration.forEach((x) => {
-        const classExtractor = new ClassExtractor();
-        this.topLevelClassOrInterfaceDeclarations.push(
-          classExtractor.extract(x)
-        );
-      });
+      ctx.classDeclaration.forEach(x => {
+        const classExtractor = new ClassExtractor()
+        this.topLevelClassOrInterfaceDeclarations.push(classExtractor.extract(x))
+      })
     }
   }
 }

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

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

src/types/ast/astExtractor/class-extractor.ts

@@ -5,36 +5,36 @@ import {
   ClassMemberDeclarationCtx,
   ClassModifierCtx,
   ClassTypeCtx,
-  TypeIdentifierCtx,
-} from "java-parser";
+  TypeIdentifierCtx
+} from 'java-parser'
 
 import {
   ClassModifier,
   Identifier,
   ClassBodyDeclaration,
   ClassDeclaration,
   NormalClassDeclaration
-} from "../types/classes";
-import { ConstructorExtractor } from "./constructor-extractor";
-import { FieldExtractor } from "./field-extractor";
-import { MethodExtractor } from "./method-extractor";
+} from '../types/classes'
+import { ConstructorExtractor } from './constructor-extractor'
+import { FieldExtractor } from './field-extractor'
+import { MethodExtractor } from './method-extractor'
 
 export class ClassExtractor extends BaseJavaCstVisitorWithDefaults {
-  private modifier: Array<ClassModifier> = [];
-  private identifier: Identifier;
-  private body: Array<ClassBodyDeclaration> = [];
-  private sclass: Identifier;
+  private modifier: Array<ClassModifier> = []
+  private identifier: Identifier
+  private body: Array<ClassBodyDeclaration> = []
+  private sclass: Identifier
 
   extract(cst: ClassDeclarationCstNode): ClassDeclaration {
-    this.visit(cst);
+    this.visit(cst)
     return {
-      kind: "NormalClassDeclaration",
+      kind: 'NormalClassDeclaration',
       classModifier: this.modifier,
       typeIdentifier: this.identifier,
       classBody: this.body,
       sclass: this.sclass,
-      location: cst.location,
-    } as NormalClassDeclaration;
+      location: cst.location
+    } as NormalClassDeclaration
   }
 
   classModifier(ctx: ClassModifierCtx) {
@@ -48,44 +48,46 @@ export class ClassExtractor extends BaseJavaCstVisitorWithDefaults {
       ctx.Sealed,
       ctx.NonSealed,
       ctx.Strictfp
-    ].filter(x => x !== undefined).map(x => x ? x[0].image : x);
-    this.modifier.push(possibleModifiers[0] as ClassModifier);
+    ]
+      .filter(x => x !== undefined)
+      .map(x => (x ? x[0].image : x))
+    this.modifier.push(possibleModifiers[0] as ClassModifier)
   }
 
   typeIdentifier(ctx: TypeIdentifierCtx) {
-    this.identifier = ctx.Identifier[0].image;
+    this.identifier = ctx.Identifier[0].image
   }
 
   classType(ctx: ClassTypeCtx) {
-      this.sclass = ctx.Identifier[0].image;
+    this.sclass = ctx.Identifier[0].image
   }
 
   classBodyDeclaration(ctx: ClassBodyDeclarationCtx) {
     if (ctx.constructorDeclaration) {
       ctx.constructorDeclaration.forEach(x => {
-        const constructorExtractor = new ConstructorExtractor();
-        const constructorNode = constructorExtractor.extract(x);
-        this.body.push(constructorNode);
+        const constructorExtractor = new ConstructorExtractor()
+        const constructorNode = constructorExtractor.extract(x)
+        this.body.push(constructorNode)
       })
     }
     if (ctx.classMemberDeclaration) {
-      this.visit(ctx.classMemberDeclaration);
+      this.visit(ctx.classMemberDeclaration)
     }
   }
 
   classMemberDeclaration(ctx: ClassMemberDeclarationCtx) {
     if (ctx.fieldDeclaration) {
       ctx.fieldDeclaration.forEach(x => {
-        const fieldExtractor = new FieldExtractor();
-        const fieldNode = fieldExtractor.extract(x);
-        this.body.push(fieldNode);
+        const fieldExtractor = new FieldExtractor()
+        const fieldNode = fieldExtractor.extract(x)
+        this.body.push(fieldNode)
       })
     }
     if (ctx.methodDeclaration) {
       ctx.methodDeclaration.forEach(x => {
-        const methodExtractor = new MethodExtractor();
-        const methodNode = methodExtractor.extract(x);
-        this.body.push(methodNode);
+        const methodExtractor = new MethodExtractor()
+        const methodNode = methodExtractor.extract(x)
+        this.body.push(methodNode)
       })
     }
   }