Merge pull request #37 from source-academy/bryan/typechecking

Add type checking features

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/compiler/__tests__/output

@@ -0,0 +1,5 @@
+1
+2
+3
+-123
+9

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

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

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

@@ -0,0 +1,77 @@
+import {
+  BaseJavaCstVisitorWithDefaults,
+  BlockStatementCstNode,
+  LocalVariableDeclarationCtx,
+  LocalVariableDeclarationStatementCtx,
+  LocalVariableTypeCtx,
+  VariableDeclaratorCtx,
+  VariableDeclaratorIdCtx,
+  VariableDeclaratorListCtx
+} 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'
+
+export class BlockStatementExtractor extends BaseJavaCstVisitorWithDefaults {
+  extract(cst: BlockStatementCstNode): BlockStatement {
+    if (cst.children.localVariableDeclarationStatement) {
+      return this.visit(cst.children.localVariableDeclarationStatement)
+    } else if (cst.children.statement) {
+      const statementExtractor = new StatementExtractor()
+      return statementExtractor.extract(cst.children.statement[0])
+    }
+    throw new Error('not implemented')
+  }
+
+  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')
+    }
+  }
+
+  variableDeclaratorList(ctx: VariableDeclaratorListCtx) {
+    return ctx.variableDeclarator.map(variableDeclarator => {
+      return this.visit(variableDeclarator)
+    })
+  }
+
+  variableDeclarator(ctx: VariableDeclaratorCtx): VariableDeclarator {
+    const variableDeclarator: { [key: string]: any } = { kind: 'VariableDeclarator' }
+    variableDeclarator.variableDeclaratorId = this.visit(ctx.variableDeclaratorId)
+    if (ctx.variableInitializer) {
+      const expressionExtractor = new ExpressionExtractor()
+      variableDeclarator.variableInitializer = expressionExtractor.visit(ctx.variableInitializer)
+    }
+    return variableDeclarator as VariableDeclarator
+  }
+
+  variableDeclaratorId(ctx: VariableDeclaratorIdCtx) {
+    return ctx.Identifier[0].image
+  }
+}

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

@@ -0,0 +1,94 @@
+import {
+  BaseJavaCstVisitorWithDefaults,
+  ClassBodyDeclarationCtx,
+  ClassDeclarationCstNode,
+  ClassMemberDeclarationCtx,
+  ClassModifierCtx,
+  ClassTypeCtx,
+  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'
+
+export class ClassExtractor extends BaseJavaCstVisitorWithDefaults {
+  private modifier: Array<ClassModifier> = []
+  private identifier: Identifier
+  private body: Array<ClassBodyDeclaration> = []
+  private sclass: Identifier
+
+  extract(cst: ClassDeclarationCstNode): ClassDeclaration {
+    this.visit(cst)
+    return {
+      kind: 'NormalClassDeclaration',
+      classModifier: this.modifier,
+      typeIdentifier: this.identifier,
+      classBody: this.body,
+      extendsTypeIdentifier: this.sclass,
+      location: cst.location
+    } as NormalClassDeclaration
+  }
+
+  classModifier(ctx: ClassModifierCtx) {
+    const possibleModifiers = [
+      ctx.Public,
+      ctx.Protected,
+      ctx.Private,
+      ctx.Abstract,
+      ctx.Static,
+      ctx.Final,
+      ctx.Sealed,
+      ctx.NonSealed,
+      ctx.Strictfp
+    ]
+      .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
+  }
+
+  classType(ctx: ClassTypeCtx) {
+    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)
+      })
+    }
+    if (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)
+      })
+    }
+    if (ctx.methodDeclaration) {
+      ctx.methodDeclaration.forEach(x => {
+        const methodExtractor = new MethodExtractor()
+        const methodNode = methodExtractor.extract(x)
+        this.body.push(methodNode)
+      })
+    }
+  }
+}

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

