fix(45224): show inlay hints for setter parameter (#45229)

Author: a-tarasyuk

src/compiler/checker.ts

@@ -16442,25 +16442,6 @@ namespace ts {
                 (hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node));
         }
 
-        function hasContextSensitiveParameters(node: FunctionLikeDeclaration) {
-            // Functions with type parameters are not context sensitive.
-            if (!node.typeParameters) {
-                // Functions with any parameters that lack type annotations are context sensitive.
-                if (some(node.parameters, p => !getEffectiveTypeAnnotationNode(p))) {
-                    return true;
-                }
-                if (node.kind !== SyntaxKind.ArrowFunction) {
-                    // If the first parameter is not an explicit 'this' parameter, then the function has
-                    // an implicit 'this' parameter which is subject to contextual typing.
-                    const parameter = firstOrUndefined(node.parameters);
-                    if (!(parameter && parameterIsThisKeyword(parameter))) {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
-
         function hasContextSensitiveReturnExpression(node: FunctionLikeDeclaration) {
             // TODO(anhans): A block should be context-sensitive if it has a context-sensitive return value.
             return !node.typeParameters && !getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== SyntaxKind.Block && isContextSensitive(node.body);

src/compiler/utilities.ts

@@ -7343,4 +7343,23 @@ namespace ts {
                 return (parent as SourceFile).statements;
         }
     }
+
+    export function hasContextSensitiveParameters(node: FunctionLikeDeclaration) {
+        // Functions with type parameters are not context sensitive.
+        if (!node.typeParameters) {
+            // Functions with any parameters that lack type annotations are context sensitive.
+            if (some(node.parameters, p => !getEffectiveTypeAnnotationNode(p))) {
+                return true;
+            }
+            if (node.kind !== SyntaxKind.ArrowFunction) {
+                // If the first parameter is not an explicit 'this' parameter, then the function has
+                // an implicit 'this' parameter which is subject to contextual typing.
+                const parameter = firstOrUndefined(node.parameters);
+                if (!(parameter && parameterIsThisKeyword(parameter))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
 }

src/services/inlayHints.ts

@@ -64,8 +64,8 @@ namespace ts.InlayHints {
                 visitCallOrNewExpression(node);
             }
             else {
-                if (preferences.includeInlayFunctionParameterTypeHints && isFunctionExpressionLike(node)) {
-                    visitFunctionExpressionLikeForParameterType(node);
+                if (preferences.includeInlayFunctionParameterTypeHints && isFunctionLikeDeclaration(node) && hasContextSensitiveParameters(node)) {
+                    visitFunctionLikeForParameterType(node);
                 }
                 if (preferences.includeInlayFunctionLikeReturnTypeHints && isSignatureSupportingReturnAnnotation(node)) {
                     visitFunctionDeclarationLikeForReturnType(node);
@@ -78,10 +78,6 @@ namespace ts.InlayHints {
             return isArrowFunction(node) || isFunctionExpression(node) || isFunctionDeclaration(node) || isMethodDeclaration(node) || isGetAccessorDeclaration(node);
         }
 
-        function isFunctionExpressionLike(node: Node): node is ArrowFunction | FunctionExpression {
-            return isArrowFunction(node) || isFunctionExpression(node);
-        }
-
         function addParameterHints(text: string, position: number, isFirstVariadicArgument: boolean) {
             result.push({
                 text: `${isFirstVariadicArgument ? "..." : ""}${truncation(text, maxHintsLength)}:`,
@@ -207,7 +203,7 @@ namespace ts.InlayHints {
         }
 
         function isHintableExpression(node: Node) {
-            return isLiteralExpression(node) || isBooleanLiteral(node) || isFunctionExpressionLike(node) || isObjectLiteralExpression(node) || isArrayLiteralExpression(node);
+            return isLiteralExpression(node) || isBooleanLiteral(node) || isArrowFunction(node) || isFunctionExpression(node) || isObjectLiteralExpression(node) || isArrayLiteralExpression(node);
         }
 
         function visitFunctionDeclarationLikeForReturnType(decl: FunctionDeclaration | ArrowFunction | FunctionExpression | MethodDeclaration | GetAccessorDeclaration) {
@@ -248,24 +244,14 @@ namespace ts.InlayHints {
             return decl.parameters.end;
         }
 
-        function visitFunctionExpressionLikeForParameterType(expr: ArrowFunction | FunctionExpression) {
-            if (!expr.parameters.length || expr.parameters.every(param => !!getEffectiveTypeAnnotationNode(param))) {
-                return;
-            }
-
-            const contextualType = checker.getContextualType(expr);
-            if (!contextualType) {
-                return;
-            }
-
-            const signatures = checker.getSignaturesOfType(contextualType, SignatureKind.Call);
-            const signature = firstOrUndefined(signatures);
+        function visitFunctionLikeForParameterType(node: FunctionLikeDeclaration) {
+            const signature = checker.getSignatureFromDeclaration(node);
             if (!signature) {
                 return;
             }
 
-            for (let i = 0; i < expr.parameters.length && i < signature.parameters.length; ++i) {
-                const param = expr.parameters[i];
+            for (let i = 0; i < node.parameters.length && i < signature.parameters.length; ++i) {
+                const param = node.parameters[i];
                 const effectiveTypeAnnotation = getEffectiveTypeAnnotationNode(param);
 
                 if (effectiveTypeAnnotation) {

tests/cases/fourslash/inlayHintsShouldWork57.ts

@@ -0,0 +1,19 @@
+/// <reference path="fourslash.ts" />
+
+////class Foo {
+////    #value = 0;
+////    get foo(): number { return this.#value; }
+////    set foo(value/**/) { this.#value = value; }
+////}
+
+const [marker] = test.markers();
+verify.getInlayHints([
+    {
+        text: ': number',
+        position: marker.position,
+        kind: ts.InlayHintKind.Type,
+        whitespaceBefore: true
+    }
+], undefined, {
+    includeInlayFunctionParameterTypeHints: true
+});

tests/cases/fourslash/inlayHintsShouldWork58.ts

@@ -0,0 +1,11 @@
+/// <reference path="fourslash.ts" />
+
+////class Foo {
+////    #value = 0;
+////    get foo(): number { return this.#value; }
+////    set foo(value/**/: number) { this.#value = value; }
+////}
+
+verify.getInlayHints([], undefined, {
+    includeInlayFunctionParameterTypeHints: true
+});

tests/cases/fourslash/inlayHintsShouldWork59.ts

@@ -0,0 +1,17 @@
+/// <reference path="fourslash.ts" />
+
+// @allowJs: true
+// @checkJs: true
+// @Filename: /a.js
+////class Foo {
+////    #value = 0;
+////    get foo() { return this.#value; }
+////    /**
+////     * @param {number} value
+////     */
+////    set foo(value/**/) { this.#value = value; }
+////}
+
+verify.getInlayHints([], undefined, {
+    includeInlayFunctionParameterTypeHints: true
+});

tests/cases/fourslash/inlayHintsShouldWork60.ts

@@ -0,0 +1,22 @@
+/// <reference path="fourslash.ts" />
+
+// @allowJs: true
+// @checkJs: true
+// @Filename: /a.js
+////class Foo {
+////    #value = 0;
+////    get foo() { return this.#value; }
+////    set foo(value/**/) { this.#value = value; }
+////}
+
+const [marker] = test.markers();
+verify.getInlayHints([
+    {
+        text: ': number',
+        position: marker.position,
+        kind: ts.InlayHintKind.Type,
+        whitespaceBefore: true
+    }
+], undefined, {
+    includeInlayFunctionParameterTypeHints: true
+});