Fix bug to not allow final methods to be overriden

Author: AprupKale

src/compiler/__tests__/__utils__/test-utils.ts

@@ -30,9 +30,9 @@ export function runTest(program: string, expectedLines: string[]) {
     console.log(inspect(ast, false, null, true))
   }
 
-  const classFiles = compile(ast as AST)
-  for (let classFile of classFiles) {
-    binaryWriter.writeBinary(classFile, pathToTestDir)
+  const classes = compile(ast as AST)
+  for (let c of classes) {
+    binaryWriter.writeBinary(c.classFile, pathToTestDir)
   }
 
   const prevDir = process.cwd()

src/compiler/__tests__/tests/methodOverriding.test.ts

@@ -119,7 +119,7 @@ const testCases: testCase[] = [
         }
       }
       class Child extends Parent {
-         public void show() {} // Uncommenting should cause compilation error
+         // public void show() {} // Uncommenting should cause compilation error
       }
       public class Main {
         public static void main(String[] args) {
@@ -185,6 +185,139 @@ const testCases: testCase[] = [
       }
     `,
     expectedLines: ['Child secret']
+  },
+  {
+    comment: 'Using this to call an instance method',
+    program: `
+      class Self {
+        public void print() {
+          System.out.println("Self print");
+        }
+        public void callSelf() {
+          this.print();
+        }
+      }
+      public class Main {
+        public static void main(String[] args) {
+          Self s = new Self();
+          s.callSelf(); // Self print
+        }
+      }
+    `,
+    expectedLines: ['Self print']
+  },
+  {
+    comment: 'Using super to invoke parent method',
+    program: `
+      class Base {
+        public void greet() {
+          System.out.println("Hello from Base");
+        }
+      }
+      class Derived extends Base {
+        public void greet() {
+          super.greet();
+          System.out.println("Hello from Derived");
+        }
+      }
+      public class Main {
+        public static void main(String[] args) {
+          Derived d = new Derived();
+          d.greet(); 
+          // Expected:
+          // Hello from Base
+          // Hello from Derived
+        }
+      }
+    `,
+    expectedLines: ['Hello from Base', 'Hello from Derived']
+  },
+  {
+    comment: 'Polymorphic call with dynamic dispatch',
+    program: `
+      class Animal {
+        public void speak() {
+          System.out.println("Animal sound");
+        }
+      }
+      class Dog extends Animal {
+        public void speak() {
+          System.out.println("Bark");
+        }
+        public void callSuper() {
+          super.speak();
+        }
+      }
+      public class Main {
+        public static void main(String[] args) {
+          Dog d = new Dog();
+          d.speak(); // Bark
+          d.callSuper(); // Animal sound
+        }
+      }
+    `,
+    expectedLines: ['Bark', 'Animal sound']
+  },
+  {
+    comment: 'Method overloading resolution',
+    program: `
+      class Overload {
+        public void test(int a) {
+          System.out.println("int");
+        }
+        public void test(double a) {
+          System.out.println("double");
+        }
+      }
+      public class Main {
+        public static void main(String[] args) {
+          Overload o = new Overload();
+          o.test(5);   // int
+          o.test(5.0); // double
+        }
+      }
+    `,
+    expectedLines: ['int', 'double']
+  },
+  {
+    comment: 'Overriding on a superclass reference',
+    program: `
+      class X {
+        public void foo() {
+          System.out.println("X foo");
+        }
+      }
+      class Y extends X {
+        public void foo() {
+          System.out.println("Y foo");
+        }
+      }
+      public class Main {
+        public static void main(String[] args) {
+          X x = new Y();
+          x.foo(); // Y foo
+        }
+      }
+    `,
+    expectedLines: ['Y foo']
+  },
+  {
+    comment: 'Implicit conversion (byte to int)',
+    program: `
+      class Implicit {
+        public void process(int a) {
+          System.out.println("Processed int");
+        }
+      }
+      public class Main {
+        public static void main(String[] args) {
+          Implicit imp = new Implicit();
+          byte b = (byte) 10;
+          imp.process(b); // Processed int
+        }
+      }
+    `,
+    expectedLines: ['Processed int']
   }
 ]
 

src/compiler/error.ts

@@ -45,3 +45,9 @@ export class AmbiguousMethodCallError extends CompileError {
     super(`Ambiguous method call: ${signature}`)
   }
 }
+
+export class OverrideFinalMethodError extends CompileError {
+  constructor(name: string) {
+    super(`Cannot override final method ${name}`)
+  }
+}

src/compiler/symbol-table.ts

@@ -6,12 +6,13 @@ import {
   generateMethodAccessFlags
 } from './compiler-utils'
 import {
-  InvalidMethodCallError,
+  InvalidMethodCallError, OverrideFinalMethodError,
   SymbolCannotBeResolvedError,
   SymbolNotFoundError,
   SymbolRedeclarationError
 } from './error'
 import { libraries } from './import/libs'
+import { METHOD_FLAGS } from '../ClassFile/types/methods'
 
 export const typeMap = new Map([
   ['byte', 'B'],
@@ -103,11 +104,10 @@ export class SymbolTable {
       if (this.importedPackages.findIndex(e => e == p.packageName + '/') == -1)
         this.importedPackages.push(p.packageName + '/')
       p.classes.forEach(c => {
-        this.insertClassInfo(
-          {
-            name: c.className,
-            accessFlags: generateClassAccessFlags(c.accessFlags)
-          })
+        this.insertClassInfo({
+          name: c.className,
+          accessFlags: generateClassAccessFlags(c.accessFlags)
+        })
         c.fields.forEach(f =>
           this.insertFieldInfo({
             name: f.fieldName,
@@ -208,6 +208,21 @@ export class SymbolTable {
   insertMethodInfo(info: MethodInfo) {
     const key = generateSymbol(info.name, SymbolType.METHOD)
 
+    for (let i = this.curClassIdx - 1; i > 0; i--) {
+      const parentTable = this.tables[i];
+      if (parentTable.has(key)) {
+        const parentMethods = parentTable.get(key)!.info;
+        if (Array.isArray(parentMethods)) {
+          for (const m of parentMethods) {
+            if (m.typeDescriptor === info.typeDescriptor && (m.accessFlags & METHOD_FLAGS.ACC_FINAL)
+              && m.className == info.parentClassName) {
+              throw new OverrideFinalMethodError(info.name);
+            }
+          }
+        }
+      }
+    }
+
     this.curTable = this.tables[this.curIdx]
     if (!this.curTable.has(key)) {
       const symbolNode: SymbolNode = {