microsoft
diff --git a/‎src/compiler/checker.ts
Copy file name to clipboard
+34Lines changed: 34 additions & 0 deletions b/‎src/compiler/checker.ts
Copy file name to clipboard
+34Lines changed: 34 additions & 0 deletions
diff --git a/‎src/compiler/types.ts
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎src/compiler/types.ts
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
diff --git a/‎src/compiler/utilitiesPublic.ts
Copy file name to clipboard
+5Lines changed: 5 additions & 0 deletions b/‎src/compiler/utilitiesPublic.ts
Copy file name to clipboard
+5Lines changed: 5 additions & 0 deletions
diff --git a/‎src/harness/client.ts
Copy file name to clipboard
+14Lines changed: 14 additions & 0 deletions b/‎src/harness/client.ts
Copy file name to clipboard
+14Lines changed: 14 additions & 0 deletions
diff --git a/‎src/harness/fourslashImpl.ts
Copy file name to clipboard
+17Lines changed: 17 additions & 0 deletions b/‎src/harness/fourslashImpl.ts
Copy file name to clipboard
+17Lines changed: 17 additions & 0 deletions
diff --git a/‎src/harness/fourslashInterfaceImpl.ts
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions b/‎src/harness/fourslashInterfaceImpl.ts
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions
diff --git a/‎src/harness/harnessLanguageService.ts
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions b/‎src/harness/harnessLanguageService.ts
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions
diff --git a/‎src/server/protocol.ts
Copy file name to clipboard
+35Lines changed: 35 additions & 0 deletions b/‎src/server/protocol.ts
Copy file name to clipboard
+35Lines changed: 35 additions & 0 deletions
diff --git a/‎src/server/session.ts
Copy file name to clipboard
+14Lines changed: 14 additions & 0 deletions b/‎src/server/session.ts
Copy file name to clipboard
+14Lines changed: 14 additions & 0 deletions
@@ -428,6 +428,7 @@ namespace ts {
                 return node ? getTypeFromTypeNode(node) : errorType;
             },
             getParameterType: getTypeAtPosition,
+            getParameterIdentifierNameAtPosition,
             getPromisedTypeOfPromise,
             getAwaitedType: type => getAwaitedType(type),
             getReturnTypeOfSignature,
@@ -30352,6 +30353,39 @@ namespace ts {
             return restParameter.escapedName;
         }
 
+        function getParameterIdentifierNameAtPosition(signature: Signature, pos: number): [parameterName: __String, isRestParameter: 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));
         }
 
@@ -4104,6 +4104,7 @@ namespace ts {
          * Returns `any` if the index is not valid.
          */
         /* @internal */ getParameterType(signature: Signature, parameterIndex: number): Type;
+        /* @internal */ getParameterIdentifierNameAtPosition(signature: Signature, parameterIndex: number): [parameterName: __String, isRestParameter: boolean] | undefined;
         getNullableType(type: Type, flags: TypeFlags): Type;
         getNonNullableType(type: Type): Type;
         /* @internal */ getNonOptionalType(type: Type): Type;
 
@@ -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:
 
@@ -644,6 +644,20 @@ namespace ts.server {
 
         applyCodeActionCommand = notImplemented;
 
+        provideInlayHints(file: string, span: TextSpan): InlayHint[] {
+            const { start, length } = span;
+            const args: protocol.InlayHintsRequestArgs = { file, start, length };
+
+            const request = this.processRequest<protocol.InlayHintsRequest>(CommandNames.ProvideInlayHints, args);
+            const response = this.processResponse<protocol.InlayHintsResponse>(request);
+
+            return response.body!.map(item => ({ // TODO: GH#18217
+                ...item,
+                kind: item.kind as InlayHintKind | undefined,
+                position: this.lineOffsetToPosition(file, item.position),
+            }));
+        }
+
         private createFileLocationOrRangeRequestArgs(positionOrRange: number | TextRange, fileName: string): protocol.FileLocationOrRangeRequestArgs {
             return typeof positionOrRange === "number"
                 ? this.createFileLocationRequestArgs(fileName, positionOrRange)
 
@@ -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.equal(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);
 
@@ -251,6 +251,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);
         }
@@ -1667,6 +1671,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 {
 
@@ -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));
         }
 
