Add inlay hints support

src/compiler/checker.ts

@@ -425,6 +425,7 @@ namespace ts {
                 return node ? getTypeFromTypeNode(node) : errorType;
             },
             getParameterType: getTypeAtPosition,
+            getParameterIdentifierNameAtPosition,
             getPromisedTypeOfPromise,
             getAwaitedType: type => getAwaitedType(type),
             getReturnTypeOfSignature,
@@ -30336,6 +30337,39 @@ namespace ts {
             return restParameter.escapedName;
         }
 
+        function getParameterIdentifierNameAtPosition(signature: Signature, pos: number): [__String, boolean] | undefined {
+            const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
+            if (pos < paramCount) {
+                const param = signature.parameters[pos];
+                return isParameterDeclarationWithIdentifierName(param) ? [param.escapedName, false] : undefined;
+            }
+
+            const restParameter = signature.parameters[paramCount] || unknownSymbol;
+            if (!isParameterDeclarationWithIdentifierName(restParameter)) {
+                return undefined;
+            }
+
+            const restType = getTypeOfSymbol(restParameter);
+            if (isTupleType(restType)) {
+                const associatedNames = ((restType as TypeReference).target as TupleType).labeledElementDeclarations;
+                const index = pos - paramCount;
+                const associatedName = associatedNames?.[index];
+                const isRestTupleElement = !!associatedName?.dotDotDotToken;
+                return associatedName ? [
+                    getTupleElementLabel(associatedName),
+                    isRestTupleElement
+                ] : undefined;
+            }
+
+            if (pos === paramCount) {
+                return [restParameter.escapedName, true];
+            }
+            return undefined;
+        }
+
+        function isParameterDeclarationWithIdentifierName(symbol: Symbol) {
+            return symbol.valueDeclaration && isParameter(symbol.valueDeclaration) && isIdentifier(symbol.valueDeclaration.name);
+        }
         function isValidDeclarationForTupleLabel(d: Declaration): d is NamedTupleMember | (ParameterDeclaration & { name: Identifier }) {
             return d.kind === SyntaxKind.NamedTupleMember || (isParameter(d) && d.name && isIdentifier(d.name));
         }

src/compiler/types.ts

