Merge pull request #42 from source-academy/csec/bugfix

CSEC Bug Fixes

Author: bryanlohxz

src/ec-evaluator/__tests__/mtd-overloading.test.ts

@@ -1211,4 +1211,117 @@ describe("evaluate method overloading correctly", () => {
 
     expect(() => evaluate(context)).toThrowError(ResOverloadError);
   });
+
+  it("should invoke inherited method", () => {
+    const programStr = `
+      class Parent {
+        static void test() {}
+      }
+      class Test extends Parent {
+        public static void main(String[] args) {
+          test();
+        }
+      }
+      `;
+
+    const compilationUnit = parse(programStr);
+    expect(compilationUnit).toBeTruthy();
+
+    const context = createContextStub();
+    context.control.push(compilationUnit!);
+
+    const result = evaluate(context);
+
+    const expectedControlTrace = [
+      "CompilationUnit",
+      
+      "ExpressionStatement", // Test.main([""]);
+      "NormalClassDeclaration", // class Test extends Parent {...}
+      "NormalClassDeclaration", // class Parent {...}
+      "NormalClassDeclaration", // class Object {...}
+      
+      "Env", // from NormalClassDeclaration
+      "ConstructorDeclaration", // Object() {...}
+
+      "Env", // from NormalClassDeclaration
+      "MethodDeclaration", // static void test() {...}
+      "ConstructorDeclaration", // Parent() {...}
+
+      "Env", // from NormalClassDeclaration
+      "MethodDeclaration", // public static void main(String[] args) {...}
+      "ConstructorDeclaration", // Test() {...}
+
+      "Pop",
+      "MethodInvocation", // Test.main([""])
+
+      "Invocation", // ()
+      "Literal", // [""]
+      "ResOverride",
+      "ExpressionName", // Test
+      "ResOverload", // main
+      "ResType", // [""]
+      "ResType", // Test
+
+      "Deref",
+      "EvalVariable", // Test
+
+      "Env", // from Invocation
+      "Marker",
+      "Block", // {...}
+
+      "Env", // from Block
+      "ReturnStatement", // return;
+      "ExpressionStatement", // Test.test();
+
+      "Pop",
+      "MethodInvocation", // Test.test()
+
+      "Invocation", // ()
+      "ResOverride",
+      "ExpressionName", // Test
+      "ResOverload", // test
+      "ResType", // Test
+
+      "Deref",
+      "EvalVariable", // Test
+
+      "Env", // from Invocation
+      "Marker",
+      "Block", // {...}
+
+      "Env", // from Block
+      "ReturnStatement", // return;
+
+      "Reset", // return
+      "Void",
+
+      "Reset", // Skip Env from Block
+
+      "Reset", // return
+      "Void",
+
+      "Reset", // Skip Env from Block
+    ];
+    const expectedStashTrace = [
+      "Test", // ResType
+      "String[]", // ResType
+      "main", // ResOverload
+      "Test", // EvalVariable
+      "Test", // Deref
+      "main", // ResOverride
+      `[""]`, // Literal
+      "Test", // ResType
+      "test", // ResOverload
+      "Test", // EvalVariable
+      "Test", // Deref
+      "test", // ResOverride
+      "Void",
+      "Void",
+    ];
+
+    expect(result).toEqual(undefined);
+    expect((context.control as ControlStub).getTrace().map(i => getControlItemStr(i))).toEqual(expectedControlTrace);
+    expect((context.stash as StashStub).getTrace().map(i => getStashItemStr(i))).toEqual(expectedStashTrace);
+    // TODO test env
+  });
 });

src/ec-evaluator/interpreter.ts

@@ -103,7 +103,7 @@ export const evaluate = (context: Context, targetStep: number = STEP_LIMIT): Sta
   const control = context.control;
   const stash = context.stash;
 
-  context.totalSteps = 1;
+  context.totalSteps = 0;
 
   let command = control.peek();
 

src/ec-evaluator/utils.ts

@@ -396,22 +396,30 @@ export const resOverload = (
 ): Closure => {
   // Identify potentially applicable methods.
   const appClosures: Closure[] = [];
-  for (const [closureName, closure] of classToSearchIn.frame.frame.entries()) {
-    // Methods contains parantheses and must have return type.
-    if (closureName.includes(mtdName + "(") && closureName[closureName.length - 1] !== ")") {
-      const params = ((closure as Closure).mtdOrCon as MethodDeclaration).methodHeader.formalParameterList;
-      
-      if (argTypes.length != params.length) continue;
-      
-      let match = true;
-      for (let i = 0; i < argTypes.length; i++) {
-        match &&= (argTypes[i].type === params[i].unannType
-          || isSubtype(argTypes[i].type, params[i].unannType, classStore));
-        if (!match) break; // short circuit
+  let c: Class | undefined = classToSearchIn;
+  while (c) {
+    for (const [closureName, closure] of c.frame.frame.entries()) {
+      // Methods contains parantheses and must have return type.
+      if (closureName.includes(mtdName + "(") && closureName[closureName.length - 1] !== ")") {
+        const params = ((closure as Closure).mtdOrCon as MethodDeclaration).methodHeader.formalParameterList;
+        
+        if (argTypes.length != params.length) continue;
+        
+        let match = true;
+        for (let i = 0; i < argTypes.length; i++) {
+          match &&= (argTypes[i].type === params[i].unannType
+            || isSubtype(argTypes[i].type, params[i].unannType, classStore));
+          if (!match) break; // short circuit
+        }
+        
+        match && appClosures.push(closure as Closure);
       }
-      
-      match && appClosures.push(closure as Closure);
     }
+
+    if (appClosures.length > 0) break;
+
+    // Search recursively.
+    c = c.superclass;
   }
 
   if (appClosures.length === 0) {