fix #2727 Type checker does not detect a signature mismatch

src/compiler.ts

@@ -6611,7 +6611,9 @@ export class Compiler extends DiagnosticEmitter {
         if (!overrideInstance.is(CommonFlags.Compiled)) continue; // errored
         let overrideType = overrideInstance.type;
         let originalType = instance.type;
-        if (!overrideType.isAssignableTo(originalType)) {
+
+        assert(originalType.getSignature() != null && overrideType.getSignature() != null);
+        if (!(overrideType.getSignature() as Signature).isAssignableTo(originalType.getSignature() as Signature, true)) {
           this.error(
             DiagnosticCode.Type_0_is_not_assignable_to_type_1,
             overrideInstance.identifierNode.range, overrideType.toString(), originalType.toString()

src/types.ts

@@ -1051,21 +1051,23 @@ 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)) {
+
+    if (
+      (thisThisType == null && targetThisType != null) ||
+      (thisThisType != null && targetThisType == null)
+    ) {
+      return false;
+    }else if(thisThisType != null && targetThisType != null){
+      if(checkCompatibleOverride){
+        // check kind of `this` type
+        if(!thisThisType.canExtendOrImplement(targetThisType)){
+          return false;
+        }
+      }else{
+        // check `this` type (invariant)
+        if(!targetThisType.isAssignableTo(thisThisType)){
           return false;
         }
-      } else if (targetThisType) {
-        return false;
-      }
-    } else {
-      // check `this` type (invariant)
-      if (thisThisType) {
-        if (targetThisType != targetThisType) return false;
-      } else if (targetThisType) {
-        return false;
       }
     }
 

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

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

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

@@ -0,0 +1,52 @@
+class C {
+  aa: i32 = 1;
+  callback(a: i32): i32 {
+    return this.aa + a + 3;
+  }
+}
+
+function expectCallback(c1: (arg0: i32) => i32): i32 {
+  return c1(4);
+}
+
+export function fut(): i32 {
+  const c1 = new C();
+  return expectCallback(c1.callback);
+}
+
+fut();
+
+class A {
+  foo(): void {
+    console.log("A");
+  }
+}
+
+class B extends A {
+  foo(): void {
+    console.log("B");
+  }
+}
+
+function foo(): void {
+  console.log("nothing");
+}
+
+function consume(callback: (this: B) => void): void {
+  const b = new B();
+  callback.call(b);
+}
+
+export function testNull(): void {
+  consume(foo); // This should (and does) error; this is fine.
+}
+
+export function testA(): void {
+  const a = new A();
+  consume(a.foo); // This shouldn't error
+}
+
+testNull();
+testA();
+
+ERROR("EOF");