forbidden interface function and generic function to be generic

Author: Changqing-JING

src/diagnosticMessages.json

@@ -52,6 +52,7 @@
   "Initializer, definitive assignment or nullable type expected.": 238,
   "Definitive assignment has no effect on local variables.": 239,
   "Ambiguous operator overload '{0}' (conflicting overloads '{1}' and '{2}').": 240,
+  "An interface or abstract method '{0}' cannot have type parameters.": 241,
 
   "Importing the table disables some indirect call optimizations.": 901,
   "Exporting the table disables some indirect call optimizations.": 902,

src/program.ts

@@ -2079,6 +2079,13 @@ export class Program extends DiagnosticEmitter {
         }
         case NodeKind.MethodDeclaration: {
           let methodDeclaration = <MethodDeclaration>memberDeclaration;
+          if (methodDeclaration.is(CommonFlags.Abstract) && methodDeclaration.is(CommonFlags.Generic)) {
+            this.error(
+              DiagnosticCode.An_interface_or_abstract_method_0_cannot_have_type_parameters,
+              methodDeclaration.name.range,
+              methodDeclaration.name.text
+            );
+          }
           if (memberDeclaration.isAny(CommonFlags.Get | CommonFlags.Set)) {
             this.initializeProperty(methodDeclaration, element);
           } else {
@@ -2653,6 +2660,13 @@ export class Program extends DiagnosticEmitter {
         }
         case NodeKind.MethodDeclaration: {
           let methodDeclaration = <MethodDeclaration>memberDeclaration;
+          if (methodDeclaration.is(CommonFlags.Generic)) {
+            this.error(
+              DiagnosticCode.An_interface_or_abstract_method_0_cannot_have_type_parameters,
+              methodDeclaration.name.range,
+              methodDeclaration.name.text
+            );
+          }
           if (memberDeclaration.isAny(CommonFlags.Get | CommonFlags.Set)) {
             this.initializeProperty(methodDeclaration, element);
           } else {

src/resolver.ts

@@ -3064,12 +3064,17 @@ export class Resolver extends DiagnosticEmitter {
           if (boundPrototype) { // might have errored earlier and wasn't added
             assert(boundPrototype.kind == ElementKind.FunctionPrototype);
             let boundFuncPrototype = <FunctionPrototype>boundPrototype;
-            let overrideTypeParams = boundFuncPrototype.typeParameterNodes;
-            let numOverrideTypeParams = overrideTypeParams ? overrideTypeParams.length : 0;
-            let baseTypeArgs = instance.typeArguments;
-            let numBaseTypeArgs = baseTypeArgs ? baseTypeArgs.length : 0;
-            if (numOverrideTypeParams == numBaseTypeArgs) {
-              overrideInstance = this.resolveFunction(boundFuncPrototype, baseTypeArgs);
+            // Only resolve the override when the generic-ness matches the base method.
+            // - generic child → non-generic base: skip; vtable dispatch site has no type
+            //   arguments to forward to the monomorphized child.
+            // - generic child → generic base: OK; type args come from the base call site.
+            // - non-generic child → non-generic base: OK; plain vtable override.
+            // FIXME: non-generic child → generic base is also mismatched (resolveFunction
+            //   would assert on typeArguments/typeParameterNodes length mismatch) but that
+            //   case is not yet guarded here. The correct fix is to replace this condition
+            //   with `boundFuncPrototype.is(Generic) == instance.is(Generic)`.
+            if (!boundFuncPrototype.is(CommonFlags.Generic) || instance.is(CommonFlags.Generic)) {
+              overrideInstance = this.resolveFunction(boundFuncPrototype, instance.typeArguments);
             }
           }
         }
@@ -3445,20 +3450,10 @@ export class Resolver extends DiagnosticEmitter {
           }
           default: assert(false);
         }
-        if (!member.is(CommonFlags.Abstract)) {
-          // A generic method cannot implement a non-generic interface method
-          // because monomorphization requires a concrete type to generate code,
-          // but virtual dispatch through the interface has no type arguments.
-          if (unimplemented.has(memberName)
-            && member.kind == ElementKind.FunctionPrototype
-            && unimplemented.get(memberName)!.kind == ElementKind.FunctionPrototype
-          ) {
-            let memberTypeParams = (<FunctionPrototype>member).typeParameterNodes;
-            let ifaceTypeParams = (<FunctionPrototype>unimplemented.get(memberName)).typeParameterNodes;
-            let numMemberTypeParams = memberTypeParams ? memberTypeParams.length : 0;
-            let numIfaceTypeParams = ifaceTypeParams ? ifaceTypeParams.length : 0;
-            if (numMemberTypeParams != numIfaceTypeParams) continue;
-          }
+        if (!member.is(CommonFlags.Abstract) && !member.is(CommonFlags.Generic)) {
+          // A generic method cannot satisfy a non-generic interface/abstract
+          // requirement: interface methods cannot be generic (AS241), and
+          // virtual dispatch cannot supply type arguments for monomorphization.
           unimplemented.delete(memberName);
         }
       }

tests/compiler/override-typeparam-mismatch.json

@@ -1,9 +1,13 @@
 {
   "asc_flags": [],
   "stderr": [
+    "AS241: An interface or abstract method 'foo' cannot have type parameters.",
+    "AS241: An interface or abstract method 'baz' cannot have type parameters.",
     "TS2515: Non-abstract class 'override-typeparam-mismatch/CC' does not implement inherited abstract member 'foo' from 'override-typeparam-mismatch/I'.",
     "TS2515: Non-abstract class 'override-typeparam-mismatch/DD' does not implement inherited abstract member 'bar' from 'override-typeparam-mismatch/J'.",
     "TS2515: Non-abstract class 'override-typeparam-mismatch/C2' does not implement inherited abstract member 'foo' from 'override-typeparam-mismatch/I2'.",
+    "TS2515: Non-abstract class 'override-typeparam-mismatch/FF' does not implement inherited abstract member 'baz' from 'override-typeparam-mismatch/A1'.",
+    "TS2515: Non-abstract class 'override-typeparam-mismatch/GG' does not implement inherited abstract member 'qux' from 'override-typeparam-mismatch/A2'.",
     "EOF"
   ]
 }

tests/compiler/override-typeparam-mismatch.ts

@@ -36,4 +36,31 @@ class C2 implements I2 {
 
 new C2().foo<i32>(1);
 
+// abstract method cannot be generic (AS241)
+abstract class A1 {
+  abstract baz<T>(x: i32): i32;
+}
+
+class FF extends A1 {
+  baz<T>(x: i32): i32 {
+    return x;
+  }
+}
+
+new FF().baz<i32>(1);
+
+// generic method cannot implement non-generic abstract method (TS2515)
+abstract class A2 {
+  abstract qux(x: i32): i32;
+}
+
+class GG extends A2 {
+  qux<T>(x: i32): i32 {
+    return x;
+  }
+}
+
+let a: A2 = new GG();
+a.qux(1);
+
 ERROR("EOF");