Add nested call and new expressions as potential intra expression inference sites

Author: Andarist

src/compiler/checker.ts

@@ -1652,7 +1652,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             const node = getParseTreeNode(nodeIn, isJsxAttributeLike);
             return node && getContextualTypeForJsxAttribute(node, /*contextFlags*/ undefined);
         },
-        isContextSensitive,
+        containsContextSensitive,
         getTypeOfPropertyOfContextualType,
         getFullyQualifiedName,
         getResolvedSignature: (node, candidatesOutArray, argumentCount) =>
@@ -6253,7 +6253,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function symbolValueDeclarationIsContextSensitive(symbol: Symbol): boolean {
-        return symbol && !!symbol.valueDeclaration && isExpression(symbol.valueDeclaration) && !isContextSensitive(symbol.valueDeclaration);
+        return symbol && !!symbol.valueDeclaration && isExpression(symbol.valueDeclaration) && !containsContextSensitive(symbol.valueDeclaration);
     }
 
     function toNodeBuilderFlags(flags = TypeFormatFlags.None): NodeBuilderFlags {
@@ -19165,47 +19165,56 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return createIndexInfo(info.keyType, instantiateType(info.type, mapper), info.isReadonly, info.declaration);
     }
 
-    // Returns true if the given expression contains (at any level of nesting) a function or arrow expression
-    // that is subject to contextual typing.
-    function isContextSensitive(node: Expression | MethodDeclaration | ObjectLiteralElementLike | JsxAttributeLike | JsxChild): boolean {
+    function containsContextRelatedNode(node: Expression | MethodDeclaration | ObjectLiteralElementLike | JsxAttributeLike | JsxChild, predicate: (node: Node) => boolean): boolean {
         Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
         switch (node.kind) {
             case SyntaxKind.FunctionExpression:
             case SyntaxKind.ArrowFunction:
             case SyntaxKind.MethodDeclaration:
-            case SyntaxKind.FunctionDeclaration: // Function declarations can have context when annotated with a jsdoc @type
-                return isContextSensitiveFunctionLikeDeclaration(node as FunctionExpression | ArrowFunction | MethodDeclaration);
+            case SyntaxKind.FunctionDeclaration:
+            case SyntaxKind.CallExpression:
+            case SyntaxKind.NewExpression:
+                return predicate(node);
             case SyntaxKind.ObjectLiteralExpression:
-                return some((node as ObjectLiteralExpression).properties, isContextSensitive);
+                return some((node as ObjectLiteralExpression).properties, p => containsContextRelatedNode(p, predicate));
             case SyntaxKind.ArrayLiteralExpression:
-                return some((node as ArrayLiteralExpression).elements, isContextSensitive);
+                return some((node as ArrayLiteralExpression).elements, e => containsContextRelatedNode(e, predicate));
             case SyntaxKind.ConditionalExpression:
-                return isContextSensitive((node as ConditionalExpression).whenTrue) ||
-                    isContextSensitive((node as ConditionalExpression).whenFalse);
+                return containsContextRelatedNode((node as ConditionalExpression).whenTrue, predicate) ||
+                    containsContextRelatedNode((node as ConditionalExpression).whenFalse, predicate);
             case SyntaxKind.BinaryExpression:
                 return ((node as BinaryExpression).operatorToken.kind === SyntaxKind.BarBarToken || (node as BinaryExpression).operatorToken.kind === SyntaxKind.QuestionQuestionToken) &&
-                    (isContextSensitive((node as BinaryExpression).left) || isContextSensitive((node as BinaryExpression).right));
+                    (containsContextRelatedNode((node as BinaryExpression).left, predicate) || containsContextRelatedNode((node as BinaryExpression).right, predicate));
             case SyntaxKind.PropertyAssignment:
-                return isContextSensitive((node as PropertyAssignment).initializer);
+                return containsContextRelatedNode((node as PropertyAssignment).initializer, predicate);
             case SyntaxKind.ParenthesizedExpression:
-                return isContextSensitive((node as ParenthesizedExpression).expression);
+                return containsContextRelatedNode((node as ParenthesizedExpression).expression, predicate);
             case SyntaxKind.JsxAttributes:
-                return some((node as JsxAttributes).properties, isContextSensitive) || isJsxOpeningElement(node.parent) && some(node.parent.parent.children, isContextSensitive);
+                return some((node as JsxAttributes).properties, p => containsContextRelatedNode(p, predicate)) || isJsxOpeningElement(node.parent) && some(node.parent.parent.children, c => containsContextRelatedNode(c, predicate));
             case SyntaxKind.JsxAttribute: {
-                // If there is no initializer, JSX attribute has a boolean value of true which is not context sensitive.
                 const { initializer } = node as JsxAttribute;
-                return !!initializer && isContextSensitive(initializer);
+                return !!initializer && containsContextRelatedNode(initializer, predicate);
             }
             case SyntaxKind.JsxExpression: {
                 // It is possible to that node.expression is undefined (e.g <div x={} />)
                 const { expression } = node as JsxExpression;
-                return !!expression && isContextSensitive(expression);
+                return !!expression && containsContextRelatedNode(expression, predicate);
             }
         }
 
         return false;
     }
 
+    // Returns true if the given expression contains (at any level of nesting) a function or arrow expression
+    // that is subject to contextual typing.
+    function containsContextSensitive(node: Expression | MethodDeclaration | ObjectLiteralElementLike | JsxAttributeLike | JsxChild): boolean {
+        return containsContextRelatedNode(node, isContextSensitiveFunctionOrObjectLiteralMethod);
+    }
+
+    function containsContextSensitiveOrCallOrNewExpression(node: Expression | MethodDeclaration | ObjectLiteralElementLike | JsxAttributeLike | JsxChild): boolean {
+        return containsContextRelatedNode(node, n => isContextSensitiveFunctionOrObjectLiteralMethod(n) || isCallOrNewExpression(n));
+    }
+
     function isContextSensitiveFunctionLikeDeclaration(node: FunctionLikeDeclaration): boolean {
         return hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node);
     }