@@ -4100,6 +4100,7 @@ namespace ts {
          * Returns `any` if the index is not valid.
          */
         /* @internal */ getParameterType(signature: Signature, parameterIndex: number): Type;
+        /* @internal */ getParameterIdentifierNameAtPosition(signature: Signature, parameterIndex: number): [__String, boolean] | undefined;
         getNullableType(type: Type, flags: TypeFlags): Type;
         getNonNullableType(type: Type): Type;
         /* @internal */ getNonOptionalType(type: Type): Type;
@@ -8462,6 +8463,14 @@ namespace ts {
         readonly providePrefixAndSuffixTextForRename?: boolean;
         readonly includePackageJsonAutoImports?: "auto" | "on" | "off";
         readonly provideRefactorNotApplicableReason?: boolean;
+        readonly includeInlayParameterNameHints?: boolean;
+        readonly includeInlayNonLiteralParameterNameHints?: boolean;
+        readonly includeInlayDuplicatedParameterNameHints?: boolean;
+        readonly includeInlayFunctionParameterTypeHints?: boolean;
+        readonly includeInlayVariableTypeHints?: boolean;
+        readonly includeInlayPropertyDeclarationTypeHints?: boolean;
+        readonly includeInlayFunctionLikeReturnTypeHints?: boolean;
+        readonly includeInlayEnumMemberValueHints?: boolean;
     }
 
     /** Represents a bigint literal value without requiring bigint support */

src/compiler/utilitiesPublic.ts

@@ -1232,6 +1232,11 @@ namespace ts {
         return node && isFunctionLikeDeclarationKind(node.kind);
     }
 
+    /* @internal */
+    export function isBooleanLiteral(node: Node): node is BooleanLiteral {
+        return node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword;
+    }
+
     function isFunctionLikeDeclarationKind(kind: SyntaxKind): boolean {
         switch (kind) {
             case SyntaxKind.FunctionDeclaration:

src/harness/client.ts

@@ -646,6 +646,22 @@ namespace ts.server {
 
         applyCodeActionCommand = notImplemented;
 
+        provideInlayHints(file: string, span: TextSpan): InlayHint[] {
+            const { start, length } = span;
+            const args: protocol.ProvideInlayHintsRequestArgs = { file, start, length };
+
+            const request = this.processRequest<protocol.ProvideInlayHintsRequest>(CommandNames.ProvideInlayHints, args);
+            const response = this.processResponse<protocol.ProvideInlayHintsResponse>(request);
+
+            return response.body!.map(item => ({ // TODO: GH#18217
+                text: item.text,
+                position: this.lineOffsetToPosition(file, item.position),
+                kind: item.kind as InlayHintKind | undefined,
+                whitespaceBefore: item.whitespaceBefore,
+                whitespaceAfter: item.whitespaceAfter
+            }));
+        }
+
         private createFileLocationOrRangeRequestArgs(positionOrRange: number | TextRange, fileName: string): protocol.FileLocationOrRangeRequestArgs {
             return typeof positionOrRange === "number"
                 ? this.createFileLocationRequestArgs(fileName, positionOrRange)

src/harness/fourslashImpl.ts

@@ -1,3 +1,4 @@
+
 namespace FourSlash {
     import ArrayOrSingle = FourSlashInterface.ArrayOrSingle;
 
@@ -836,6 +837,22 @@ namespace FourSlash {
             });
         }
 
+        public verifyInlayHints(expected: readonly FourSlashInterface.VerifyInlayHintsOptions[], span: ts.TextSpan = { start: 0, length: this.activeFile.content.length }, preference?: ts.InlayHintsOptions) {
+            const hints = this.languageService.provideInlayHints(this.activeFile.fileName, span, preference);
+            assert.equal(hints.length, expected.length, "Number of hints");
+
+            const sortHints = (a: ts.InlayHint, b: ts.InlayHint) => {
+                return a.position - b.position;
+            };
+            ts.zipWith(hints.sort(sortHints), [...expected].sort(sortHints), (actual, expected) => {
+                assert.equal(actual.text, expected.text, "Text");
+                assert.deepEqual(actual.position, expected.position, "Position");
+                assert.equal(actual.kind, expected.kind, "Kind");
+                assert.equal(actual.whitespaceBefore, expected.whitespaceBefore, "whitespaceBefore");
+                assert.equal(actual.whitespaceAfter, expected.whitespaceAfter, "whitespaceAfter");
+            });
+        }
+
         public verifyCompletions(options: FourSlashInterface.VerifyCompletionsOptions) {
             if (options.marker === undefined) {
                 this.verifyCompletionsWorker(options);

src/harness/fourslashInterfaceImpl.ts

@@ -247,6 +247,10 @@ namespace FourSlashInterface {
             }
         }
 
+        public getInlayHints(expected: readonly VerifyInlayHintsOptions[], span: ts.TextSpan, preference?: ts.InlayHintsOptions) {
+            this.state.verifyInlayHints(expected, span, preference);
+        }
+
         public quickInfoIs(expectedText: string, expectedDocumentation?: string) {
             this.state.verifyQuickInfoString(expectedText, expectedDocumentation);
         }
@@ -1663,6 +1667,14 @@ namespace FourSlashInterface {
         readonly containerKind?: ts.ScriptElementKind;
     }
 
+    export interface VerifyInlayHintsOptions {
+        text: string;
+        position: number;
+        kind?: ts.InlayHintKind;
+        whitespaceBefore?: boolean;
+        whitespaceAfter?: boolean;
+    }
+
     export type ArrayOrSingle<T> = T | readonly T[];
 
     export interface VerifyCompletionListContainsOptions extends ts.UserPreferences {

src/harness/harnessLanguageService.ts

@@ -599,6 +599,9 @@ namespace Harness.LanguageService {
         provideCallHierarchyOutgoingCalls(fileName: string, position: number) {
             return unwrapJSONCallResult(this.shim.provideCallHierarchyOutgoingCalls(fileName, position));
         }
+        provideInlayHints(fileName: string, span: ts.TextSpan, preference: ts.InlayHintsOptions) {
+            return unwrapJSONCallResult(this.shim.provideInlayHints(fileName, span, preference));
+        }
         getEmitOutput(fileName: string): ts.EmitOutput {
             return unwrapJSONCallResult(this.shim.getEmitOutput(fileName));
         }

src/server/protocol.ts

@@ -154,6 +154,7 @@ namespace ts.server.protocol {
         PrepareCallHierarchy = "prepareCallHierarchy",
         ProvideCallHierarchyIncomingCalls = "provideCallHierarchyIncomingCalls",
         ProvideCallHierarchyOutgoingCalls = "provideCallHierarchyOutgoingCalls",
+        ProvideInlayHints = "provideInlayHints"
 
         // NOTE: If updating this, be sure to also update `allCommandNames` in `testRunner/unittests/tsserver/session.ts`.
     }
@@ -2549,6 +2550,40 @@ namespace ts.server.protocol {
         body?: SignatureHelpItems;
     }
 
+    export const enum InlayHintKind {
+        Other = 0,
+        Type = 1,
+        Parameter = 2,
+    }
+
+    export interface ProvideInlayHintsRequestArgs extends FileRequestArgs {
+        /**
+         * Start position of the span.
+         */
+        start: number;
+        /**
+         * Length of the span.
+         */
+        length: number;
+    }
+
+    export interface ProvideInlayHintsRequest extends Request {
+        command: CommandTypes.ProvideInlayHints;
+        arguments: ProvideInlayHintsRequestArgs;
+    }
+
+    export interface InlayHintItem {
+        text: string;
+        position: Location;
+        kind?: InlayHintKind;
+        whitespaceBefore?: boolean;
+        whitespaceAfter?: boolean;
+    }
+
+    export interface ProvideInlayHintsResponse extends Response {
+        body?: InlayHintItem[];
+    }
+
     /**
      * Synchronous request for semantic diagnostics of one file.
      */

src/server/scriptInfo.ts

@@ -651,6 +651,13 @@ namespace ts.server {
             return location;
         }
 
+        textSpanToProtoTextSpan(range: TextSpan): protocol.TextSpan {
+            return {
+                start: this.positionToLineOffset(range.start),
+                end: this.positionToLineOffset(range.start + range.length)
+            };
+        }
+
         public isJavaScript() {
             return this.scriptKind === ScriptKind.JS || this.scriptKind === ScriptKind.JSX;
         }

src/server/session.ts

@@ -1449,6 +1449,20 @@ namespace ts.server {
             });
         }
 
+        private provideInlayHints(args: protocol.ProvideInlayHintsRequestArgs) {
+            const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
+            const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file)!;
+            const hints = languageService.provideInlayHints(file, args, this.getPreferences(file));
+
+            return hints.map(hint => ({
+                text: hint.text,
+                position: scriptInfo.positionToLineOffset(hint.position),
+                kind: hint.kind,
+                whitespaceBefore: hint.whitespaceBefore,
+                whitespaceAfter: hint.whitespaceAfter
+            }));
+        }
+
         private setCompilerOptionsForInferredProjects(args: protocol.SetCompilerOptionsForInferredProjectsArgs): void {
             this.projectService.setCompilerOptionsForInferredProjects(args.options, args.projectRootPath);
         }
@@ -2962,6 +2976,9 @@ namespace ts.server {
             [CommandNames.UncommentSelectionFull]: (request: protocol.UncommentSelectionRequest) => {
                 return this.requiredResponse(this.uncommentSelection(request.arguments, /*simplifiedResult*/ false));
             },
+            [CommandNames.ProvideInlayHints]: (request: protocol.ProvideInlayHintsRequest) => {
+                return this.requiredResponse(this.provideInlayHints(request.arguments));
+            }
         }));
 
         public addProtocolHandler(command: string, handler: (request: protocol.Request) => HandlerResponse) {