fix according to PR comments

Author: Changqing-JING

src/compiler.ts

@@ -6609,19 +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;
 
-        assert(originalType.getSignature() != null && overrideType.getSignature() != null);
-        if (!(overrideType.getSignature() as Signature).isAssignableTo(originalType.getSignature() as Signature, true)) {
+        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

@@ -1052,23 +1052,14 @@ export class Signature {
     let thisThisType = this.thisType;
     let targetThisType = target.thisType;
 
-    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;
-        }
+    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

@@ -1,8 +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'.",
+    "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

@@ -1,52 +1,15 @@
-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");
-  }
+  foo(): void { }
 }
-
 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();
-
+  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");