Fix typechecker bug for chained field access primary prefix

Author: bryanlohxz

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

@@ -46,7 +46,6 @@ import {
   DimensionExpression,
   Expression,
   ExpressionName,
-  FieldAccess,
   Primary
 } from '../types/blocks-and-statements'
 import { Location } from '../types'
@@ -317,13 +316,17 @@ export class ExpressionExtractor extends BaseJavaCstVisitorWithDefaults {
   fqnOrRefType(ctx: FqnOrRefTypeCtx) {
     const firstPart = this.visit(ctx.fqnOrRefTypePartFirst)
     if (ctx.Dot && ctx.fqnOrRefTypePartRest) {
-      const expressionName = this.visit(ctx.fqnOrRefTypePartRest) as ExpressionName
-      return {
-        kind: 'FieldAccess',
-        identifier: expressionName.name,
-        primary: firstPart,
-        location: expressionName.location
-      } as FieldAccess
+      let result: Primary = firstPart
+      for (const fqnOrRefTypePartRest of ctx.fqnOrRefTypePartRest) {
+        const expressionName = this.visit(fqnOrRefTypePartRest) as ExpressionName
+        result = {
+          kind: 'FieldAccess',
+          identifier: expressionName.name,
+          primary: result,
+          location: expressionName.location
+        }
+      }
+      return result
     }
     return firstPart
   }

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

@@ -119,6 +119,21 @@ const testcases: {
         }
     `,
     result: { type: null, errors: [] }
+  },
+  {
+    input: `
+        class StaticMember {
+          static String staticVariable = "Static Variable";
+          static void staticMethod() { System.out.println("Static method."); }
+        }
+        public class Main {
+          public static void main(String[] args) {
+            System.out.println(StaticMember.staticVariable); // Access static variable
+            StaticMember.staticMethod(); // Call static method
+          }
+        }
+    `,
+    result: { type: null, errors: [] }
   }
 ]
 

src/types/checker/environment.ts

@@ -1,11 +1,22 @@
 import * as NonPrimitives from '../types/nonPrimitives'
 import * as Primitives from '../types/primitives'
-import { Method } from '../types/methods'
+import { Method, MethodSignature, Parameter } from '../types/methods'
 import { Type } from '../types/type'
 import { CannotFindSymbolError, VariableAlreadyDefinedError } from '../errors'
 import { Array } from '../types/arrays'
+import { ClassImpl } from '../types/classes'
 import { isArrayType, removeArraySuffix } from './arrays'
 
+const SYSTEM_CLASS = new ClassImpl('System')
+const PRINTSTREAM_CLASS = new ClassImpl('PrintStream')
+SYSTEM_CLASS.setField('out', PRINTSTREAM_CLASS)
+const PRINTLN_METHOD_SIGNATURE = new MethodSignature()
+PRINTLN_METHOD_SIGNATURE.parameters.addParameter(
+  new Parameter('message', new NonPrimitives.String())
+)
+const PRINTLN_METHOD = new Method(PRINTLN_METHOD_SIGNATURE)
+PRINTSTREAM_CLASS.setMethod('println', PRINTLN_METHOD)
+
 const GLOBAL_TYPE_ENVIRONMENT: { [key: string]: Type } = {
   boolean: new Primitives.Boolean(),
   byte: new Primitives.Byte(),
@@ -25,8 +36,9 @@ const GLOBAL_TYPE_ENVIRONMENT: { [key: string]: Type } = {
   Long: new NonPrimitives.Long(),
   Short: new NonPrimitives.Short(),
   String: new NonPrimitives.String(),
-  // TODO: Fix to array type
-  'String[]': new NonPrimitives.String()
+
+  // Hard coded variables
+  System: SYSTEM_CLASS
 }
 
 export class Frame {

src/types/checker/index.ts

@@ -5,6 +5,7 @@ import { Type } from '../types/type'
 import {
   ArrayRequiredError,
   BadOperandTypesError,
+  CannotFindSymbolError,
   IncompatibleTypesError,
   NotApplicableToExpressionTypeError,
   VariableAlreadyDefinedError
@@ -272,7 +273,10 @@ export const typeCheckBody = (node: Node, frame: Frame = Frame.globalFrame()): R
       return OK_RESULT
     }
     case 'ExpressionName': {
-      const type = frame.getVariable(node.name)
+      const variable = frame.getVariable(node.name)
+      if (!(variable instanceof Error)) return newResult(variable)
+      if (!(variable instanceof CannotFindSymbolError)) return newResult(null, [variable])
+      const type = frame.getType(node.name)
       if (type instanceof Error) return newResult(null, [type])
       return newResult(type)
     }