@@ -0,0 +1,120 @@
+import {
+  ArgumentListCtx,
+  BaseJavaCstVisitorWithDefaults,
+  BlockStatementsCtx,
+  ConstructorDeclarationCstNode,
+  ConstructorModifierCtx,
+  FormalParameterCtx,
+  FormalParameterListCtx,
+  SimpleTypeNameCtx,
+  UnqualifiedExplicitConstructorInvocationCtx,
+  VariableArityParameterCtx,
+  VariableDeclaratorIdCtx,
+  VariableParaRegularParameterCtx
+} from 'java-parser'
+
+import {
+  Identifier,
+  FormalParameter,
+  ConstructorModifier,
+  ConstructorDeclaration
+} from '../types/classes'
+import { BlockStatement, ExplicitConstructorInvocation } from '../types/blocks-and-statements'
+import { Location } from '../types'
+import { BlockStatementExtractor } from './block-statement-extractor'
+import { TypeExtractor } from './type-extractor'
+import { ExpressionExtractor } from './expression-extractor'
+
+export class ConstructorExtractor extends BaseJavaCstVisitorWithDefaults {
+  private modifier: Array<ConstructorModifier> = []
+  private identifier: Identifier
+  private params: Array<FormalParameter> = []
+  private body: Array<BlockStatement> = []
+  private location: Location
+
+  extract(cst: ConstructorDeclarationCstNode): ConstructorDeclaration {
+    this.location = cst.location
+    this.visit(cst)
+    return {
+      kind: 'ConstructorDeclaration',
+      constructorModifier: this.modifier,
+      constructorDeclarator: {
+        identifier: this.identifier,
+        formalParameterList: this.params
+      },
+      constructorBody: {
+        kind: 'Block',
+        blockStatements: this.body,
+        location: this.location
+      },
+      location: this.location
+    }
+  }
+
+  constructorModifier(ctx: ConstructorModifierCtx) {
+    const possibleModifiers = [ctx.Public, ctx.Protected, ctx.Private]
+      .filter(x => x !== undefined)
+      .map(x => (x ? x[0].image : x))
+    this.modifier.push(possibleModifiers[0] as ConstructorModifier)
+  }
+
+  simpleTypeName(ctx: SimpleTypeNameCtx) {
+    this.identifier = ctx.Identifier[0].image
+  }
+
+  formalParameterList(ctx: FormalParameterListCtx) {
+    this.params = ctx.formalParameter.map(p => this.visit(p))
+  }
+
+  formalParameter(ctx: FormalParameterCtx) {
+    if (ctx.variableParaRegularParameter) {
+      return this.visit(ctx.variableParaRegularParameter)
+    } /* if (ctx.variableArityParameter) */ else {
+      return this.visit(ctx.variableArityParameter!)
+    }
+  }
+
+  variableParaRegularParameter(ctx: VariableParaRegularParameterCtx) {
+    const typeExtractor = new TypeExtractor()
+    return {
+      kind: 'FormalParameter',
+      unannType: typeExtractor.extract(ctx.unannType[0]),
+      identifier: this.visit(ctx.variableDeclaratorId)
+    } as FormalParameter
+  }
+
+  variableArityParameter(ctx: VariableArityParameterCtx) {
+    const typeExtractor = new TypeExtractor()
+    return {
+      kind: 'FormalParameter',
+      unannType: typeExtractor.extract(ctx.unannType[0]),
+      identifier: ctx.Identifier[0].image
+    } as FormalParameter
+  }
+
+  variableDeclaratorId(ctx: VariableDeclaratorIdCtx) {
+    return ctx.Identifier[0].image
+  }
+
+  blockStatements(ctx: BlockStatementsCtx) {
+    ctx.blockStatement.forEach(x => {
+      const blockStatementExtractor = new BlockStatementExtractor()
+      this.body.push(blockStatementExtractor.extract(x))
+    })
+  }
+
+  unqualifiedExplicitConstructorInvocation(ctx: UnqualifiedExplicitConstructorInvocationCtx) {
+    const expConInv = {
+      kind: 'ExplicitConstructorInvocation',
+      thisOrSuper: ctx.This?.[0].image || ctx.Super?.[0].image,
+      argumentList: ctx.argumentList ? this.visit(ctx.argumentList) : [],
+      location: this.location
+    } as ExplicitConstructorInvocation
+    this.body.push(expConInv)
+  }
+
+  argumentList(ctx: ArgumentListCtx) {
+    const expressionExtractor = new ExpressionExtractor()
+    return ctx.expression.map(e => expressionExtractor.extract(e))
+  }
+}