@@ -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 {
+        Type = "Type",
+        Parameter = "Parameter",
+        Enum = "Enum",
+    }
+
+    export interface InlayHintsRequestArgs extends FileRequestArgs {
+        /**
+         * Start position of the span.
+         */
+        start: number;
+        /**
+         * Length of the span.
+         */
+        length: number;
+    }
+
+    export interface InlayHintsRequest extends Request {
+        command: CommandTypes.ProvideInlayHints;
+        arguments: InlayHintsRequestArgs;
+    }
+
+    export interface InlayHintItem {
+        text: string;
+        position: Location;
+        kind?: InlayHintKind;
+        whitespaceBefore?: boolean;
+        whitespaceAfter?: boolean;
+    }
+
+    export interface InlayHintsResponse extends Response {
+        body?: InlayHintItem[];
+    }
+
     /**
      * Synchronous request for semantic diagnostics of one file.
      */
 
@@ -1450,6 +1450,17 @@ namespace ts.server {
             });
         }
 
+        private provideInlayHints(args: protocol.InlayHintsRequestArgs) {
+            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 => ({
+                ...hint,
+                position: scriptInfo.positionToLineOffset(hint.position),
+            }));
+        }
+
         private setCompilerOptionsForInferredProjects(args: protocol.SetCompilerOptionsForInferredProjectsArgs): void {
             this.projectService.setCompilerOptionsForInferredProjects(args.options, args.projectRootPath);
         }
@@ -2963,6 +2974,9 @@ namespace ts.server {
             [CommandNames.UncommentSelectionFull]: (request: protocol.UncommentSelectionRequest) => {
                 return this.requiredResponse(this.uncommentSelection(request.arguments, /*simplifiedResult*/ false));
             },
+            [CommandNames.ProvideInlayHints]: (request: protocol.InlayHintsRequest) => {
+                return this.requiredResponse(this.provideInlayHints(request.arguments));
+            }
         }));
 
         public addProtocolHandler(command: string, handler: (request: protocol.Request) => HandlerResponse) {
Original file line number	Diff line number	Diff line change
`@@ -251,6 +251,10 @@ namespace FourSlashInterface {`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`
	`254`	`+ public getInlayHints(expected: readonly VerifyInlayHintsOptions[], span: ts.TextSpan, preference?: ts.InlayHintsOptions) {`
	`255`	`+ this.state.verifyInlayHints(expected, span, preference);`
	`256`	`+ }`
	`257`	`+`
`254`	`258`	`public quickInfoIs(expectedText: string, expectedDocumentation?: string) {`
`255`	`259`	`this.state.verifyQuickInfoString(expectedText, expectedDocumentation);`
`256`	`260`	`}`
`@@ -1667,6 +1671,14 @@ namespace FourSlashInterface {`
`1667`	`1671`	`readonly containerKind?: ts.ScriptElementKind;`
`1668`	`1672`	`}`
`1669`	`1673`
	`1674`	`+ export interface VerifyInlayHintsOptions {`
	`1675`	`+ text: string;`
	`1676`	`+ position: number;`
	`1677`	`+ kind?: ts.InlayHintKind;`
	`1678`	`+ whitespaceBefore?: boolean;`
	`1679`	`+ whitespaceAfter?: boolean;`
	`1680`	`+ }`
	`1681`	`+`
`1670`	`1682`	`export type ArrayOrSingle<T> = T \| readonly T[];`
`1671`	`1683`
`1672`	`1684`	`export interface VerifyCompletionListContainsOptions extends ts.UserPreferences {`
Original file line number	Diff line number	Diff line change
`@@ -599,6 +599,9 @@ namespace Harness.LanguageService {`
`599`	`599`	`provideCallHierarchyOutgoingCalls(fileName: string, position: number) {`
`600`	`600`	`return unwrapJSONCallResult(this.shim.provideCallHierarchyOutgoingCalls(fileName, position));`
`601`	`601`	`}`
	`602`	`+ provideInlayHints(fileName: string, span: ts.TextSpan, preference: ts.InlayHintsOptions) {`
	`603`	`+ return unwrapJSONCallResult(this.shim.provideInlayHints(fileName, span, preference));`
	`604`	`+ }`
`602`	`605`	`getEmitOutput(fileName: string): ts.EmitOutput {`
`603`	`606`	`return unwrapJSONCallResult(this.shim.getEmitOutput(fileName));`
`604`	`607`	`}`