Type-check the this parameter of (override) signatures correctly

In most cases, a function type is assignable to another if the target
`this` parameter is a subtype of the original `this` parameter. However,
this check wasn't performed correctly in `Signature#isAssignableTo`.
Also, the reverse is true when checking whether override signatures are
compatible, since the `this` parameter refers to the subclass that's
overriding the parent class's method. At least, that's how I think it
works...

Fixes AssemblyScript#2727.
Closes AssemblyScript#2728.

Author: CountBleck

src/compiler.ts

@@ -6609,17 +6609,17 @@ 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)) {
+        let overrideSignature = overrideInstance.signature;
+        let 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,14 @@ 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) {
-        return false;
-      }
+    if (thisThisType && targetThisType) {
+      let compatibleThisType = checkCompatibleOverride
+        ? thisThisType.canExtendOrImplement(targetThisType)
+        : targetThisType.isAssignableTo(thisThisType);
+
+      if (!compatibleThisType) return false;
+    } else if (thisThisType || targetThisType) {
+      return false;
     }
 
     // check rest parameter

tests/compiler/class-method-as-parameter.json

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

tests/compiler/class-method-as-parameter.ts

@@ -0,0 +1,21 @@
+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");