Complete implementation of typechecking arrays

Author: bryanlohxz

src/compiler/__tests__/output

@@ -0,0 +1,6 @@
+true
+4
+167.5
+3.2
+16777215
+70000000000

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

@@ -1,7 +1,7 @@
 import { BaseJavaCstVisitorWithDefaults, CstNode, TypeDeclarationCtx } from 'java-parser'
 
 import { NormalClassDeclaration } from '../types/classes'
-import { AST } from '../types/packages-and-modules'
+import { AST } from '../types'
 import { ClassExtractor } from './class-extractor'
 
 export class ASTExtractor extends BaseJavaCstVisitorWithDefaults {

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

@@ -1,15 +1,12 @@
 import {
-  ArrayInitializerCtx,
   BaseJavaCstVisitorWithDefaults,
   BlockStatementCstNode,
   LocalVariableDeclarationCtx,
   LocalVariableDeclarationStatementCtx,
   LocalVariableTypeCtx,
   VariableDeclaratorCtx,
   VariableDeclaratorIdCtx,
-  VariableDeclaratorListCtx,
-  VariableInitializerCtx,
-  VariableInitializerListCtx
+  VariableDeclaratorListCtx
 } from 'java-parser'
 import {
   BlockStatement,
@@ -22,13 +19,13 @@ import { TypeExtractor } from './type-extractor'
 
 export class BlockStatementExtractor extends BaseJavaCstVisitorWithDefaults {
   extract(cst: BlockStatementCstNode): BlockStatement {
-    this.visit(cst)
     if (cst.children.localVariableDeclarationStatement) {
       return this.visit(cst.children.localVariableDeclarationStatement)
-    } /* if (cst.children.statement) */ else {
+    } else if (cst.children.statement) {
       const statementExtractor = new StatementExtractor()
-      return statementExtractor.extract(cst.children.statement![0])
+      return statementExtractor.extract(cst.children.statement[0])
     }
+    throw new Error('not implemented')
   }
 
   localVariableDeclarationStatement(
@@ -65,35 +62,16 @@ export class BlockStatementExtractor extends BaseJavaCstVisitorWithDefaults {
   }
 
   variableDeclarator(ctx: VariableDeclaratorCtx): VariableDeclarator {
-    return {
-      kind: 'VariableDeclarator',
-      variableDeclaratorId: this.visit(ctx.variableDeclaratorId),
-      variableInitializer: ctx.variableInitializer ? this.visit(ctx.variableInitializer) : undefined
+    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
   }
-
-  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)
-    }
-  }
-
-  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/ast/astExtractor/constructor-extractor.ts

@@ -20,7 +20,7 @@ import {
   ConstructorDeclaration
 } from '../types/classes'
 import { BlockStatement, ExplicitConstructorInvocation } from '../types/blocks-and-statements'
-import { Location } from '../types/ast'
+import { Location } from '../types'
 import { BlockStatementExtractor } from './block-statement-extractor'
 import { TypeExtractor } from './type-extractor'
 import { ExpressionExtractor } from './expression-extractor'

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

@@ -1,10 +1,17 @@
 import {
   ArgumentListCtx,
   ArrayAccessSuffixCtx,
+  ArrayCreationDefaultInitSuffixCtx,
+  ArrayCreationExplicitInitSuffixCtx,
+  ArrayCreationExpressionCtx,
+  ArrayInitializerCtx,
   BaseJavaCstVisitorWithDefaults,
   BinaryExpressionCtx,
   BooleanLiteralCtx,
   ClassOrInterfaceTypeToInstantiateCtx,
+  DimExprCtx,
+  DimExprsCtx,
+  DimsCtx,
   ExpressionCstNode,
   ExpressionCtx,
   FloatingPointLiteralCtx,
@@ -25,21 +32,26 @@ import {
   TernaryExpressionCtx,
   UnaryExpressionCstNode,
   UnaryExpressionCtx,
-  UnqualifiedClassInstanceCreationExpressionCtx
+  UnqualifiedClassInstanceCreationExpressionCtx,
+  VariableInitializerCtx,
+  VariableInitializerListCtx
 } from 'java-parser'
 import {
   ArgumentList,
   ArrayAccess,
+  ArrayCreationExpression,
   Assignment,
   BinaryExpression,
   ClassInstanceCreationExpression,
+  DimensionExpression,
   Expression,
   ExpressionName,
   FieldAccess,
   Primary
 } from '../types/blocks-and-statements'
-import { Location } from '../types/ast'
+import { Location } from '../types'
 import { getLocation } from './utils'
+import { TypeExtractor } from './type-extractor'
 
 export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
   private location: Location
@@ -272,7 +284,9 @@ export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
   }
 
   newExpression(ctx: NewExpressionCtx) {
-    if (ctx.unqualifiedClassInstanceCreationExpression) {
+    if (ctx.arrayCreationExpression) {
+      return this.visit(ctx.arrayCreationExpression)
+    } else if (ctx.unqualifiedClassInstanceCreationExpression) {
       return this.visit(ctx.unqualifiedClassInstanceCreationExpression)
     }
   }
@@ -451,4 +465,70 @@ export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
       location: getLocation(ctx.LSquare[0])
     }
   }
+
+  arrayCreationExpression(ctx: ArrayCreationExpressionCtx): ArrayCreationExpression {
+    const result: { [key: string]: any } = { kind: 'ArrayCreationExpression' }
+    const typeExtractor = new TypeExtractor()
+    if (ctx.classOrInterfaceType) result.type = typeExtractor.visit(ctx.classOrInterfaceType)
+    else if (ctx.primitiveType) result.type = typeExtractor.visit(ctx.primitiveType)
+    if (ctx.arrayCreationDefaultInitSuffix)
+      result.dimensionExpressions = this.visit(ctx.arrayCreationDefaultInitSuffix)
+    else if (ctx.arrayCreationExplicitInitSuffix) {
+      const { arrayInitializer, dimensions } = this.visit(ctx.arrayCreationExplicitInitSuffix)
+      result.arrayInitializer = arrayInitializer
+      result.type += dimensions
+    }
+    result.location = getLocation(ctx.New[0])
+    return result as ArrayCreationExpression
+  }
+
+  arrayCreationDefaultInitSuffix(ctx: ArrayCreationDefaultInitSuffixCtx) {
+    if (ctx.dims) throw new Error('not implemented')
+    return this.visit(ctx.dimExprs)
+  }
+
+  arrayCreationExplicitInitSuffix(ctx: ArrayCreationExplicitInitSuffixCtx) {
+    return {
+      arrayInitializer: this.visit(ctx.arrayInitializer),
+      dimensions: this.visit(ctx.dims)
+    }
+  }
+
+  dims(ctx: DimsCtx) {
+    return '[]'.repeat(ctx.LSquare.length)
+  }
+
+  dimExprs(ctx: DimExprsCtx) {
+    return ctx.dimExpr.map(dimExpr => this.visit(dimExpr))
+  }
+
+  dimExpr(ctx: DimExprCtx): DimensionExpression {
+    const expressionExtractor = new ExpressionExtractor()
+    return {
+      kind: 'DimensionExpression',
+      expression: expressionExtractor.extract(ctx.expression[0]),
+      location: getLocation(ctx.LSquare[0])
+    }
+  }
+
+  arrayInitializer(ctx: ArrayInitializerCtx) {
+    if (ctx.variableInitializerList) {
+      return this.visit(ctx.variableInitializerList)
+    }
+  }
+
+  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)
+    }
+  }
+
+  variableInitializerList(ctx: VariableInitializerListCtx) {
+    return ctx.variableInitializer.map(variableInitializer => {
+      return this.visit(variableInitializer)
+    })
+  }
 }

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

