Add function expression like hints

Author: Kingwl

src/server/protocol.ts

@@ -2491,8 +2491,10 @@ namespace ts.server.protocol {
     }
 
     export interface HintItem {
-        text: string
-        position: Location
+        text: string;
+        position: Location;
+        whitespaceBefore?: boolean;
+        whitespaceAfter?: boolean;
     }
 
     export interface ProvideInlineHintsResponse extends Response {

src/server/session.ts

@@ -1428,7 +1428,9 @@ namespace ts.server {
 
             return hints.map(hint => ({
                 text: hint.text,
-                position: scriptInfo.positionToLineOffset(hint.position)
+                position: scriptInfo.positionToLineOffset(hint.position),
+                whitespaceBefore: hint.whitespaceBefore,
+                whitespaceAfter: hint.whitespaceAfter
             }));
         }
 

src/services/inlineHints.ts

@@ -1,8 +1,10 @@
 /* @internal */
 namespace ts.InlineHints {
     interface HintInfo {
-        text: string
-        position: number
+        text: string;
+        position: number;
+        whitespaceBefore?: boolean;
+        whitespaceAfter?: boolean;
     }
 
     export function provideInlineHints(context: InlineHintsContext): HintInfo[] {
@@ -41,21 +43,20 @@ namespace ts.InlineHints {
             if (isCallExpression(node) || isNewExpression(node)) {
                 visitCallOrNewExpression(node);
             }
+            else if (isArrowFunction(node) || isFunctionExpression(node)) {
+                visitFunctionExpressionLike(node);
+            }
             return forEachChild(node, visitor);
         }
 
         function visitCallOrNewExpression(expr: CallExpression | NewExpression) {
-            const candidates: Signature[] = [];
-            const signature = checker.getResolvedSignatureForSignatureHelp(expr, candidates);
-            if (!signature || !candidates.length) {
+            if (!expr.arguments || !expr.arguments.length) {
                 return;
             }
 
-            getCallArgumentsHints(expr, signature);
-        }
-
-        function getCallArgumentsHints(expr: CallExpression | NewExpression, signature: Signature) {
-            if (!expr.arguments || !expr.arguments.length) {
+            const candidates: Signature[] = [];
+            const signature = checker.getResolvedSignatureForSignatureHelp(expr, candidates);
+            if (!signature || !candidates.length) {
                 return;
             }
 
@@ -67,11 +68,55 @@ namespace ts.InlineHints {
                     if (!argumentName || argumentName !== parameterName) {
                         result.push({
                             text: `${unescapeLeadingUnderscores(parameterName)}:`,
-                            position: expr.arguments[i].getStart()
+                            position: expr.arguments[i].getStart(),
+                            whitespaceAfter: true,
                         });
                     }
                 }
             }
         }
+
+        function visitFunctionExpressionLike(expr: ArrowFunction | FunctionExpression) {
+            if (!expr.parameters.length || expr.parameters.every(param => param.type)) {
+                return;
+            }
+
+            const contextualType = checker.getContextualType(expr);
+            if (!contextualType) {
+                return;
+            }
+
+            const signatures = checker.getSignaturesOfType(contextualType, SignatureKind.Call);
+            const signature = firstOrUndefined(signatures);
+            if (!signature) {
+                return;
+            }
+
+            for (let i = 0; i < expr.parameters.length && i < signature.parameters.length; ++i) {
+                const param = expr.parameters[i];
+                if (param.type) {
+                    continue;
+                }
+
+                const signatureParam = signature.parameters[i];
+                const signatureParamType = checker.getTypeOfSymbolAtLocation(signatureParam, signatureParam.valueDeclaration);
+
+                const valueDeclaration = signatureParam.valueDeclaration;
+                if (!valueDeclaration || !isParameter(valueDeclaration) || !valueDeclaration.type) {
+                    continue;
+                }
+
+                const typeDisplayString = displayPartsToString(typeToDisplayParts(checker, signatureParamType));
+                if (!typeDisplayString) {
+                    continue;
+                }
+
+                result.push({
+                    text: `:${typeDisplayString}`,
+                    position: param.end,
+                    whitespaceBefore: true,
+                });
+            }
+        }
     }
 }

src/services/types.ts

@@ -688,8 +688,10 @@ namespace ts {
     }
 
     export interface InlineHint {
-        text: string,
-        position: number
+        text: string;
+        position: number;
+        whitespaceBefore?: boolean;
+        whitespaceAfter?: boolean;
     }
 
     export interface TodoCommentDescriptor {

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -5711,6 +5711,8 @@ declare namespace ts {
     interface InlineHint {
         text: string;
         position: number;
+        whitespaceBefore?: boolean;
+        whitespaceAfter?: boolean;
     }
     interface TodoCommentDescriptor {
         text: string;
@@ -8403,6 +8405,8 @@ declare namespace ts.server.protocol {
     interface HintItem {
         text: string;
         position: Location;
+        whitespaceBefore?: boolean;
+        whitespaceAfter?: boolean;
     }
     interface ProvideInlineHintsResponse extends Response {
         body?: HintItem[];

tests/baselines/reference/api/typescript.d.ts

@@ -5711,6 +5711,8 @@ declare namespace ts {
     interface InlineHint {
         text: string;
         position: number;
+        whitespaceBefore?: boolean;
+        whitespaceAfter?: boolean;
     }
     interface TodoCommentDescriptor {
         text: string;