Limit scope of instantiation to only when likely needed

Author: weswigham

src/compiler/checker.ts

@@ -13026,7 +13026,7 @@ namespace ts {
 
         function getContextualTypeForObjectLiteralElement(element: ObjectLiteralElementLike, checkMode?: CheckMode) {
             const objectLiteral = <ObjectLiteralExpression>element.parent;
-            const type = getApparentTypeOfContextualType(objectLiteral, checkMode);
+            const type = getInstantiatedContextualType(objectLiteral, checkMode);
             if (type) {
                 if (!hasDynamicName(element)) {
                     // For a (non-symbol) computed property, there is no reason to look up the name
@@ -13122,6 +13122,17 @@ namespace ts {
             return type && getApparentType(type);
         }
 
+        /**
+         * This must be called when a contextual type function is attempting to dig into a type to contextually type a subexpression
+         * Otherwise, contextual typing stops when a type argument is encountered, and `any` is ued instead.
+         */
+        function getInstantiatedContextualType(node: Expression, checkMode?: CheckMode): Type {
+            if (checkMode === CheckMode.Inferential && node.contextualType && node.contextualMapper) {
+                return instantiateType(node.contextualType, node.contextualMapper);
+            }
+            return getContextualType(node, checkMode);
+        }
+
         /**
          * Woah! Do you really want to use this function?
          *
@@ -13145,12 +13156,6 @@ namespace ts {
                 return undefined;
             }
             if (node.contextualType) {
-                if (checkMode & CheckMode.Inferential) {
-                    const mapper = getContextualMapper(node);
-                    if (mapper) {
-                        return instantiateType(node.contextualType, mapper);
-                    }
-                }
                 return node.contextualType;
             }
             const parent = node.parent;
@@ -16848,7 +16853,7 @@ namespace ts {
 
             // Check if function expression is contextually typed and assign parameter types if so.
             if (!(links.flags & NodeCheckFlags.ContextChecked)) {
-                const contextualSignature = getContextualSignature(node);
+                const contextualSignature = getContextualSignature(node); // Intentionally do not pass check mode; resolve without instantiation
                 // If a type check is started at a function expression that is an argument of a function call, obtaining the
                 // contextual type may recursively get back to here during overload resolution of the call. If so, we will have
                 // already assigned contextual types.

tests/baselines/reference/functionConstraintSatisfaction.types

@@ -44,8 +44,8 @@ var r = foo(new Function());
 >Function : FunctionConstructor
 
 var r1 = foo((x) => x);
->r1 : Function
->foo((x) => x) : Function
+>r1 : (x: any) => any
+>foo((x) => x) : (x: any) => any
 >foo : <T extends Function>(x: T) => T
 >(x) => x : (x: any) => any
 >x : any
@@ -60,8 +60,8 @@ var r2 = foo((x: string[]) => x);
 >x : string[]
 
 var r3 = foo(function (x) { return x });
->r3 : Function
->foo(function (x) { return x }) : Function
+>r3 : (x: any) => any
+>foo(function (x) { return x }) : (x: any) => any
 >foo : <T extends Function>(x: T) => T
 >function (x) { return x } : (x: any) => any
 >x : any

tests/baselines/reference/inferentialTypingUsingApparentType2.types

@@ -13,7 +13,7 @@ function foo<T extends { m(p: string): number }>(x: T): T {
 }
 
 foo({ m(x) { return x.length } });
->foo({ m(x) { return x.length } }) : { m(x: string): number; }
+>foo({ m(x) { return x.length } }) : { m(p: string): number; }
 >foo : <T extends { m(p: string): number; }>(x: T) => T
 >{ m(x) { return x.length } } : { m(x: string): number; }
 >m : (x: string) => number

tests/baselines/reference/inferringAnyFunctionType5.types

@@ -13,8 +13,8 @@ function f<T extends { q: (p1: number) => number }>(p: T): T {
 }
 
 var v = f({ q: x => x });
->v : { q: (x: number) => number; }
->f({ q: x => x }) : { q: (x: number) => number; }
+>v : { q: (p1: number) => number; }
+>f({ q: x => x }) : { q: (p1: number) => number; }
 >f : <T extends { q: (p1: number) => number; }>(p: T) => T
 >{ q: x => x } : { q: (x: number) => number; }
 >q : (x: number) => number

tests/baselines/reference/promisePermutations3.errors.txt

@@ -71,7 +71,7 @@ tests/cases/compiler/promisePermutations3.ts(159,21): error TS2345: Argument of
         Types of parameters 'onfulfilled' and 'success' are incompatible.
           Types of parameters 'value' and 'value' are incompatible.
             Type 'number' is not assignable to type 'string'.
-tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: {}) => Promise<any>'.
+tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: (x: any) => any) => Promise<any>'.
   Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
     Types of property 'then' are incompatible.
       Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
@@ -352,7 +352,7 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
     var s12a = s12.then(testFunction12, testFunction12, testFunction12); // ok
     var s12b = s12.then(testFunction12P, testFunction12P, testFunction12P); // ok
                         ~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: {}) => Promise<any>'.
+!!! error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: (x: any) => any) => Promise<any>'.
 !!! error TS2345:   Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
 !!! error TS2345:       Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.