@@ -42,7 +42,7 @@ import {
   StatementExpression,
   VariableDeclarator
 } from '../types/blocks-and-statements'
-import { Location } from '../types/ast'
+import { Location } from '../types'
 import { ExpressionExtractor } from './expression-extractor'
 import { BlockStatementExtractor } from './block-statement-extractor'
 import { TypeExtractor } from './type-extractor'

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

@@ -4,6 +4,7 @@ import {
   FloatingPointTypeCtx,
   IntegralTypeCtx,
   NumericTypeCtx,
+  PrimitiveTypeCtx,
   UnannClassOrInterfaceTypeCtx,
   UnannClassTypeCtx,
   UnannPrimitiveTypeCtx,
@@ -88,4 +89,10 @@ export class TypeExtractor extends BaseJavaCstVisitorWithDefaults {
   dims(ctx: DimsCtx) {
     return '[]'.repeat(ctx.LSquare.length)
   }
+
+  primitiveType(ctx: PrimitiveTypeCtx) {
+    if (ctx.Boolean) return 'boolean'
+    if (ctx.numericType) return this.visit(ctx.numericType)
+    throw new Error('not implemented')
+  }
 }

src/types/ast/astExtractor/utils.ts

@@ -1,4 +1,4 @@
-import { Location } from '../types/ast'
+import { Location } from '../types'
 
 export const getLocation = (object: Location): Location => ({
   startLine: object.startLine,

src/types/ast/index.ts

@@ -1,6 +1,6 @@
 import { parse as parseToCst } from 'java-parser'
 import { ASTExtractor } from './astExtractor/ast-extractor'
-import { AST } from './types/packages-and-modules'
+import { AST } from './types'
 
 /**
  * Parse program string into Abstract Syntax Tree (AST).