@@ -19215,9 +19224,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             return false;
         }
         if (node.body.kind !== SyntaxKind.Block) {
-            return isContextSensitive(node.body);
+            return containsContextSensitive(node.body);
         }
-        return !!forEachReturnStatement(node.body as Block, (statement) => !!statement.expression && isContextSensitive(statement.expression));
+        return !!forEachReturnStatement(node.body as Block, (statement) => !!statement.expression && containsContextSensitive(statement.expression));
     }
 
     function isContextSensitiveFunctionOrObjectLiteralMethod(func: Node): func is FunctionExpression | ArrowFunction | MethodDeclaration {
@@ -29983,7 +29992,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const type = checkExpressionForMutableLocation(e, checkMode, forceTuple);
                 elementTypes.push(addOptionality(type, /*isProperty*/ true, hasOmittedExpression));
                 elementFlags.push(hasOmittedExpression ? ElementFlags.Optional : ElementFlags.Required);
-                if (inTupleContext && checkMode && checkMode & CheckMode.Inferential && !(checkMode & CheckMode.SkipContextSensitive) && isContextSensitive(e)) {
+                if (inTupleContext && checkMode && checkMode & CheckMode.Inferential && !(checkMode & CheckMode.SkipContextSensitive) && containsContextSensitiveOrCallOrNewExpression(e)) {
                     const inferenceContext = getInferenceContext(node);
                     Debug.assert(inferenceContext);  // In CheckMode.Inferential we should always have an inference context
                     addIntraExpressionInferenceSite(inferenceContext, e, type);
@@ -30208,8 +30217,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 member = prop;
                 allPropertiesTable?.set(prop.escapedName, prop);
 
-                if (contextualType && checkMode && checkMode & CheckMode.Inferential && !(checkMode & CheckMode.SkipContextSensitive) &&
-                    (memberDecl.kind === SyntaxKind.PropertyAssignment || memberDecl.kind === SyntaxKind.MethodDeclaration) && isContextSensitive(memberDecl)) {
+                if (contextualType && checkMode && checkMode & CheckMode.Inferential && (!(checkMode & CheckMode.SkipContextSensitive) &&
+                    (memberDecl.kind === SyntaxKind.PropertyAssignment || memberDecl.kind === SyntaxKind.MethodDeclaration) && containsContextSensitiveOrCallOrNewExpression(memberDecl))) {
                     const inferenceContext = getInferenceContext(node);
                     Debug.assert(inferenceContext);  // In CheckMode.Inferential we should always have an inference context
                     const inferenceNode = memberDecl.kind === SyntaxKind.PropertyAssignment ? memberDecl.initializer : memberDecl;
@@ -30465,7 +30474,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText as string);
                     }
                 }
-                if (contextualType && checkMode && checkMode & CheckMode.Inferential && !(checkMode & CheckMode.SkipContextSensitive) && isContextSensitive(attributeDecl)) {
+                if (contextualType && checkMode && checkMode & CheckMode.Inferential && !(checkMode & CheckMode.SkipContextSensitive) && containsContextSensitiveOrCallOrNewExpression(attributeDecl)) {
                     const inferenceContext = getInferenceContext(attributes);
                     Debug.assert(inferenceContext);  // In CheckMode.Inferential we should always have an inference context
                     const inferenceNode = (attributeDecl.initializer as JsxExpression).expression!;
@@ -33138,7 +33147,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         // For a decorator, no arguments are susceptible to contextual typing due to the fact
         // decorators are applied to a declaration by the emitter, and not to an expression.
         const isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
-        let argCheckMode = !isDecorator && !isSingleNonGenericCandidate && some(args, isContextSensitive) ? CheckMode.SkipContextSensitive : CheckMode.Normal;
+        let argCheckMode = !isDecorator && !isSingleNonGenericCandidate && some(args, containsContextSensitive) ? CheckMode.SkipContextSensitive : CheckMode.Normal;
         argCheckMode |= checkMode & CheckMode.IsForStringLiteralArgumentCompletions;
 
         // The following variables are captured and modified by calls to chooseOverload.
@@ -35865,7 +35874,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
 
         // The identityMapper object is used to indicate that function expressions are wildcards
-        if (checkMode && checkMode & CheckMode.SkipContextSensitive && isContextSensitive(node)) {
+        if (checkMode && checkMode & CheckMode.SkipContextSensitive && containsContextSensitive(node)) {
             // Skip parameters, return signature with return type that retains noncontextual parts so inferences can still be drawn in an early stage
             if (!getEffectiveReturnTypeNode(node) && !hasContextSensitiveParameters(node)) {
                 // Return plain anyFunctionType if there is no possibility we'll make inferences from the return type
@@ -35910,7 +35919,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 if (!signature) {
                     return;
                 }
-                if (isContextSensitive(node)) {
+                if (containsContextSensitive(node)) {
                     if (contextualSignature) {
                         const inferenceContext = getInferenceContext(node);
                         let instantiatedContextualSignature: Signature | undefined;

src/compiler/types.ts

@@ -5064,7 +5064,7 @@ export interface TypeChecker {
     /** @internal */ getContextualTypeForObjectLiteralElement(element: ObjectLiteralElementLike): Type | undefined;
     /** @internal */ getContextualTypeForArgumentAtIndex(call: CallLikeExpression, argIndex: number): Type | undefined;
     /** @internal */ getContextualTypeForJsxAttribute(attribute: JsxAttribute | JsxSpreadAttribute): Type | undefined;
-    /** @internal */ isContextSensitive(node: Expression | MethodDeclaration | ObjectLiteralElementLike | JsxAttributeLike): boolean;
+    /** @internal */ containsContextSensitive(node: Expression | MethodDeclaration | ObjectLiteralElementLike | JsxAttributeLike): boolean;
     /** @internal */ getTypeOfPropertyOfContextualType(type: Type, name: __String): Type | undefined;
 
     /**

src/services/refactors/extractSymbol.ts

@@ -1357,7 +1357,7 @@ function extractConstantInScope(
         : getUniqueName(isClassLike(scope) ? "newProperty" : "newLocal", file);
     const isJS = isInJSFile(scope);
 
-    let variableType = isJS || !checker.isContextSensitive(node)
+    let variableType = isJS || !checker.containsContextSensitive(node)
         ? undefined
         : checker.typeToTypeNode(checker.getContextualType(node)!, scope, NodeBuilderFlags.NoTruncation); // TODO: GH#18217
 

tests/baselines/reference/intraExpressionInferences.errors.txt

@@ -212,4 +212,26 @@ tests/cases/conformance/types/typeRelationships/typeInference/intraExpressionInf
         let test1: "a" = u
       }
     })
-    
+    
+    type ErrorFn = (error: unknown) => void;
+    
+    declare const genericFn: <T>(args: {
+      parser: (p: unknown, errorFn: ErrorFn) => T;
+      handler: (data: { body: T }) => unknown;
+    }) => T;
+    
+    declare const createParser: <T>(arg: T) => (p: unknown, errorFn: ErrorFn) => T;
+    
+    genericFn({
+      parser: createParser(1 as const),
+      handler: ({ body: _ }) => {},
+    });
+    
+    declare const genericFnTuple: <T>(
+      args: [
+        parser: (p: unknown, errorFn: ErrorFn) => T,
+        handler: (data: { body: T }) => unknown
+      ]
+    ) => T;
+    
+    genericFnTuple([createParser(1 as const), ({ body: _ }) => {}]);

tests/baselines/reference/intraExpressionInferences.js

@@ -197,7 +197,29 @@ branch({
     let test1: "a" = u
   }
 })
-
+
+type ErrorFn = (error: unknown) => void;
+
+declare const genericFn: <T>(args: {
+  parser: (p: unknown, errorFn: ErrorFn) => T;
+  handler: (data: { body: T }) => unknown;
+}) => T;
+
+declare const createParser: <T>(arg: T) => (p: unknown, errorFn: ErrorFn) => T;
+
+genericFn({
+  parser: createParser(1 as const),
+  handler: ({ body: _ }) => {},
+});
+
+declare const genericFnTuple: <T>(
+  args: [
+    parser: (p: unknown, errorFn: ErrorFn) => T,
+    handler: (data: { body: T }) => unknown
+  ]
+) => T;
+
+genericFnTuple([createParser(1 as const), ({ body: _ }) => {}]);
 
 //// [intraExpressionInferences.js]
 "use strict";
@@ -316,6 +338,15 @@ branch({
         var test1 = u;
     }
 });
+genericFn({
+    parser: createParser(1),
+    handler: function (_b) {
+        var _ = _b.body;
+    },
+});
+genericFnTuple([createParser(1), function (_b) {
+        var _ = _b.body;
+    }]);
 
 
 //// [intraExpressionInferences.d.ts]
@@ -383,3 +414,17 @@ declare const branch: <T, U extends T>(_: {
     then: (u: U) => void;
 }) => void;
 declare const x: "a" | "b";
+type ErrorFn = (error: unknown) => void;
+declare const genericFn: <T>(args: {
+    parser: (p: unknown, errorFn: ErrorFn) => T;
+    handler: (data: {
+        body: T;
+    }) => unknown;
+}) => T;
+declare const createParser: <T>(arg: T) => (p: unknown, errorFn: ErrorFn) => T;
+declare const genericFnTuple: <T>(args: [
+    parser: (p: unknown, errorFn: ErrorFn) => T,
+    handler: (data: {
+        body: T;
+    }) => unknown
+]) => T;