From 6df05fa8cb07680a043275774c359e463e3955da Mon Sep 17 00:00:00 2001
From: Wesley Wigham <wewigham@microsoft.com>
Date: Thu, 18 Apr 2019 12:53:08 -0700
Subject: [PATCH 1/5] Have signature identity checks look at the base
 constraint of type parameters, allow identical type parameter lists to merge
 in union signatures

---
 src/compiler/checker.ts                       | 68 +++++++++++++++----
 src/compiler/types.ts                         |  4 +-
 .../genericSignatureIdentity.errors.txt       | 33 +++++++++
 ...naturesWithTypeParametersAndAny.errors.txt |  5 +-
 .../reference/promiseIdentity.errors.txt      | 27 ++++++++
 .../promiseIdentityWithAny.errors.txt         | 16 +++++
 .../baselines/reference/unionOfClassCalls.js  | 21 ++++++
 .../reference/unionOfClassCalls.symbols       | 42 ++++++++++++
 .../reference/unionOfClassCalls.types         | 34 ++++++++++
 tests/cases/compiler/unionOfClassCalls.ts     | 14 ++++
 10 files changed, 250 insertions(+), 14 deletions(-)
 create mode 100644 tests/baselines/reference/genericSignatureIdentity.errors.txt
 create mode 100644 tests/baselines/reference/promiseIdentity.errors.txt
 create mode 100644 tests/baselines/reference/promiseIdentityWithAny.errors.txt
 create mode 100644 tests/baselines/reference/unionOfClassCalls.js
 create mode 100644 tests/baselines/reference/unionOfClassCalls.symbols
 create mode 100644 tests/baselines/reference/unionOfClassCalls.types
 create mode 100644 tests/cases/compiler/unionOfClassCalls.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 308b95c218611..ee6617f3a1d03 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -6968,7 +6968,7 @@ namespace ts {
                     if (signatures !== masterList) {
                         const signature = signatures[0];
                         Debug.assert(!!signature, "getUnionSignatures bails early on empty signature lists and should not have empty lists on second pass");
-                        results = signature.typeParameters && some(results, s => !!s.typeParameters) ? undefined : map(results, sig => combineSignaturesOfUnionMembers(sig, signature));
+                        results = signature.typeParameters && some(results, s => !!s.typeParameters && !compareTypeParametersIdentical(signature.typeParameters!, s.typeParameters)) ? undefined : map(results, sig => combineSignaturesOfUnionMembers(sig, signature));
                         if (!results) {
                             break;
                         }
@@ -6979,18 +6979,34 @@ namespace ts {
             return result || emptyArray;
         }
 
-        function combineUnionThisParam(left: Symbol | undefined, right: Symbol | undefined): Symbol | undefined {
+        function compareTypeParametersIdentical(sourceParams: readonly TypeParameter[], targetParams: readonly TypeParameter[]): boolean {
+            if (sourceParams.length !== targetParams.length) {
+                return false;
+            }
+
+            for (let i = 0; i < sourceParams.length; i++) {
+                const source = sourceParams[i];
+                const target = targetParams[i];
+                if (source === target) continue;
+                if (!isTypeIdenticalTo(getConstraintFromTypeParameter(source) || unknownType, getConstraintFromTypeParameter(target) || unknownType)) return false;
+                if (!isTypeIdenticalTo(getDefaultFromTypeParameter(source) || unknownType, getDefaultFromTypeParameter(target) || unknownType)) return false;
+            }
+
+            return true;
+        }
+
+        function combineUnionThisParam(left: Symbol | undefined, right: Symbol | undefined, mapper: TypeMapper | undefined): Symbol | undefined {
             if (!left || !right) {
                 return left || right;
             }
             // A signature `this` type might be a read or a write position... It's very possible that it should be invariant
             // and we should refuse to merge signatures if there are `this` types and they do not match. However, so as to be
             // permissive when calling, for now, we'll union the `this` types just like the overlapping-union-signature check does
-            const thisType = getUnionType([getTypeOfSymbol(left), getTypeOfSymbol(right)], UnionReduction.Subtype);
+            const thisType = getUnionType([getTypeOfSymbol(left), instantiateType(getTypeOfSymbol(right), mapper)], UnionReduction.Subtype);
             return createSymbolWithType(left, thisType);
         }
 
-        function combineUnionParameters(left: Signature, right: Signature) {
+        function combineUnionParameters(left: Signature, right: Signature, mapper: TypeMapper | undefined) {
             const longest = getParameterCount(left) >= getParameterCount(right) ? left : right;
             const shorter = longest === left ? right : left;
             const longestCount = getParameterCount(longest);
@@ -6998,8 +7014,14 @@ namespace ts {
             const needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest);
             const params = new Array<Symbol>(longestCount + (needsExtraRestElement ? 1 : 0));
             for (let i = 0; i < longestCount; i++) {
-                const longestParamType = tryGetTypeAtPosition(longest, i)!;
-                const shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType;
+                let longestParamType = tryGetTypeAtPosition(longest, i)!;
+                if (longest === right) {
+                    longestParamType = instantiateType(longestParamType, mapper);
+                }
+                let shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType;
+                if (shorter === right) {
+                    shorterParamType = instantiateType(shorterParamType, mapper);
+                }
                 const unionParamType = getIntersectionType([longestParamType, shorterParamType]);
                 const isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === (longestCount - 1);
                 const isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter);
@@ -7015,21 +7037,29 @@ namespace ts {
             if (needsExtraRestElement) {
                 const restParamSymbol = createSymbol(SymbolFlags.FunctionScopedVariable, "args" as __String);
                 restParamSymbol.type = createArrayType(getTypeAtPosition(shorter, longestCount));
+                if (shorter === right) {
+                    restParamSymbol.type = instantiateType(restParamSymbol.type, mapper);
+                }
                 params[longestCount] = restParamSymbol;
             }
             return params;
         }
 
         function combineSignaturesOfUnionMembers(left: Signature, right: Signature): Signature {
+            const typeParams = left.typeParameters || right.typeParameters;
+            let paramMapper: TypeMapper | undefined;
+            if (left.typeParameters && right.typeParameters) {
+                paramMapper = createTypeMapper(right.typeParameters, left.typeParameters);
+            }
             const declaration = left.declaration;
-            const params = combineUnionParameters(left, right);
-            const thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter);
+            const params = combineUnionParameters(left, right, paramMapper);
+            const thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter, paramMapper);
             const minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount);
             const hasRestParam = left.hasRestParameter || right.hasRestParameter;
             const hasLiteralTypes = left.hasLiteralTypes || right.hasLiteralTypes;
             const result = createSignature(
                 declaration,
-                left.typeParameters || right.typeParameters,
+                typeParams,
                 thisParam,
                 params,
                 /*resolvedReturnType*/ undefined,
@@ -7039,6 +7069,9 @@ namespace ts {
                 hasLiteralTypes
             );
             result.unionSignatures = concatenate(left.unionSignatures || [left], [right]);
+            if (paramMapper) {
+                result.mapper = left.mapper && left.unionSignatures ? combineTypeMappers(left.mapper, paramMapper) : paramMapper;
+            }
             return result;
         }
 
@@ -8417,7 +8450,7 @@ namespace ts {
                     return errorType;
                 }
                 let type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper!) :
-                    signature.unionSignatures ? getUnionType(map(signature.unionSignatures, getReturnTypeOfSignature), UnionReduction.Subtype) :
+                    signature.unionSignatures ? instantiateType(getUnionType(map(signature.unionSignatures, getReturnTypeOfSignature), UnionReduction.Subtype), signature.mapper) :
                     getReturnTypeFromAnnotation(signature.declaration!) ||
                     isJSConstructor(signature.declaration) && getJSClassType(getSymbolOfNode(signature.declaration!)) ||
                     (nodeIsMissing((<FunctionLikeDeclaration>signature.declaration).body) ? anyType : getReturnTypeFromBody(<FunctionLikeDeclaration>signature.declaration));
@@ -8531,6 +8564,17 @@ namespace ts {
             return instantiateSignature(signature, createTypeEraser(signature.typeParameters!), /*eraseTypeParameters*/ true);
         }
 
+        function getConstrainedSignature(signature: Signature): Signature {
+            return signature.typeParameters ?
+                signature.constrainedSignatureCache || (signature.constrainedSignatureCache = createConstrainedSignature(signature)) :
+                signature;
+        }
+
+        function createConstrainedSignature(signature: Signature) {
+            // Create an instantiation of the signature where all type arguments are their base constraint
+            return instantiateSignature(signature, t => contains(signature.typeParameters, t) ? getBaseConstraintOfType(t) || unknownType : t, /*eraseTypeParameters*/ true);
+        }
+
         function getCanonicalSignature(signature: Signature): Signature {
             return signature.typeParameters ?
                 signature.canonicalSignatureCache || (signature.canonicalSignatureCache = createCanonicalSignature(signature)) :
@@ -13883,8 +13927,8 @@ namespace ts {
             }
             // 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);
+            source = getConstrainedSignature(source);
+            target = getConstrainedSignature(target);
             let result = Ternary.True;
 
             if (!ignoreThisTypes) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 826c567b06fbd..6e972b18f10cc 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -4381,7 +4381,9 @@ namespace ts {
         /* @internal */
         unionSignatures?: Signature[];      // Underlying signatures of a union signature
         /* @internal */
-        erasedSignatureCache?: Signature;   // Erased version of signature (deferred)
+        erasedSignatureCache?: Signature;   // Erased version of signature (to any) (deferred)
+        /* @internal */
+        constrainedSignatureCache?: Signature;// Erased version of signature (to constraints) (deferred)
         /* @internal */
         canonicalSignatureCache?: Signature; // Canonical version of signature (deferred)
         /* @internal */
diff --git a/tests/baselines/reference/genericSignatureIdentity.errors.txt b/tests/baselines/reference/genericSignatureIdentity.errors.txt
new file mode 100644
index 0000000000000..08bc0119ba4f7
--- /dev/null
+++ b/tests/baselines/reference/genericSignatureIdentity.errors.txt
@@ -0,0 +1,33 @@
+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'.
+        <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'.
+        <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'.
+        <T>(x: any): any;
+    };
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/identityForSignaturesWithTypeParametersAndAny.errors.txt b/tests/baselines/reference/identityForSignaturesWithTypeParametersAndAny.errors.txt
index 6023928022699..40a9651acec7d 100644
--- a/tests/baselines/reference/identityForSignaturesWithTypeParametersAndAny.errors.txt
+++ b/tests/baselines/reference/identityForSignaturesWithTypeParametersAndAny.errors.txt
@@ -1,12 +1,15 @@
+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'.
     
     var g: <T, U>(x: T, y: U) => T;
     var g: <T>(x: any, y: any) => any;
diff --git a/tests/baselines/reference/promiseIdentity.errors.txt b/tests/baselines/reference/promiseIdentity.errors.txt
new file mode 100644
index 0000000000000..96bdc0d5196ab
--- /dev/null
+++ b/tests/baselines/reference/promiseIdentity.errors.txt
@@ -0,0 +1,27 @@
+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>'.
\ No newline at end of file
diff --git a/tests/baselines/reference/promiseIdentityWithAny.errors.txt b/tests/baselines/reference/promiseIdentityWithAny.errors.txt
new file mode 100644
index 0000000000000..ebbcc3febf4dc
--- /dev/null
+++ b/tests/baselines/reference/promiseIdentityWithAny.errors.txt
@@ -0,0 +1,16 @@
+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>'.
\ No newline at end of file
diff --git a/tests/baselines/reference/unionOfClassCalls.js b/tests/baselines/reference/unionOfClassCalls.js
new file mode 100644
index 0000000000000..6e23f70d6c45d
--- /dev/null
+++ b/tests/baselines/reference/unionOfClassCalls.js
@@ -0,0 +1,21 @@
+//// [unionOfClassCalls.ts]
+declare class Test<T> {
+    obj: T;
+    get<K extends keyof T>(k: K): T[K];
+}
+
+interface A { t: "A" }
+interface B { t: "B" }
+
+declare const tmp: Test<A> | Test<B>;
+
+switch (tmp.get('t')) {
+    case 'A': break;
+    case 'B': break;
+}
+
+//// [unionOfClassCalls.js]
+switch (tmp.get('t')) {
+    case 'A': break;
+    case 'B': break;
+}
diff --git a/tests/baselines/reference/unionOfClassCalls.symbols b/tests/baselines/reference/unionOfClassCalls.symbols
new file mode 100644
index 0000000000000..8be25548d8ee2
--- /dev/null
+++ b/tests/baselines/reference/unionOfClassCalls.symbols
@@ -0,0 +1,42 @@
+=== tests/cases/compiler/unionOfClassCalls.ts ===
+declare class Test<T> {
+>Test : Symbol(Test, Decl(unionOfClassCalls.ts, 0, 0))
+>T : Symbol(T, Decl(unionOfClassCalls.ts, 0, 19))
+
+    obj: T;
+>obj : Symbol(Test.obj, Decl(unionOfClassCalls.ts, 0, 23))
+>T : Symbol(T, Decl(unionOfClassCalls.ts, 0, 19))
+
+    get<K extends keyof T>(k: K): T[K];
+>get : Symbol(Test.get, Decl(unionOfClassCalls.ts, 1, 11))
+>K : Symbol(K, Decl(unionOfClassCalls.ts, 2, 8))
+>T : Symbol(T, Decl(unionOfClassCalls.ts, 0, 19))
+>k : Symbol(k, Decl(unionOfClassCalls.ts, 2, 27))
+>K : Symbol(K, Decl(unionOfClassCalls.ts, 2, 8))
+>T : Symbol(T, Decl(unionOfClassCalls.ts, 0, 19))
+>K : Symbol(K, Decl(unionOfClassCalls.ts, 2, 8))
+}
+
+interface A { t: "A" }
+>A : Symbol(A, Decl(unionOfClassCalls.ts, 3, 1))
+>t : Symbol(A.t, Decl(unionOfClassCalls.ts, 5, 13))
+
+interface B { t: "B" }
+>B : Symbol(B, Decl(unionOfClassCalls.ts, 5, 22))
+>t : Symbol(B.t, Decl(unionOfClassCalls.ts, 6, 13))
+
+declare const tmp: Test<A> | Test<B>;
+>tmp : Symbol(tmp, Decl(unionOfClassCalls.ts, 8, 13))
+>Test : Symbol(Test, Decl(unionOfClassCalls.ts, 0, 0))
+>A : Symbol(A, Decl(unionOfClassCalls.ts, 3, 1))
+>Test : Symbol(Test, Decl(unionOfClassCalls.ts, 0, 0))
+>B : Symbol(B, Decl(unionOfClassCalls.ts, 5, 22))
+
+switch (tmp.get('t')) {
+>tmp.get : Symbol(Test.get, Decl(unionOfClassCalls.ts, 1, 11), Decl(unionOfClassCalls.ts, 1, 11))
+>tmp : Symbol(tmp, Decl(unionOfClassCalls.ts, 8, 13))
+>get : Symbol(Test.get, Decl(unionOfClassCalls.ts, 1, 11), Decl(unionOfClassCalls.ts, 1, 11))
+
+    case 'A': break;
+    case 'B': break;
+}
diff --git a/tests/baselines/reference/unionOfClassCalls.types b/tests/baselines/reference/unionOfClassCalls.types
new file mode 100644
index 0000000000000..daea1f6f733b5
--- /dev/null
+++ b/tests/baselines/reference/unionOfClassCalls.types
@@ -0,0 +1,34 @@
+=== tests/cases/compiler/unionOfClassCalls.ts ===
+declare class Test<T> {
+>Test : Test<T>
+
+    obj: T;
+>obj : T
+
+    get<K extends keyof T>(k: K): T[K];
+>get : <K extends keyof T>(k: K) => T[K]
+>k : K
+}
+
+interface A { t: "A" }
+>t : "A"
+
+interface B { t: "B" }
+>t : "B"
+
+declare const tmp: Test<A> | Test<B>;
+>tmp : Test<A> | Test<B>
+
+switch (tmp.get('t')) {
+>tmp.get('t') : "A" | "B"
+>tmp.get : (<K extends "t">(k: K) => A[K]) | (<K extends "t">(k: K) => B[K])
+>tmp : Test<A> | Test<B>
+>get : (<K extends "t">(k: K) => A[K]) | (<K extends "t">(k: K) => B[K])
+>'t' : "t"
+
+    case 'A': break;
+>'A' : "A"
+
+    case 'B': break;
+>'B' : "B"
+}
diff --git a/tests/cases/compiler/unionOfClassCalls.ts b/tests/cases/compiler/unionOfClassCalls.ts
new file mode 100644
index 0000000000000..28ea00fac1821
--- /dev/null
+++ b/tests/cases/compiler/unionOfClassCalls.ts
@@ -0,0 +1,14 @@
+declare class Test<T> {
+    obj: T;
+    get<K extends keyof T>(k: K): T[K];
+}
+
+interface A { t: "A" }
+interface B { t: "B" }
+
+declare const tmp: Test<A> | Test<B>;
+
+switch (tmp.get('t')) {
+    case 'A': break;
+    case 'B': break;
+}
\ No newline at end of file

From d36dfcb278caedc708bc6cc13973f1bbaf90d0bd Mon Sep 17 00:00:00 2001
From: Wesley Wigham <wewigham@microsoft.com>
Date: Thu, 18 Apr 2019 14:33:43 -0700
Subject: [PATCH 2/5] Update text in fourslash test

---
 tests/cases/fourslash/completionEntryForUnionMethod.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/cases/fourslash/completionEntryForUnionMethod.ts b/tests/cases/fourslash/completionEntryForUnionMethod.ts
index 80fa6d5dd6e6c..b309d453f16e2 100644
--- a/tests/cases/fourslash/completionEntryForUnionMethod.ts
+++ b/tests/cases/fourslash/completionEntryForUnionMethod.ts
@@ -3,7 +3,7 @@
 ////var y: Array<string>|Array<number>;
 ////y.map/**/(
 
-const text = "(property) Array<T>.map: (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[])";
+const text = "(method) Array<T>.map<unknown>(callbackfn: ((value: string, index: number, array: string[]) => unknown) & ((value: number, index: number, array: number[]) => unknown), thisArg: any): unknown[]";
 const documentation = "Calls a defined callback function on each element of an array, and returns an array that contains the results.";
 
 verify.quickInfoAt("", text, documentation);

From 0580ccaf8591fac3ee91602ba8aef7fd8f6065db Mon Sep 17 00:00:00 2001
From: Wesley Wigham <wewigham@microsoft.com>
Date: Thu, 18 Apr 2019 14:38:38 -0700
Subject: [PATCH 3/5] Add whitespace to fix lint, remove duplicate impl

---
 src/compiler/checker.ts | 7 +------
 src/compiler/types.ts   | 2 +-
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index ee6617f3a1d03..bb16748779d39 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -8566,15 +8566,10 @@ namespace ts {
 
         function getConstrainedSignature(signature: Signature): Signature {
             return signature.typeParameters ?
-                signature.constrainedSignatureCache || (signature.constrainedSignatureCache = createConstrainedSignature(signature)) :
+                signature.constrainedSignatureCache || (signature.constrainedSignatureCache = getBaseSignature(signature)) :
                 signature;
         }
 
-        function createConstrainedSignature(signature: Signature) {
-            // Create an instantiation of the signature where all type arguments are their base constraint
-            return instantiateSignature(signature, t => contains(signature.typeParameters, t) ? getBaseConstraintOfType(t) || unknownType : t, /*eraseTypeParameters*/ true);
-        }
-
         function getCanonicalSignature(signature: Signature): Signature {
             return signature.typeParameters ?
                 signature.canonicalSignatureCache || (signature.canonicalSignatureCache = createCanonicalSignature(signature)) :
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 6e972b18f10cc..6fa5ba96c1007 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -4383,7 +4383,7 @@ namespace ts {
         /* @internal */
         erasedSignatureCache?: Signature;   // Erased version of signature (to any) (deferred)
         /* @internal */
-        constrainedSignatureCache?: Signature;// Erased version of signature (to constraints) (deferred)
+        constrainedSignatureCache?: Signature; // Erased version of signature (to constraints) (deferred)
         /* @internal */
         canonicalSignatureCache?: Signature; // Canonical version of signature (deferred)
         /* @internal */

From 01dea4beaff142515d42a7b33ccda9918baf5d57 Mon Sep 17 00:00:00 2001
From: Wesley Wigham <wewigham@microsoft.com>
Date: Thu, 18 Apr 2019 14:45:39 -0700
Subject: [PATCH 4/5] Consolidate names

---
 src/compiler/checker.ts | 10 +++++-----
 src/compiler/types.ts   |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index bb16748779d39..c08b4e275a076 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -8564,9 +8564,9 @@ namespace ts {
             return instantiateSignature(signature, createTypeEraser(signature.typeParameters!), /*eraseTypeParameters*/ true);
         }
 
-        function getConstrainedSignature(signature: Signature): Signature {
+        function getBaseSignature(signature: Signature): Signature {
             return signature.typeParameters ?
-                signature.constrainedSignatureCache || (signature.constrainedSignatureCache = getBaseSignature(signature)) :
+                signature.baseSignatureCache || (signature.baseSignatureCache = createBaseSignature(signature)) :
                 signature;
         }
 
@@ -8589,7 +8589,7 @@ namespace ts {
                 isInJSFile(signature.declaration));
         }
 
-        function getBaseSignature(signature: Signature) {
+        function createBaseSignature(signature: Signature) {
             const typeParameters = signature.typeParameters;
             if (typeParameters) {
                 const typeEraser = createTypeEraser(typeParameters);
@@ -13922,8 +13922,8 @@ namespace ts {
             }
             // 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 = getConstrainedSignature(source);
-            target = getConstrainedSignature(target);
+            source = getBaseSignature(source);
+            target = getBaseSignature(target);
             let result = Ternary.True;
 
             if (!ignoreThisTypes) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 6fa5ba96c1007..1f62a96cf8cbe 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -4383,7 +4383,7 @@ namespace ts {
         /* @internal */
         erasedSignatureCache?: Signature;   // Erased version of signature (to any) (deferred)
         /* @internal */
-        constrainedSignatureCache?: Signature; // Erased version of signature (to constraints) (deferred)
+        baseSignatureCache?: Signature; // Erased version of signature (to constraints) (deferred)
         /* @internal */
         canonicalSignatureCache?: Signature; // Canonical version of signature (deferred)
         /* @internal */

From e14c58e0874d4226aeaf28e73bc159db54752b0e Mon Sep 17 00:00:00 2001
From: Wesley Wigham <wwigham@gmail.com>
Date: Wed, 4 Mar 2020 04:59:11 -0800
Subject: [PATCH 5/5] Remove comparisons of type parameter defaults, add more
 test cases

---
 src/compiler/checker.ts                       |  10 +-
 .../reference/unionOfClassCalls.errors.txt    |  85 ++++++++
 .../baselines/reference/unionOfClassCalls.js  | 102 ++++++++-
 .../reference/unionOfClassCalls.symbols       | 205 ++++++++++++++++--
 .../reference/unionOfClassCalls.types         | 191 ++++++++++++++++
 tests/cases/compiler/unionOfClassCalls.ts     |  65 +++++-
 6 files changed, 634 insertions(+), 24 deletions(-)
 create mode 100644 tests/baselines/reference/unionOfClassCalls.errors.txt

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 7bddbbd8d7cef..6855bd974df52 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -9301,12 +9301,17 @@ namespace ts {
                 return false;
             }
 
+            const mapper = createTypeMapper(targetParams, sourceParams);
             for (let i = 0; i < sourceParams.length; i++) {
                 const source = sourceParams[i];
                 const target = targetParams[i];
                 if (source === target) continue;
-                if (!isTypeIdenticalTo(getConstraintFromTypeParameter(source) || unknownType, getConstraintFromTypeParameter(target) || unknownType)) return false;
-                if (!isTypeIdenticalTo(getDefaultFromTypeParameter(source) || unknownType, getDefaultFromTypeParameter(target) || unknownType)) return false;
+                // We instantiate the target type parameter constraints into the source types so we can recognize `<T, U extends T>` as the same as `<A, B extends A>`
+                if (!isTypeIdenticalTo(getConstraintFromTypeParameter(source) || unknownType, instantiateType(getConstraintFromTypeParameter(target) || unknownType, mapper))) return false;
+                // We don't compare defaults - we just use the type parameter defaults from the first signature that seems to match.
+                // It might make sense to combine these defaults in the future, but doing so intelligently requires knowing
+                // if the parameter is used covariantly or contravariantly (so we intersect if it's used like a parameter or union if used like a return type)
+                // and, since it's just an inference _default_, just picking one arbitrarily works OK.
             }
 
             return true;
@@ -9374,6 +9379,7 @@ namespace ts {
             let paramMapper: TypeMapper | undefined;
             if (left.typeParameters && right.typeParameters) {
                 paramMapper = createTypeMapper(right.typeParameters, left.typeParameters);
+                // We just use the type parameter defaults from the first signature
             }
             const declaration = left.declaration;
             const params = combineUnionParameters(left, right, paramMapper);
diff --git a/tests/baselines/reference/unionOfClassCalls.errors.txt b/tests/baselines/reference/unionOfClassCalls.errors.txt
new file mode 100644
index 0000000000000..386d34414bbf0
--- /dev/null
+++ b/tests/baselines/reference/unionOfClassCalls.errors.txt
@@ -0,0 +1,85 @@
+tests/cases/compiler/unionOfClassCalls.ts(28,5): error TS2349: This expression is not callable.
+  Each member of the union type '{ (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; } | { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }' has signatures, but none of those signatures are compatible with each other.
+
+
+==== tests/cases/compiler/unionOfClassCalls.ts (1 errors) ====
+    // from https://github.com/microsoft/TypeScript/issues/30717
+    declare class Test<T> {
+        obj: T;
+        get<K extends keyof T>(k: K): T[K];
+    }
+    
+    interface A { t: "A" }
+    interface B { t: "B" }
+    
+    declare const tmp: Test<A> | Test<B>;
+    
+    switch (tmp.get('t')) {
+        case 'A': break;
+        case 'B': break;
+    }
+    
+    // from https://github.com/microsoft/TypeScript/issues/36390
+    
+    const arr: number[] | string[] = [];  // Works with Array<number | string>
+    const arr1: number[]  = [];
+    const arr2:  string[] = [];
+    
+    arr.map((a: number | string, index: number) => { 
+        return index
+    })
+    
+    // This case still doesn't work because `reduce` has multiple overloads :(
+    arr.reduce((acc: Array<string>, a: number | string, index: number) => { 
+        ~~~~~~
+!!! error TS2349: This expression is not callable.
+!!! error TS2349:   Each member of the union type '{ (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; } | { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }' has signatures, but none of those signatures are compatible with each other.
+        return []
+    }, [])
+    
+    arr.forEach((a: number | string, index: number) => { 
+        return index
+    })
+    
+    arr1.map((a: number, index: number) => { 
+        return index
+    })
+    
+    arr1.reduce((acc: number[], a: number, index: number) => { 
+        return [a]
+    }, [])
+    
+    arr1.forEach((a: number, index: number) => { 
+        return index
+    })
+    arr2.map((a:  string, index: number) => { 
+        return index
+    })
+    
+    arr2.reduce((acc: string[], a: string, index: number) => { 
+        return []
+    }, [])
+    
+    arr2.forEach((a: string, index: number) => { 
+        return index
+    })
+    
+    // from https://github.com/microsoft/TypeScript/issues/36307
+    
+    declare class Foo {
+        doThing(): Promise<this>
+    }
+    
+    declare class Bar extends Foo {
+        bar: number;
+    }
+    declare class Baz extends Foo {
+        baz: number;
+    }
+    
+    declare var a: Bar | Baz;
+    // note, you must annotate `result` for now
+    a.doThing().then((result: Bar | Baz) => {
+    	// whatever
+    });
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/unionOfClassCalls.js b/tests/baselines/reference/unionOfClassCalls.js
index 6e23f70d6c45d..706af1b83990b 100644
--- a/tests/baselines/reference/unionOfClassCalls.js
+++ b/tests/baselines/reference/unionOfClassCalls.js
@@ -1,4 +1,5 @@
 //// [unionOfClassCalls.ts]
+// from https://github.com/microsoft/TypeScript/issues/30717
 declare class Test<T> {
     obj: T;
     get<K extends keyof T>(k: K): T[K];
@@ -12,10 +13,109 @@ declare const tmp: Test<A> | Test<B>;
 switch (tmp.get('t')) {
     case 'A': break;
     case 'B': break;
-}
+}
+
+// from https://github.com/microsoft/TypeScript/issues/36390
+
+const arr: number[] | string[] = [];  // Works with Array<number | string>
+const arr1: number[]  = [];
+const arr2:  string[] = [];
+
+arr.map((a: number | string, index: number) => { 
+    return index
+})
+
+// This case still doesn't work because `reduce` has multiple overloads :(
+arr.reduce((acc: Array<string>, a: number | string, index: number) => { 
+    return []
+}, [])
+
+arr.forEach((a: number | string, index: number) => { 
+    return index
+})
+
+arr1.map((a: number, index: number) => { 
+    return index
+})
+
+arr1.reduce((acc: number[], a: number, index: number) => { 
+    return [a]
+}, [])
+
+arr1.forEach((a: number, index: number) => { 
+    return index
+})
+arr2.map((a:  string, index: number) => { 
+    return index
+})
+
+arr2.reduce((acc: string[], a: string, index: number) => { 
+    return []
+}, [])
+
+arr2.forEach((a: string, index: number) => { 
+    return index
+})
+
+// from https://github.com/microsoft/TypeScript/issues/36307
+
+declare class Foo {
+    doThing(): Promise<this>
+}
+
+declare class Bar extends Foo {
+    bar: number;
+}
+declare class Baz extends Foo {
+    baz: number;
+}
+
+declare var a: Bar | Baz;
+// note, you must annotate `result` for now
+a.doThing().then((result: Bar | Baz) => {
+	// whatever
+});
+
 
 //// [unionOfClassCalls.js]
+"use strict";
 switch (tmp.get('t')) {
     case 'A': break;
     case 'B': break;
 }
+// from https://github.com/microsoft/TypeScript/issues/36390
+var arr = []; // Works with Array<number | string>
+var arr1 = [];
+var arr2 = [];
+arr.map(function (a, index) {
+    return index;
+});
+// This case still doesn't work because `reduce` has multiple overloads :(
+arr.reduce(function (acc, a, index) {
+    return [];
+}, []);
+arr.forEach(function (a, index) {
+    return index;
+});
+arr1.map(function (a, index) {
+    return index;
+});
+arr1.reduce(function (acc, a, index) {
+    return [a];
+}, []);
+arr1.forEach(function (a, index) {
+    return index;
+});
+arr2.map(function (a, index) {
+    return index;
+});
+arr2.reduce(function (acc, a, index) {
+    return [];
+}, []);
+arr2.forEach(function (a, index) {
+    return index;
+});
+// note, you must annotate `result` for now
+a.doThing().then(function (result) {
+    // whatever
+});
diff --git a/tests/baselines/reference/unionOfClassCalls.symbols b/tests/baselines/reference/unionOfClassCalls.symbols
index 8be25548d8ee2..03155a66c5a10 100644
--- a/tests/baselines/reference/unionOfClassCalls.symbols
+++ b/tests/baselines/reference/unionOfClassCalls.symbols
@@ -1,42 +1,207 @@
 === tests/cases/compiler/unionOfClassCalls.ts ===
+// from https://github.com/microsoft/TypeScript/issues/30717
 declare class Test<T> {
 >Test : Symbol(Test, Decl(unionOfClassCalls.ts, 0, 0))
->T : Symbol(T, Decl(unionOfClassCalls.ts, 0, 19))
+>T : Symbol(T, Decl(unionOfClassCalls.ts, 1, 19))
 
     obj: T;
->obj : Symbol(Test.obj, Decl(unionOfClassCalls.ts, 0, 23))
->T : Symbol(T, Decl(unionOfClassCalls.ts, 0, 19))
+>obj : Symbol(Test.obj, Decl(unionOfClassCalls.ts, 1, 23))
+>T : Symbol(T, Decl(unionOfClassCalls.ts, 1, 19))
 
     get<K extends keyof T>(k: K): T[K];
->get : Symbol(Test.get, Decl(unionOfClassCalls.ts, 1, 11))
->K : Symbol(K, Decl(unionOfClassCalls.ts, 2, 8))
->T : Symbol(T, Decl(unionOfClassCalls.ts, 0, 19))
->k : Symbol(k, Decl(unionOfClassCalls.ts, 2, 27))
->K : Symbol(K, Decl(unionOfClassCalls.ts, 2, 8))
->T : Symbol(T, Decl(unionOfClassCalls.ts, 0, 19))
->K : Symbol(K, Decl(unionOfClassCalls.ts, 2, 8))
+>get : Symbol(Test.get, Decl(unionOfClassCalls.ts, 2, 11))
+>K : Symbol(K, Decl(unionOfClassCalls.ts, 3, 8))
+>T : Symbol(T, Decl(unionOfClassCalls.ts, 1, 19))
+>k : Symbol(k, Decl(unionOfClassCalls.ts, 3, 27))
+>K : Symbol(K, Decl(unionOfClassCalls.ts, 3, 8))
+>T : Symbol(T, Decl(unionOfClassCalls.ts, 1, 19))
+>K : Symbol(K, Decl(unionOfClassCalls.ts, 3, 8))
 }
 
 interface A { t: "A" }
->A : Symbol(A, Decl(unionOfClassCalls.ts, 3, 1))
->t : Symbol(A.t, Decl(unionOfClassCalls.ts, 5, 13))
+>A : Symbol(A, Decl(unionOfClassCalls.ts, 4, 1))
+>t : Symbol(A.t, Decl(unionOfClassCalls.ts, 6, 13))
 
 interface B { t: "B" }
->B : Symbol(B, Decl(unionOfClassCalls.ts, 5, 22))
->t : Symbol(B.t, Decl(unionOfClassCalls.ts, 6, 13))
+>B : Symbol(B, Decl(unionOfClassCalls.ts, 6, 22))
+>t : Symbol(B.t, Decl(unionOfClassCalls.ts, 7, 13))
 
 declare const tmp: Test<A> | Test<B>;
->tmp : Symbol(tmp, Decl(unionOfClassCalls.ts, 8, 13))
+>tmp : Symbol(tmp, Decl(unionOfClassCalls.ts, 9, 13))
 >Test : Symbol(Test, Decl(unionOfClassCalls.ts, 0, 0))
->A : Symbol(A, Decl(unionOfClassCalls.ts, 3, 1))
+>A : Symbol(A, Decl(unionOfClassCalls.ts, 4, 1))
 >Test : Symbol(Test, Decl(unionOfClassCalls.ts, 0, 0))
->B : Symbol(B, Decl(unionOfClassCalls.ts, 5, 22))
+>B : Symbol(B, Decl(unionOfClassCalls.ts, 6, 22))
 
 switch (tmp.get('t')) {
->tmp.get : Symbol(Test.get, Decl(unionOfClassCalls.ts, 1, 11), Decl(unionOfClassCalls.ts, 1, 11))
->tmp : Symbol(tmp, Decl(unionOfClassCalls.ts, 8, 13))
->get : Symbol(Test.get, Decl(unionOfClassCalls.ts, 1, 11), Decl(unionOfClassCalls.ts, 1, 11))
+>tmp.get : Symbol(Test.get, Decl(unionOfClassCalls.ts, 2, 11), Decl(unionOfClassCalls.ts, 2, 11))
+>tmp : Symbol(tmp, Decl(unionOfClassCalls.ts, 9, 13))
+>get : Symbol(Test.get, Decl(unionOfClassCalls.ts, 2, 11), Decl(unionOfClassCalls.ts, 2, 11))
 
     case 'A': break;
     case 'B': break;
 }
+
+// from https://github.com/microsoft/TypeScript/issues/36390
+
+const arr: number[] | string[] = [];  // Works with Array<number | string>
+>arr : Symbol(arr, Decl(unionOfClassCalls.ts, 18, 5))
+
+const arr1: number[]  = [];
+>arr1 : Symbol(arr1, Decl(unionOfClassCalls.ts, 19, 5))
+
+const arr2:  string[] = [];
+>arr2 : Symbol(arr2, Decl(unionOfClassCalls.ts, 20, 5))
+
+arr.map((a: number | string, index: number) => { 
+>arr.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>arr : Symbol(arr, Decl(unionOfClassCalls.ts, 18, 5))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 22, 9))
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 22, 28))
+
+    return index
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 22, 28))
+
+})
+
+// This case still doesn't work because `reduce` has multiple overloads :(
+arr.reduce((acc: Array<string>, a: number | string, index: number) => { 
+>arr.reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --) ... and 1 more)
+>arr : Symbol(arr, Decl(unionOfClassCalls.ts, 18, 5))
+>reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --) ... and 1 more)
+>acc : Symbol(acc, Decl(unionOfClassCalls.ts, 27, 12))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 27, 31))
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 27, 51))
+
+    return []
+}, [])
+
+arr.forEach((a: number | string, index: number) => { 
+>arr.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>arr : Symbol(arr, Decl(unionOfClassCalls.ts, 18, 5))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 31, 13))
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 31, 32))
+
+    return index
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 31, 32))
+
+})
+
+arr1.map((a: number, index: number) => { 
+>arr1.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
+>arr1 : Symbol(arr1, Decl(unionOfClassCalls.ts, 19, 5))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 35, 10))
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 35, 20))
+
+    return index
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 35, 20))
+
+})
+
+arr1.reduce((acc: number[], a: number, index: number) => { 
+>arr1.reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>arr1 : Symbol(arr1, Decl(unionOfClassCalls.ts, 19, 5))
+>reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>acc : Symbol(acc, Decl(unionOfClassCalls.ts, 39, 13))
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 39, 27))
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 39, 38))
+
+    return [a]
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 39, 27))
+
+}, [])
+
+arr1.forEach((a: number, index: number) => { 
+>arr1.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
+>arr1 : Symbol(arr1, Decl(unionOfClassCalls.ts, 19, 5))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 43, 14))
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 43, 24))
+
+    return index
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 43, 24))
+
+})
+arr2.map((a:  string, index: number) => { 
+>arr2.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
+>arr2 : Symbol(arr2, Decl(unionOfClassCalls.ts, 20, 5))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 46, 10))
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 46, 21))
+
+    return index
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 46, 21))
+
+})
+
+arr2.reduce((acc: string[], a: string, index: number) => { 
+>arr2.reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>arr2 : Symbol(arr2, Decl(unionOfClassCalls.ts, 20, 5))
+>reduce : Symbol(Array.reduce, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>acc : Symbol(acc, Decl(unionOfClassCalls.ts, 50, 13))
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 50, 27))
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 50, 38))
+
+    return []
+}, [])
+
+arr2.forEach((a: string, index: number) => { 
+>arr2.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
+>arr2 : Symbol(arr2, Decl(unionOfClassCalls.ts, 20, 5))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 54, 14))
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 54, 24))
+
+    return index
+>index : Symbol(index, Decl(unionOfClassCalls.ts, 54, 24))
+
+})
+
+// from https://github.com/microsoft/TypeScript/issues/36307
+
+declare class Foo {
+>Foo : Symbol(Foo, Decl(unionOfClassCalls.ts, 56, 2))
+
+    doThing(): Promise<this>
+>doThing : Symbol(Foo.doThing, Decl(unionOfClassCalls.ts, 60, 19))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --))
+}
+
+declare class Bar extends Foo {
+>Bar : Symbol(Bar, Decl(unionOfClassCalls.ts, 62, 1))
+>Foo : Symbol(Foo, Decl(unionOfClassCalls.ts, 56, 2))
+
+    bar: number;
+>bar : Symbol(Bar.bar, Decl(unionOfClassCalls.ts, 64, 31))
+}
+declare class Baz extends Foo {
+>Baz : Symbol(Baz, Decl(unionOfClassCalls.ts, 66, 1))
+>Foo : Symbol(Foo, Decl(unionOfClassCalls.ts, 56, 2))
+
+    baz: number;
+>baz : Symbol(Baz.baz, Decl(unionOfClassCalls.ts, 67, 31))
+}
+
+declare var a: Bar | Baz;
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 71, 11))
+>Bar : Symbol(Bar, Decl(unionOfClassCalls.ts, 62, 1))
+>Baz : Symbol(Baz, Decl(unionOfClassCalls.ts, 66, 1))
+
+// note, you must annotate `result` for now
+a.doThing().then((result: Bar | Baz) => {
+>a.doThing().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>a.doThing : Symbol(Foo.doThing, Decl(unionOfClassCalls.ts, 60, 19), Decl(unionOfClassCalls.ts, 60, 19))
+>a : Symbol(a, Decl(unionOfClassCalls.ts, 71, 11))
+>doThing : Symbol(Foo.doThing, Decl(unionOfClassCalls.ts, 60, 19), Decl(unionOfClassCalls.ts, 60, 19))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>result : Symbol(result, Decl(unionOfClassCalls.ts, 73, 18))
+>Bar : Symbol(Bar, Decl(unionOfClassCalls.ts, 62, 1))
+>Baz : Symbol(Baz, Decl(unionOfClassCalls.ts, 66, 1))
+
+	// whatever
+});
+
diff --git a/tests/baselines/reference/unionOfClassCalls.types b/tests/baselines/reference/unionOfClassCalls.types
index daea1f6f733b5..bcae9d15d6801 100644
--- a/tests/baselines/reference/unionOfClassCalls.types
+++ b/tests/baselines/reference/unionOfClassCalls.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/unionOfClassCalls.ts ===
+// from https://github.com/microsoft/TypeScript/issues/30717
 declare class Test<T> {
 >Test : Test<T>
 
@@ -32,3 +33,193 @@ switch (tmp.get('t')) {
     case 'B': break;
 >'B' : "B"
 }
+
+// from https://github.com/microsoft/TypeScript/issues/36390
+
+const arr: number[] | string[] = [];  // Works with Array<number | string>
+>arr : number[] | string[]
+>[] : never[]
+
+const arr1: number[]  = [];
+>arr1 : number[]
+>[] : never[]
+
+const arr2:  string[] = [];
+>arr2 : string[]
+>[] : never[]
+
+arr.map((a: number | string, index: number) => { 
+>arr.map((a: number | string, index: number) => {     return index}) : number[]
+>arr.map : (<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[])
+>arr : number[] | string[]
+>map : (<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[])
+>(a: number | string, index: number) => {     return index} : (a: string | number, index: number) => number
+>a : string | number
+>index : number
+
+    return index
+>index : number
+
+})
+
+// This case still doesn't work because `reduce` has multiple overloads :(
+arr.reduce((acc: Array<string>, a: number | string, index: number) => { 
+>arr.reduce((acc: Array<string>, a: number | string, index: number) => {     return []}, []) : any
+>arr.reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; } | { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
+>arr : number[] | string[]
+>reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; } | { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
+>(acc: Array<string>, a: number | string, index: number) => {     return []} : (acc: string[], a: string | number, index: number) => never[]
+>acc : string[]
+>a : string | number
+>index : number
+
+    return []
+>[] : never[]
+
+}, [])
+>[] : never[]
+
+arr.forEach((a: number | string, index: number) => { 
+>arr.forEach((a: number | string, index: number) => {     return index}) : void
+>arr.forEach : ((callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void) | ((callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void)
+>arr : number[] | string[]
+>forEach : ((callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void) | ((callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void)
+>(a: number | string, index: number) => {     return index} : (a: string | number, index: number) => number
+>a : string | number
+>index : number
+
+    return index
+>index : number
+
+})
+
+arr1.map((a: number, index: number) => { 
+>arr1.map((a: number, index: number) => {     return index}) : number[]
+>arr1.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>arr1 : number[]
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>(a: number, index: number) => {     return index} : (a: number, index: number) => number
+>a : number
+>index : number
+
+    return index
+>index : number
+
+})
+
+arr1.reduce((acc: number[], a: number, index: number) => { 
+>arr1.reduce((acc: number[], a: number, index: number) => {     return [a]}, []) : number[]
+>arr1.reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>arr1 : number[]
+>reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>(acc: number[], a: number, index: number) => {     return [a]} : (acc: number[], a: number, index: number) => number[]
+>acc : number[]
+>a : number
+>index : number
+
+    return [a]
+>[a] : number[]
+>a : number
+
+}, [])
+>[] : never[]
+
+arr1.forEach((a: number, index: number) => { 
+>arr1.forEach((a: number, index: number) => {     return index}) : void
+>arr1.forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
+>arr1 : number[]
+>forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
+>(a: number, index: number) => {     return index} : (a: number, index: number) => number
+>a : number
+>index : number
+
+    return index
+>index : number
+
+})
+arr2.map((a:  string, index: number) => { 
+>arr2.map((a:  string, index: number) => {     return index}) : number[]
+>arr2.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>arr2 : string[]
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>(a:  string, index: number) => {     return index} : (a: string, index: number) => number
+>a : string
+>index : number
+
+    return index
+>index : number
+
+})
+
+arr2.reduce((acc: string[], a: string, index: number) => { 
+>arr2.reduce((acc: string[], a: string, index: number) => {     return []}, []) : never[]
+>arr2.reduce : { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
+>arr2 : string[]
+>reduce : { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
+>(acc: string[], a: string, index: number) => {     return []} : (acc: string[], a: string, index: number) => never[]
+>acc : string[]
+>a : string
+>index : number
+
+    return []
+>[] : never[]
+
+}, [])
+>[] : never[]
+
+arr2.forEach((a: string, index: number) => { 
+>arr2.forEach((a: string, index: number) => {     return index}) : void
+>arr2.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>arr2 : string[]
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>(a: string, index: number) => {     return index} : (a: string, index: number) => number
+>a : string
+>index : number
+
+    return index
+>index : number
+
+})
+
+// from https://github.com/microsoft/TypeScript/issues/36307
+
+declare class Foo {
+>Foo : Foo
+
+    doThing(): Promise<this>
+>doThing : () => Promise<this>
+}
+
+declare class Bar extends Foo {
+>Bar : Bar
+>Foo : Foo
+
+    bar: number;
+>bar : number
+}
+declare class Baz extends Foo {
+>Baz : Baz
+>Foo : Foo
+
+    baz: number;
+>baz : number
+}
+
+declare var a: Bar | Baz;
+>a : Bar | Baz
+
+// note, you must annotate `result` for now
+a.doThing().then((result: Bar | Baz) => {
+>a.doThing().then((result: Bar | Baz) => {	// whatever}) : Promise<void>
+>a.doThing().then : (<TResult1 = Bar, TResult2 = never>(onfulfilled?: ((value: Bar) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>) | (<TResult1 = Baz, TResult2 = never>(onfulfilled?: ((value: Baz) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>)
+>a.doThing() : Promise<Bar> | Promise<Baz>
+>a.doThing : (() => Promise<Bar>) | (() => Promise<Baz>)
+>a : Bar | Baz
+>doThing : (() => Promise<Bar>) | (() => Promise<Baz>)
+>then : (<TResult1 = Bar, TResult2 = never>(onfulfilled?: ((value: Bar) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>) | (<TResult1 = Baz, TResult2 = never>(onfulfilled?: ((value: Baz) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>)
+>(result: Bar | Baz) => {	// whatever} : (result: Bar | Baz) => void
+>result : Bar | Baz
+
+	// whatever
+});
+
diff --git a/tests/cases/compiler/unionOfClassCalls.ts b/tests/cases/compiler/unionOfClassCalls.ts
index 28ea00fac1821..509fbb4b46a6c 100644
--- a/tests/cases/compiler/unionOfClassCalls.ts
+++ b/tests/cases/compiler/unionOfClassCalls.ts
@@ -1,3 +1,5 @@
+// @strict: true
+// from https://github.com/microsoft/TypeScript/issues/30717
 declare class Test<T> {
     obj: T;
     get<K extends keyof T>(k: K): T[K];
@@ -11,4 +13,65 @@ declare const tmp: Test<A> | Test<B>;
 switch (tmp.get('t')) {
     case 'A': break;
     case 'B': break;
-}
\ No newline at end of file
+}
+
+// from https://github.com/microsoft/TypeScript/issues/36390
+
+const arr: number[] | string[] = [];  // Works with Array<number | string>
+const arr1: number[]  = [];
+const arr2:  string[] = [];
+
+arr.map((a: number | string, index: number) => { 
+    return index
+})
+
+// This case still doesn't work because `reduce` has multiple overloads :(
+arr.reduce((acc: Array<string>, a: number | string, index: number) => { 
+    return []
+}, [])
+
+arr.forEach((a: number | string, index: number) => { 
+    return index
+})
+
+arr1.map((a: number, index: number) => { 
+    return index
+})
+
+arr1.reduce((acc: number[], a: number, index: number) => { 
+    return [a]
+}, [])
+
+arr1.forEach((a: number, index: number) => { 
+    return index
+})
+arr2.map((a:  string, index: number) => { 
+    return index
+})
+
+arr2.reduce((acc: string[], a: string, index: number) => { 
+    return []
+}, [])
+
+arr2.forEach((a: string, index: number) => { 
+    return index
+})
+
+// from https://github.com/microsoft/TypeScript/issues/36307
+
+declare class Foo {
+    doThing(): Promise<this>
+}
+
+declare class Bar extends Foo {
+    bar: number;
+}
+declare class Baz extends Foo {
+    baz: number;
+}
+
+declare var a: Bar | Baz;
+// note, you must annotate `result` for now
+a.doThing().then((result: Bar | Baz) => {
+	// whatever
+});