Merge pull request microsoft#32049 from microsoft/noDuplicateIntersectionSignatures

Remove duplicate signatures in intersections

Author: ahejlsberg

src/compiler/checker.ts

@@ -7234,8 +7234,8 @@ namespace ts {
         function resolveIntersectionTypeMembers(type: IntersectionType) {
             // The members and properties collections are empty for intersection types. To get all properties of an
             // intersection type use getPropertiesOfType (only the language service uses this).
-            let callSignatures: ReadonlyArray<Signature> = emptyArray;
-            let constructSignatures: ReadonlyArray<Signature> = emptyArray;
+            let callSignatures: Signature[] | undefined;
+            let constructSignatures: Signature[] | undefined;
             let stringIndexInfo: IndexInfo | undefined;
             let numberIndexInfo: IndexInfo | undefined;
             const types = type.types;
@@ -7257,13 +7257,22 @@ namespace ts {
                             return clone;
                         });
                     }
-                    constructSignatures = concatenate(constructSignatures, signatures);
+                    constructSignatures = appendSignatures(constructSignatures, signatures);
                 }
-                callSignatures = concatenate(callSignatures, getSignaturesOfType(t, SignatureKind.Call));
+                callSignatures = appendSignatures(callSignatures, getSignaturesOfType(t, SignatureKind.Call));
                 stringIndexInfo = intersectIndexInfos(stringIndexInfo, getIndexInfoOfType(t, IndexKind.String));
                 numberIndexInfo = intersectIndexInfos(numberIndexInfo, getIndexInfoOfType(t, IndexKind.Number));
             }
-            setStructuredTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
+            setStructuredTypeMembers(type, emptySymbols, callSignatures || emptyArray, constructSignatures || emptyArray, stringIndexInfo, numberIndexInfo);
+        }
+
+        function appendSignatures(signatures: Signature[] | undefined, newSignatures: readonly Signature[]) {
+            for (const sig of newSignatures) {
+                if (!signatures || every(signatures, s => !compareSignaturesIdentical(s, sig, /*partialMatch*/ false, /*ignoreThisTypes*/ false, /*ignoreReturnTypes*/ false, compareTypesIdentical))) {
+                    signatures = append(signatures, sig);
+                }
+            }
+            return signatures;
         }
 
         /**
@@ -14325,20 +14334,25 @@ namespace ts {
             if (!(isMatchingSignature(source, target, partialMatch))) {
                 return Ternary.False;
             }
-            // Check that the two signatures have the same number of type parameters. We might consider
-            // also checking that any type parameter constraints match, but that would require instantiating
-            // the constraints with a common set of type arguments to get relatable entities in places where
-            // type parameters occur in the constraints. The complexity of doing that doesn't seem worthwhile,
-            // particularly as we're comparing erased versions of the signatures below.
+            // Check that the two signatures have the same number of type parameters.
             if (length(source.typeParameters) !== length(target.typeParameters)) {
                 return Ternary.False;
             }
-            // Spec 1.0 Section 3.8.3 & 3.8.4:
-            // M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N
-            source = getErasedSignature(source);
-            target = getErasedSignature(target);
+            // Check that type parameter constraints and defaults match. If they do, instantiate the source
+            // signature with the type parameters of the target signature and continue the comparison.
+            if (target.typeParameters) {
+                const mapper = createTypeMapper(source.typeParameters!, target.typeParameters);
+                for (let i = 0; i < target.typeParameters.length; i++) {
+                    const s = source.typeParameters![i];
+                    const t = target.typeParameters[i];
+                    if (!(s === t || compareTypes(instantiateType(getConstraintFromTypeParameter(s), mapper) || unknownType, getConstraintFromTypeParameter(t) || unknownType) &&
+                        compareTypes(instantiateType(getDefaultFromTypeParameter(s), mapper) || unknownType, getDefaultFromTypeParameter(t) || unknownType))) {
+                        return Ternary.False;
+                    }
+                }
+                source = instantiateSignature(source, mapper, /*eraseTypeParameters*/ true);
+            }
             let result = Ternary.True;
-
             if (!ignoreThisTypes) {
                 const sourceThisType = getThisTypeOfSignature(source);
                 if (sourceThisType) {
@@ -14352,7 +14366,6 @@ namespace ts {
                     }
                 }
             }
