fix #2727 Type checker does not detect a signature mismatch

src/compiler.ts

@@ -6609,17 +6609,18 @@ export class Compiler extends DiagnosticEmitter {
       for (let i = 0, k = overrideInstances.length; i < k; ++i) {
         let overrideInstance = overrideInstances[i];
         if (!overrideInstance.is(CommonFlags.Compiled)) continue; // errored
-        let overrideType = overrideInstance.type;
-        let originalType = instance.type;
-        if (!overrideType.isAssignableTo(originalType)) {
+
+        const overrideSignature = overrideInstance.signature;
+        const originalSignature = instance.signature;
+
+        if (!overrideSignature.isAssignableTo(originalSignature, true)) {
           this.error(
             DiagnosticCode.Type_0_is_not_assignable_to_type_1,
-            overrideInstance.identifierNode.range, overrideType.toString(), originalType.toString()
+            overrideInstance.identifierNode.range, overrideSignature.toString(), originalSignature.toString()
           );
           continue;
         }
         // TODO: additional optional parameters are not permitted by `isAssignableTo` yet
-        let overrideSignature = overrideInstance.signature;
         let overrideParameterTypes = overrideSignature.parameterTypes;
         let overrideNumParameters = overrideParameterTypes.length;
         let paramExprs = new Array<ExpressionRef>(1 + overrideNumParameters);

src/types.ts

@@ -1051,22 +1051,15 @@ export class Signature {
   isAssignableTo(target: Signature, checkCompatibleOverride: bool = false): bool {
     let thisThisType = this.thisType;
     let targetThisType = target.thisType;
-    if (checkCompatibleOverride) {
-      // check kind of `this` type
-      if (thisThisType) {
-        if (!targetThisType || !thisThisType.canExtendOrImplement(targetThisType)) {
-          return false;
-        }
-      } else if (targetThisType) {
-        return false;
-      }
-    } else {
-      // check `this` type (invariant)
-      if (thisThisType) {
-        if (targetThisType != targetThisType) return false;
-      } else if (targetThisType) {
+
+    if (thisThisType != null && targetThisType != null){
+      const compatibleThisType = checkCompatibleOverride ? thisThisType.canExtendOrImplement(targetThisType)
+        : targetThisType.isAssignableTo(thisThisType);
+      if (!compatibleThisType) {
         return false;
       }
+    }else if (thisThisType || targetThisType){
+      return false;
     }
 
     // check rest parameter

tests/compiler/class-member-function-as-parameter.json

@@ -0,0 +1,8 @@
+{
+  "asc_flags": [],
+  "stderr": [
+    "TS2322: Type '() => void' is not assignable to type '(this: class-member-function-as-parameter/A) => void'.",
+    "TS2322: Type '(this: class-member-function-as-parameter/B) => void' is not assignable to type '(this: class-member-function-as-parameter/A) => void'.",
+    "EOF"
+  ]
+}

tests/compiler/class-member-function-as-parameter.ts

@@ -0,0 +1,15 @@
+class A {
+  foo(): void { }
+}
+class B extends A {
+  foo(): void { }
+}
+function foo(): void { }
+function consumeA(callback: (this: A) => void): void { }
+function consumeB(callback: (this: B) => void): void { }
+const a = new A();
+const b = new B();
+consumeB(a.foo); // shouldn't error
+consumeA(foo);   // should error
+consumeA(b.foo); // should error
+ERROR("EOF");