Merge pull request #15381 from Microsoft/revert15104

Revert #15104

Author: mhegazy

src/compiler/checker.ts

@@ -8177,8 +8177,7 @@ namespace ts {
         function isSignatureAssignableTo(source: Signature,
             target: Signature,
             ignoreReturnTypes: boolean): boolean {
-            return compareSignaturesRelated(source, target, /*checkAsCallback*/ false, ignoreReturnTypes, /*reportErrors*/ false,
-                /*errorReporter*/ undefined, compareTypesAssignable) !== Ternary.False;
+            return compareSignaturesRelated(source, target, ignoreReturnTypes, /*reportErrors*/ false, /*errorReporter*/ undefined, compareTypesAssignable) !== Ternary.False;
         }
 
         type ErrorReporter = (message: DiagnosticMessage, arg0?: string, arg1?: string) => void;
@@ -8188,7 +8187,6 @@ namespace ts {
          */
         function compareSignaturesRelated(source: Signature,
             target: Signature,
-            checkAsCallback: boolean,
             ignoreReturnTypes: boolean,
             reportErrors: boolean,
             errorReporter: ErrorReporter,
@@ -8231,23 +8229,9 @@ namespace ts {
             const sourceParams = source.parameters;
             const targetParams = target.parameters;
             for (let i = 0; i < checkCount; i++) {
-                const sourceType = i < sourceMax ? getTypeOfParameter(sourceParams[i]) : getRestTypeOfSignature(source);
-                const targetType = i < targetMax ? getTypeOfParameter(targetParams[i]) : getRestTypeOfSignature(target);
-                const sourceSig = getSingleCallSignature(getNonNullableType(sourceType));
-                const targetSig = getSingleCallSignature(getNonNullableType(targetType));
-                // In order to ensure that any generic type Foo<T> is at least co-variant with respect to T no matter
-                // how Foo uses T, we need to relate parameters bi-variantly (given that parameters are input positions,
-                // they naturally relate only contra-variantly). However, if the source and target parameters both have
-                // function types with a single call signature, we known we are relating two callback parameters. In
-                // that case it is sufficient to only relate the parameters of the signatures co-variantly because,
-                // similar to return values, callback parameters are output positions. This means that a Promise<T>,
-                // where T is used only in callback parameter positions, will be co-variant (as opposed to bi-variant)
-                // with respect to T.
-                const callbacks = sourceSig && targetSig && !sourceSig.typePredicate && !targetSig.typePredicate &&
-                    (getFalsyFlags(sourceType) & TypeFlags.Nullable) === (getFalsyFlags(targetType) & TypeFlags.Nullable);
-                const related = callbacks ?
-                    compareSignaturesRelated(targetSig, sourceSig, /*checkAsCallback*/ true, /*ignoreReturnTypes*/ false, reportErrors, errorReporter, compareTypes) :
-                    !checkAsCallback && compareTypes(sourceType, targetType, /*reportErrors*/ false) || compareTypes(targetType, sourceType, reportErrors);
+                const s = i < sourceMax ? getTypeOfParameter(sourceParams[i]) : getRestTypeOfSignature(source);
+                const t = i < targetMax ? getTypeOfParameter(targetParams[i]) : getRestTypeOfSignature(target);
+                const related = compareTypes(s, t, /*reportErrors*/ false) || compareTypes(t, s, reportErrors);
                 if (!related) {
                     if (reportErrors) {
                         errorReporter(Diagnostics.Types_of_parameters_0_and_1_are_incompatible,
@@ -8279,11 +8263,7 @@ namespace ts {
                     }
                 }
                 else {
-                    // When relating callback signatures, we still need to relate return types bi-variantly as otherwise
-                    // the containing type wouldn't be co-variant. For example, interface Foo<T> { add(cb: () => T): void }
-                    // wouldn't be co-variant for T without this rule.
-                    result &= checkAsCallback && compareTypes(targetReturnType, sourceReturnType, /*reportErrors*/ false) ||
-                        compareTypes(sourceReturnType, targetReturnType, reportErrors);
+                    result &= compareTypes(sourceReturnType, targetReturnType, reportErrors);
                 }
 
             }
@@ -9251,7 +9231,7 @@ namespace ts {
              * See signatureAssignableTo, compareSignaturesIdentical
              */
             function signatureRelatedTo(source: Signature, target: Signature, reportErrors: boolean): Ternary {
-                return compareSignaturesRelated(source, target, /*checkAsCallback*/ false, /*ignoreReturnTypes*/ false, reportErrors, reportError, isRelatedTo);
+                return compareSignaturesRelated(source, target, /*ignoreReturnTypes*/ false, reportErrors, reportError, isRelatedTo);
             }
 
             function signaturesIdenticalTo(source: Type, target: Type, kind: SignatureKind): Ternary {

src/compiler/parser.ts

@@ -57,7 +57,7 @@ namespace ts {
         // The visitXXX functions could be written as local functions that close over the cbNode and cbNodeArray
         // callback parameters, but that causes a closure allocation for each invocation with noticeable effects
         // on performance.
-        const visitNodes: (cb: ((node: Node) => T) | ((node: Node[]) => T), nodes: Node[]) => T = cbNodeArray ? visitNodeArray : visitEachNode;
+        const visitNodes: (cb: (node: Node | Node[]) => T, nodes: Node[]) => T = cbNodeArray ? visitNodeArray : visitEachNode;
         const cbNodes = cbNodeArray || cbNode;
         switch (node.kind) {
             case SyntaxKind.QualifiedName:

src/compiler/visitor.ts

@@ -885,7 +885,7 @@ namespace ts {
             return initial;
         }
 
-        const reduceNodes: (nodes: NodeArray<Node>, f: ((memo: T, node: Node) => T) | ((memo: T, node: NodeArray<Node>) => T), initial: T) => T = cbNodeArray ? reduceNodeArray : reduceLeft;
+        const reduceNodes: (nodes: NodeArray<Node>, f: (memo: T, node: Node | NodeArray<Node>) => T, initial: T) => T = cbNodeArray ? reduceNodeArray : reduceLeft;
         const cbNodes = cbNodeArray || cbNode;
         const kind = node.kind;
 

tests/baselines/reference/assignmentCompatWithCallSignatures3.errors.txt

@@ -1,15 +1,17 @@
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures4.ts(52,9): error TS2322: Type '<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U' is not assignable to type '(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived'.
   Types of parameters 'y' and 'y' are incompatible.
-    Types of parameters 'arg2' and 'arg2' are incompatible.
-      Type '{ foo: number; }' is not assignable to type 'Base'.
-        Types of property 'foo' are incompatible.
-          Type 'number' is not assignable to type 'string'.
+    Type '(arg2: Base) => Derived' is not assignable to type '(arg2: { foo: number; }) => any'.
+      Types of parameters 'arg2' and 'arg2' are incompatible.
+        Type '{ foo: number; }' is not assignable to type 'Base'.
+          Types of property 'foo' are incompatible.
+            Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures4.ts(53,9): error TS2322: Type '(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived' is not assignable to type '<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U'.
   Types of parameters 'y' and 'y' are incompatible.
-    Types of parameters 'arg2' and 'arg2' are incompatible.
-      Type 'Base' is not assignable to type '{ foo: number; }'.
-        Types of property 'foo' are incompatible.
-          Type 'string' is not assignable to type 'number'.
+    Type '(arg2: { foo: number; }) => any' is not assignable to type '(arg2: Base) => Derived'.
+      Types of parameters 'arg2' and 'arg2' are incompatible.
+        Type 'Base' is not assignable to type '{ foo: number; }'.
+          Types of property 'foo' are incompatible.
+            Type 'string' is not assignable to type 'number'.
 
 
 ==== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures4.ts (2 errors) ====
@@ -68,18 +70,20 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignme
             ~~
 !!! error TS2322: Type '<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U' is not assignable to type '(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived'.
 !!! error TS2322:   Types of parameters 'y' and 'y' are incompatible.
-!!! error TS2322:     Types of parameters 'arg2' and 'arg2' are incompatible.
-!!! error TS2322:       Type '{ foo: number; }' is not assignable to type 'Base'.
-!!! error TS2322:         Types of property 'foo' are incompatible.
-!!! error TS2322:           Type 'number' is not assignable to type 'string'.
+!!! error TS2322:     Type '(arg2: Base) => Derived' is not assignable to type '(arg2: { foo: number; }) => any'.
+!!! error TS2322:       Types of parameters 'arg2' and 'arg2' are incompatible.
+!!! error TS2322:         Type '{ foo: number; }' is not assignable to type 'Base'.
+!!! error TS2322:           Types of property 'foo' are incompatible.
+!!! error TS2322:             Type 'number' is not assignable to type 'string'.
             b8 = a8; // error, { foo: number } and Base are incompatible
             ~~
 !!! error TS2322: Type '(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived' is not assignable to type '<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U'.
 !!! error TS2322:   Types of parameters 'y' and 'y' are incompatible.
-!!! error TS2322:     Types of parameters 'arg2' and 'arg2' are incompatible.
-!!! error TS2322:       Type 'Base' is not assignable to type '{ foo: number; }'.
-!!! error TS2322:         Types of property 'foo' are incompatible.
-!!! error TS2322:           Type 'string' is not assignable to type 'number'.
+!!! error TS2322:     Type '(arg2: { foo: number; }) => any' is not assignable to type '(arg2: Base) => Derived'.
+!!! error TS2322:       Types of parameters 'arg2' and 'arg2' are incompatible.
+!!! error TS2322:         Type 'Base' is not assignable to type '{ foo: number; }'.
+!!! error TS2322:           Types of property 'foo' are incompatible.
+!!! error TS2322:             Type 'string' is not assignable to type 'number'.
 
 
             var b10: <T extends Derived>(...x: T[]) => T;