Revert "Merge pull request microsoft#32049 from microsoft/noDuplicateIntersectionSignatures"

This reverts commit f89165d, reversing
changes made to 410b717.

Author: amcasey

src/compiler/checker.ts

@@ -7404,8 +7404,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: Signature[] | undefined;
-            let constructSignatures: Signature[] | undefined;
+            let callSignatures: ReadonlyArray<Signature> = emptyArray;
+            let constructSignatures: ReadonlyArray<Signature> = emptyArray;
             let stringIndexInfo: IndexInfo | undefined;
             let numberIndexInfo: IndexInfo | undefined;
             const types = type.types;
@@ -7427,22 +7427,13 @@ namespace ts {
                             return clone;
                         });
                     }
-                    constructSignatures = appendSignatures(constructSignatures, signatures);
+                    constructSignatures = concatenate(constructSignatures, signatures);
                 }
-                callSignatures = appendSignatures(callSignatures, getSignaturesOfType(t, SignatureKind.Call));
+                callSignatures = concatenate(callSignatures, getSignaturesOfType(t, SignatureKind.Call));
                 stringIndexInfo = intersectIndexInfos(stringIndexInfo, getIndexInfoOfType(t, IndexKind.String));
                 numberIndexInfo = intersectIndexInfos(numberIndexInfo, getIndexInfoOfType(t, IndexKind.Number));
             }
-            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;
+            setStructuredTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
         }
 
         /**
@@ -14633,25 +14624,20 @@ namespace ts {
             if (!(isMatchingSignature(source, target, partialMatch))) {
                 return Ternary.False;
             }
-            // Check that the two signatures have the same number of type parameters.
+            // 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.
             if (length(source.typeParameters) !== length(target.typeParameters)) {
                 return Ternary.False;
             }
-            // 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);
-            }
+            // 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);
             let result = Ternary.True;
+
             if (!ignoreThisTypes) {
                 const sourceThisType = getThisTypeOfSignature(source);
                 if (sourceThisType) {
@@ -14665,6 +14651,7 @@ namespace ts {
                     }
                 }
             }
+
             const targetLen = getParameterCount(target);
             for (let i = 0; i < targetLen; i++) {
                 const s = getTypeAtPosition(source, i);

tests/baselines/reference/genericSignatureIdentity.errors.txt

@@ -1,16 +1,12 @@
-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 (5 errors) ====
+==== tests/cases/compiler/identityForSignaturesWithTypeParametersAndAny.ts (4 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/identityForSignaturesWithTypeParametersAndAny.errors.txt

@@ -237,13 +237,4 @@ 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/identityForSignaturesWithTypeParametersSwitched.errors.txt

@@ -156,15 +156,6 @@ 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]
@@ -262,10 +253,3 @@ 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.errors.txt

@@ -564,26 +564,3 @@ 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.js

@@ -540,35 +540,3 @@ 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) & ((x: number, y: number) => void) & ((x: number, y: number) => void)
->window : Window & typeof globalThis
->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)) | (((x: number, y: number) => void) & ((x: number, y: number) => void))
->window : Window & typeof globalThis
->action : "resizeTo" | "resizeBy"
->x : number
->y : number
-	}
-}
-