Add support for varargs to methods

Author: bryanlohxz

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

@@ -98,7 +98,8 @@ export class MethodExtractor extends BaseJavaCstVisitorWithDefaults {
     return {
       kind: 'FormalParameter',
       unannType: typeExtractor.extract(ctx.unannType[0]),
-      identifier: this.visit(ctx.variableDeclaratorId)
+      identifier: this.visit(ctx.variableDeclaratorId),
+      isVariableArityParameter: false
     } as FormalParameter
   }
 
@@ -107,7 +108,8 @@ export class MethodExtractor extends BaseJavaCstVisitorWithDefaults {
     return {
       kind: 'FormalParameter',
       unannType: typeExtractor.extract(ctx.unannType[0]),
-      identifier: ctx.Identifier[0].image
+      identifier: ctx.Identifier[0].image,
+      isVariableArityParameter: true
     } as FormalParameter
   }
 

src/types/ast/types/classes.ts

@@ -73,6 +73,7 @@ export interface FormalParameter {
   kind: 'FormalParameter'
   unannType: UnannType
   identifier: Identifier
+  isVariableArityParameter: boolean
 }
 
 export interface FieldDeclaration extends BaseNode {

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

@@ -1,8 +1,13 @@
-import { CannotFindSymbolError } from '../../errors'
+import {
+  CannotFindSymbolError,
+  IncompatibleTypesError,
+  MethodCannotBeAppliedError,
+  VarargsParameterMustBeLastParameter,
+  VariableAlreadyDefinedError
+} from '../../errors'
 import { check } from '..'
 import { parse } from '../../ast'
 import { Type } from '../../types/type'
-import { IncompatibleTypesError, MethodCannotBeAppliedError } from '../../errors'
 
 const createProgram = (methods: string) => `
   public class Main {
@@ -75,6 +80,34 @@ const testcases: {
       public static int getStringLength(String input) { return input; }
     `,
     result: { type: null, errors: [new IncompatibleTypesError()] }
+  },
+  {
+    input: `
+      public static void main(String[] args) { printMultipleMessages("Hello", "World"); }
+      public static void printMultipleMessages(String... message, String message) {} // Duplicate Identifier
+    `,
+    result: { type: null, errors: [new VarargsParameterMustBeLastParameter()] }
+  },
+  {
+    input: `
+      public static void main(String[] args) { printMultipleMessages("Hello", "World"); }
+      public static void printMultipleMessages(String message, String message) {} // Duplicate Identifier
+    `,
+    result: { type: null, errors: [new VariableAlreadyDefinedError()] }
+  },
+  {
+    input: `
+      public static void main(String[] args) { printMultipleMessages("Hello", "World", "!"); }
+      public static void printMultipleMessages(String... messages) { for (String msg : messages) {} }
+    `,
+    result: { type: null, errors: [] }
+  },
+  {
+    input: `
+      public static void main(String[] args) { printMultipleMessages(); }
+      public static void printMultipleMessages(String... messages) { for (String msg : messages) {} }
+    `,
+    result: { type: null, errors: [] }
   }
 ]
 

src/types/checker/index.ts

@@ -381,7 +381,8 @@ export const check = (node: Node, frame: Frame = Frame.globalFrame()): Result =>
             furtherChecks.push(() => {
               const methodFrame = classFrame.newChildFrame()
               const methodSignature = method.getOverload(0)
-              methodSignature.mapParameters((name, type) => {
+              methodSignature.mapParameters((name, type, isVarargs) => {
+                if (isVarargs) type = new ArrayType(type)
                 const error = methodFrame.setVariable(name, type)
                 if (error) errors.push(error)
               })
@@ -392,6 +393,7 @@ export const check = (node: Node, frame: Frame = Frame.globalFrame()): Result =>
           }
         }
       })
+      if (errors.length > 0) return newResult(null, errors)
       furtherChecks.forEach(furtherCheck => furtherCheck())
       return newResult(null, errors)
     }

src/types/errors.ts

@@ -70,6 +70,12 @@ export class MethodCannotBeAppliedError extends Error {
   }
 }
 