-
             const targetLen = getParameterCount(target);
             for (let i = 0; i < targetLen; i++) {
                 const s = getTypeAtPosition(source, i);

tests/baselines/reference/genericSignatureIdentity.errors.txt

@@ -0,0 +1,36 @@
+tests/cases/compiler/genericSignatureIdentity.ts(10,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'x' must be of type '<T extends Date>(x: T) => T', but here has type '<T extends number>(x: T) => T'.
+tests/cases/compiler/genericSignatureIdentity.ts(14,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'x' must be of type '<T extends Date>(x: T) => T', but here has type '<T>(x: T) => T'.
+tests/cases/compiler/genericSignatureIdentity.ts(18,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'x' must be of type '<T extends Date>(x: T) => T', but here has type '<T>(x: any) => any'.
+
+
+==== tests/cases/compiler/genericSignatureIdentity.ts (3 errors) ====
+    // This test is here to remind us of our current limits of type identity checking.
+    // Ideally all of the below declarations would be considered different (and thus errors)
+    // but they aren't because we erase type parameters to type any and don't check that
+    // constraints are identical.
+    
+    var x: {
+        <T extends Date>(x: T): T;
+    };
+    
+    var x: {
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'x' must be of type '<T extends Date>(x: T) => T', but here has type '<T extends number>(x: T) => T'.
+!!! related TS6203 tests/cases/compiler/genericSignatureIdentity.ts:6:5: 'x' was also declared here.
+        <T extends number>(x: T): T;
+    };
+    
+    var x: {
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'x' must be of type '<T extends Date>(x: T) => T', but here has type '<T>(x: T) => T'.
+!!! related TS6203 tests/cases/compiler/genericSignatureIdentity.ts:6:5: 'x' was also declared here.
+        <T>(x: T): T;
+    };
+    
+    var x: {
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'x' must be of type '<T extends Date>(x: T) => T', but here has type '<T>(x: any) => any'.
+!!! related TS6203 tests/cases/compiler/genericSignatureIdentity.ts:6:5: 'x' was also declared here.
+        <T>(x: any): any;
+    };
+    

tests/baselines/reference/identityForSignaturesWithTypeParametersAndAny.errors.txt

@@ -1,12 +1,16 @@
+tests/cases/compiler/identityForSignaturesWithTypeParametersAndAny.ts(2,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '<T, U>(x: T, y: U) => T', but here has type '<T, U>(x: any, y: any) => any'.
 tests/cases/compiler/identityForSignaturesWithTypeParametersAndAny.ts(5,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'g' must be of type '<T, U>(x: T, y: U) => T', but here has type '<T>(x: any, y: any) => any'.
 tests/cases/compiler/identityForSignaturesWithTypeParametersAndAny.ts(8,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'h' must be of type '<T, U>(x: T, y: U) => T', but here has type '(x: any, y: any) => any'.
 tests/cases/compiler/identityForSignaturesWithTypeParametersAndAny.ts(11,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'i' must be of type '<T, U>(x: T, y: U) => T', but here has type '<T, U>(x: any, y: string) => any'.
 tests/cases/compiler/identityForSignaturesWithTypeParametersAndAny.ts(14,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'j' must be of type '<T, U>(x: T, y: U) => T', but here has type '<T, U>(x: any, y: any) => string'.
 
 
-==== tests/cases/compiler/identityForSignaturesWithTypeParametersAndAny.ts (4 errors) ====
+==== tests/cases/compiler/identityForSignaturesWithTypeParametersAndAny.ts (5 errors) ====
     var f: <T, U>(x: T, y: U) => T;
     var f: <T, U>(x: any, y: any) => any;
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '<T, U>(x: T, y: U) => T', but here has type '<T, U>(x: any, y: any) => any'.
+!!! related TS6203 tests/cases/compiler/identityForSignaturesWithTypeParametersAndAny.ts:1:5: 'f' was also declared here.
 
     var g: <T, U>(x: T, y: U) => T;
     var g: <T>(x: any, y: any) => any;

tests/baselines/reference/identityForSignaturesWithTypeParametersSwitched.errors.txt

@@ -0,0 +1,9 @@
+tests/cases/compiler/identityForSignaturesWithTypeParametersSwitched.ts(2,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '<T, U>(x: T, y: U) => T', but here has type '<T, U>(x: U, y: T) => U'.
+
+
+==== tests/cases/compiler/identityForSignaturesWithTypeParametersSwitched.ts (1 errors) ====
+    var f: <T, U>(x: T, y: U) => T;
+    var f: <T, U>(x: U, y: T) => U;
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '<T, U>(x: T, y: U) => T', but here has type '<T, U>(x: U, y: T) => U'.
+!!! related TS6203 tests/cases/compiler/identityForSignaturesWithTypeParametersSwitched.ts:1:5: 'f' was also declared here.

tests/baselines/reference/keyofAndIndexedAccess2.errors.txt

@@ -237,4 +237,13 @@ tests/cases/conformance/types/keyof/keyofAndIndexedAccess2.ts(108,5): error TS23
     type Baz<T, Q extends Foo<T>> = { [K in keyof Q]: T[Q[K]] };
 
     type Qux<T, Q extends Bar<T>> = { [K in keyof Q]: T[Q[K]["0"]] };
+    
+    // Repro from #32038
+    
+    const actions = ['resizeTo', 'resizeBy'] as const;
+    for (const action of actions) {
+    	window[action] = (x, y) => {
+    		window[action](x, y);
+    	}
+    }
 

tests/baselines/reference/keyofAndIndexedAccess2.js

@@ -156,6 +156,15 @@ type Bar<T> = { [key: string]: { [K in keyof T]: [K] }[keyof T] };
 type Baz<T, Q extends Foo<T>> = { [K in keyof Q]: T[Q[K]] };
 
 type Qux<T, Q extends Bar<T>> = { [K in keyof Q]: T[Q[K]["0"]] };
+
+// Repro from #32038
+
+const actions = ['resizeTo', 'resizeBy'] as const;
+for (const action of actions) {
+	window[action] = (x, y) => {
+		window[action](x, y);
+	}
+}
 
 
 //// [keyofAndIndexedAccess2.js]
@@ -253,3 +262,10 @@ export class c {
         this["a"] = "b";
     }
 }
+// Repro from #32038
+const actions = ['resizeTo', 'resizeBy'];
+for (const action of actions) {
+    window[action] = (x, y) => {
+        window[action](x, y);
+    };
+}

tests/baselines/reference/keyofAndIndexedAccess2.symbols

@@ -564,3 +564,26 @@ type Qux<T, Q extends Bar<T>> = { [K in keyof Q]: T[Q[K]["0"]] };
 >Q : Symbol(Q, Decl(keyofAndIndexedAccess2.ts, 156, 11))
 >K : Symbol(K, Decl(keyofAndIndexedAccess2.ts, 156, 35))
 
+// Repro from #32038
+
+const actions = ['resizeTo', 'resizeBy'] as const;
+>actions : Symbol(actions, Decl(keyofAndIndexedAccess2.ts, 160, 5))
+
+for (const action of actions) {
+>action : Symbol(action, Decl(keyofAndIndexedAccess2.ts, 161, 10))
+>actions : Symbol(actions, Decl(keyofAndIndexedAccess2.ts, 160, 5))
+
+	window[action] = (x, y) => {
+>window : Symbol(window, Decl(lib.dom.d.ts, --, --))
+>action : Symbol(action, Decl(keyofAndIndexedAccess2.ts, 161, 10))
+>x : Symbol(x, Decl(keyofAndIndexedAccess2.ts, 162, 19))
+>y : Symbol(y, Decl(keyofAndIndexedAccess2.ts, 162, 21))
+
+		window[action](x, y);
+>window : Symbol(window, Decl(lib.dom.d.ts, --, --))
+>action : Symbol(action, Decl(keyofAndIndexedAccess2.ts, 161, 10))
+>x : Symbol(x, Decl(keyofAndIndexedAccess2.ts, 162, 19))
+>y : Symbol(y, Decl(keyofAndIndexedAccess2.ts, 162, 21))
+	}
+}
+

tests/baselines/reference/keyofAndIndexedAccess2.types

@@ -540,3 +540,35 @@ type Baz<T, Q extends Foo<T>> = { [K in keyof Q]: T[Q[K]] };
 type Qux<T, Q extends Bar<T>> = { [K in keyof Q]: T[Q[K]["0"]] };
 >Qux : Qux<T, Q>
 
+// Repro from #32038
+
+const actions = ['resizeTo', 'resizeBy'] as const;
+>actions : readonly ["resizeTo", "resizeBy"]
+>['resizeTo', 'resizeBy'] as const : readonly ["resizeTo", "resizeBy"]
+>['resizeTo', 'resizeBy'] : readonly ["resizeTo", "resizeBy"]
+>'resizeTo' : "resizeTo"
+>'resizeBy' : "resizeBy"
+
+for (const action of actions) {
+>action : "resizeTo" | "resizeBy"
+>actions : readonly ["resizeTo", "resizeBy"]
+
+	window[action] = (x, y) => {
+>window[action] = (x, y) => {		window[action](x, y);	} : (x: number, y: number) => void
+>window[action] : ((x: number, y: number) => void) & ((x: number, y: number) => void)
+>window : Window
+>action : "resizeTo" | "resizeBy"
+>(x, y) => {		window[action](x, y);	} : (x: number, y: number) => void
+>x : number
+>y : number
+
+		window[action](x, y);
+>window[action](x, y) : void
+>window[action] : ((x: number, y: number) => void) | ((x: number, y: number) => void)
+>window : Window
+>action : "resizeTo" | "resizeBy"
+>x : number
+>y : number
+	}
+}
+

tests/baselines/reference/promiseIdentity.errors.txt

@@ -0,0 +1,28 @@
+tests/cases/compiler/promiseIdentity.ts(21,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'y' must be of type 'IPromise2<string, number>', but here has type 'Promise2<any, string>'.
+
+
+==== tests/cases/compiler/promiseIdentity.ts (1 errors) ====
+    export interface IPromise<T> {
+        then<U>(callback: (x: T) => IPromise<U>): IPromise<U>;
+    }
+    interface Promise<T> {
+        then<U>(callback: (x: T) => Promise<U>): Promise<U>;
+    }
+    var x: IPromise<string>;
+    var x: Promise<string>;
+    
+    
+    interface IPromise2<T, V> {
+        then<U, W>(callback: (x: T) => IPromise2<U, W>): IPromise2<W, U>;
+    }
+    interface Promise2<T, V> {
+        then<U, W>(callback: (x: V) => Promise2<U, T>): Promise2<T, W>; // Uses V instead of T in callback's parameter
+    }
+    
+    // Ok because T in this particular Promise2 is any, as are all the U and W references.
+    // Also, the V of Promise2 happens to coincide with the T of IPromise2 (they are both string).
+    var y: IPromise2<string, number>;
+    var y: Promise2<any, string>;
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'y' must be of type 'IPromise2<string, number>', but here has type 'Promise2<any, string>'.
+!!! related TS6203 tests/cases/compiler/promiseIdentity.ts:20:5: 'y' was also declared here.

tests/baselines/reference/promiseIdentityWithAny.errors.txt

@@ -0,0 +1,17 @@
+tests/cases/compiler/promiseIdentityWithAny.ts(10,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'x' must be of type 'IPromise<string, number>', but here has type 'Promise<string, boolean>'.
+
+
+==== tests/cases/compiler/promiseIdentityWithAny.ts (1 errors) ====
+    export interface IPromise<T, V> {
+        then<U, W>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
+    }
+    export interface Promise<T, V> {
+        then<U, W>(callback: (x: T) => Promise<any, any>): Promise<any, any>;
+    }
+    
+    // Should be ok because signature type parameters get erased to any
+    var x: IPromise<string, number>;
+    var x: Promise<string, boolean>;
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'x' must be of type 'IPromise<string, number>', but here has type 'Promise<string, boolean>'.
+!!! related TS6203 tests/cases/compiler/promiseIdentityWithAny.ts:9:5: 'x' was also declared here.

tests/baselines/reference/promiseIdentityWithConstraints.errors.txt

@@ -0,0 +1,17 @@
+tests/cases/compiler/promiseIdentityWithConstraints.ts(10,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'x' must be of type 'IPromise<string, number>', but here has type 'Promise<string, boolean>'.
+
+
+==== tests/cases/compiler/promiseIdentityWithConstraints.ts (1 errors) ====
+    export interface IPromise<T, V> {
+        then<U extends T, W extends V>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
+    }
+    export interface Promise<T, V> {
+        then<U extends T, W extends V>(callback: (x: T) => Promise<U, W>): Promise<U, W>;
+    }
+    
+    // Error because constraint V doesn't match
+    var x: IPromise<string, number>;
+    var x: Promise<string, boolean>;
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'x' must be of type 'IPromise<string, number>', but here has type 'Promise<string, boolean>'.
+!!! related TS6203 tests/cases/compiler/promiseIdentityWithConstraints.ts:9:5: 'x' was also declared here.

tests/cases/conformance/types/keyof/keyofAndIndexedAccess2.ts

@@ -158,3 +158,12 @@ type Bar<T> = { [key: string]: { [K in keyof T]: [K] }[keyof T] };
 type Baz<T, Q extends Foo<T>> = { [K in keyof Q]: T[Q[K]] };
 
 type Qux<T, Q extends Bar<T>> = { [K in keyof Q]: T[Q[K]["0"]] };
+
+// Repro from #32038
+
+const actions = ['resizeTo', 'resizeBy'] as const;
+for (const action of actions) {
+	window[action] = (x, y) => {
+		window[action](x, y);
+	}
+}