+export class VarargsParameterMustBeLastParameter extends Error {
+  constructor() {
+    super('varargs parameter must be the last parameter')
+  }
+}
+
 export class VariableAlreadyDefinedError extends Error {
   constructor() {
     super('variable is already defined')

src/types/inputs/Main.java

@@ -1,7 +1,4 @@
 public class Main {
-  public static void main(String[] args) {
-    int[] arr = {1, 2, 3};
-    for (int num : arr) {}
-    System.out.println(num);
-  }
+  public static void main(String[] args) { printMultipleMessages("Hello", "World"); }
+  public static void printMultipleMessages(String ...message, String message) {} // Duplicate Identifier
 }

src/types/typeFactories/methodFactory.ts

@@ -1,6 +1,3 @@
-import { FormalParameter, MethodDeclaration } from '../ast/types/classes'
-import { Frame } from '../checker/environment'
-import { Type } from '../types/type'
 import {
   ArgumentList,
   ClassMethod,
@@ -9,6 +6,10 @@ import {
   Parameter,
   ParameterList
 } from '../types/methods'
+import { FormalParameter, MethodDeclaration } from '../ast/types/classes'
+import { Frame } from '../checker/environment'
+import { Type } from '../types/type'
+import { VarargsParameterMustBeLastParameter, VariableAlreadyDefinedError } from '../errors'
 
 export const createArgumentList = (...argumentTypes: Type[]): ArgumentList | Error => {
   const argumentList = new ArgumentList()
@@ -22,11 +23,21 @@ const createParameterList = (
   frame: Frame,
   ...parameterDeclarations: FormalParameter[]
 ): ParameterList | Error => {
+  const identifiers = new Set<string>()
   const parameters: ParameterList = new ParameterList()
-  for (const parameterDeclaration of parameterDeclarations) {
+  for (let i = 0; i < parameterDeclarations.length; i++) {
+    const parameterDeclaration = parameterDeclarations[i]
+    if (parameterDeclaration.isVariableArityParameter && i + 1 !== parameterDeclarations.length)
+      return new VarargsParameterMustBeLastParameter()
     const parameterType = frame.getType(parameterDeclaration.unannType)
     if (parameterType instanceof Error) return parameterType
-    const parameter = new Parameter(parameterDeclaration.identifier, parameterType)
+    if (identifiers.has(parameterDeclaration.identifier)) return new VariableAlreadyDefinedError()
+    identifiers.add(parameterDeclaration.identifier)
+    const parameter = new Parameter(
+      parameterDeclaration.identifier,
+      parameterType,
+      parameterDeclaration.isVariableArityParameter
+    )
     parameters.addParameter(parameter)
   }
   return parameters

src/types/types/methods.ts

@@ -23,28 +23,37 @@ export class ArgumentList {
 }
 
 export class Parameter {
-  public name: string
-  public type: Type
-  constructor(name: string, type: Type) {
-    this.name = name
-    this.type = type
+  private _name: string
+  private _type: Type
+  private _isVarargs: boolean
+
+  constructor(name: string, type: Type, isVarargs: boolean = false) {
+    this._name = name
+    this._type = type
+    this._isVarargs = isVarargs
   }
 
   public canBeAssigned(type: Type): boolean {
-    if (type instanceof Parameter) return this.type.canBeAssigned(type.type)
-    return this.type.canBeAssigned(type)
+    if (type instanceof Parameter) return this._type.canBeAssigned(type._type)
+    return this._type.canBeAssigned(type)
   }
 
   public equals(object: unknown): boolean {
-    return object instanceof Parameter && this.name === object.name && this.type.equals(object.type)
+    return (
+      object instanceof Parameter && this._name === object._name && this._type.equals(object._type)
+    )
   }
 
   public getName(): string {
-    return this.name
+    return this._name
   }
 
   public getType(): Type {
-    return this.type
+    return this._type
+  }
+
+  public isVarargs(): boolean {
+    return this._isVarargs
   }
 }
 
@@ -65,11 +74,23 @@ export class ParameterList {
   }
 
   public matchesArguments(args: ArgumentList): boolean {
-    if (this.length() !== args.length()) return false
+    const isLastParameterVarargs = this.get(this.length() - 1).isVarargs()
+    if (isLastParameterVarargs && args.length() < this.length() - 1) return false
+    if (!isLastParameterVarargs && args.length() !== this.length()) return false
     for (let i = 0; i < this.length(); i++) {
       const parameter = this.get(i)
-      const argument = args.get(i)
-      if (!parameter.canBeAssigned(argument)) return false
+      if (!parameter.isVarargs()) {
+        const argument = args.get(i)
+        if (!parameter.canBeAssigned(argument)) return false
+        continue
+      }
+
+      for (let j = i; j < args.length(); j++) {
+        const argument = args.get(j)
+        if (!parameter.canBeAssigned(argument)) return false
+      }
+
+      break
     }
     return true
   }
@@ -120,11 +141,11 @@ export class MethodSignature extends Type {
     return this.parameters.length()
   }
 
-  public mapParameters<T>(mapper: (name: string, type: Type) => T): T[] {
+  public mapParameters<T>(mapper: (name: string, type: Type, isVarargs: boolean) => T): T[] {
     const result: T[] = []
     for (let i = 0; i < this.parameterSize(); i++) {
       const parameter = this.parameters.get(i)
-      result.push(mapper(parameter.getName(), parameter.getType()))
+      result.push(mapper(parameter.getName(), parameter.getType(), parameter.isVarargs()))
     }
     return result
   }