microsoft · gabritto · May 5, 2025 · May 5, 2025 · May 5, 2025 · May 6, 2025
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -5143,7 +5143,16 @@ export interface TypeChecker {
     symbolToParameterDeclaration(symbol: Symbol, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): ParameterDeclaration | undefined;
     /** Note that the resulting nodes cannot be checked. */
     typeParameterToDeclaration(parameter: TypeParameter, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): TypeParameterDeclaration | undefined;
-    /** @internal */ typeParameterToDeclaration(parameter: TypeParameter, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined, internalFlags?: InternalNodeBuilderFlags, tracker?: SymbolTracker, verbosityLevel?: number, out?: WriterContextOut): TypeParameterDeclaration | undefined; // eslint-disable-line @typescript-eslint/unified-signatures
+    /** @internal */ typeParameterToDeclaration(
+        parameter: TypeParameter,
+        enclosingDeclaration: Node | undefined,
+        flags: NodeBuilderFlags | undefined,
+        internalFlags?: InternalNodeBuilderFlags,
+        tracker?: SymbolTracker,
+        maximumLength?: number,
+        verbosityLevel?: number,
+        out?: WriterContextOut, // eslint-disable-line @typescript-eslint/unified-signatures
+    ): TypeParameterDeclaration | undefined;
 
     getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
     getSymbolAtLocation(node: Node): Symbol | undefined;
@@ -5175,8 +5184,25 @@ export interface TypeChecker {
     symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): string;
     typePredicateToString(predicate: TypePredicate, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
 
-    /** @internal */ writeSignature(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind, writer?: EmitTextWriter, verbosityLevel?: number, out?: WriterContextOut): string;
-    /** @internal */ writeType(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags, writer?: EmitTextWriter, verbosityLevel?: number, out?: WriterContextOut): string;
+    /** @internal */ writeSignature(
+        signature: Signature,
+        enclosingDeclaration?: Node,
+        flags?: TypeFormatFlags,
+        kind?: SignatureKind,
+        writer?: EmitTextWriter,
+        maximumLength?: number,
+        verbosityLevel?: number,
+        out?: WriterContextOut,
+    ): string;
+    /** @internal */ writeType(
+        type: Type,
+        enclosingDeclaration?: Node,
+        flags?: TypeFormatFlags,
+        writer?: EmitTextWriter,
+        maximumLength?: number,
+        verbosityLevel?: number,
+        out?: WriterContextOut,
+    ): string;
     /** @internal */ writeSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags, writer?: EmitTextWriter): string;
     /** @internal */ writeTypePredicate(predicate: TypePredicate, enclosingDeclaration?: Node, flags?: TypeFormatFlags, writer?: EmitTextWriter): string;
 
@@ -5896,7 +5922,7 @@ export interface EmitResolver {
     isImportRequiredByAugmentation(decl: ImportDeclaration): boolean;
     isDefinitelyReferenceToGlobalSymbolObject(node: Node): boolean;
     createLateBoundIndexSignatures(cls: ClassLikeDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): (IndexSignatureDeclaration | PropertyDeclaration)[] | undefined;
-    symbolToDeclarations(symbol: Symbol, meaning: SymbolFlags, flags: NodeBuilderFlags, verbosityLevel?: number, out?: WriterContextOut): Declaration[];
+    symbolToDeclarations(symbol: Symbol, meaning: SymbolFlags, flags: NodeBuilderFlags, maximumLength?: number, verbosityLevel?: number, out?: WriterContextOut): Declaration[];
 }
 
 // dprint-ignore
@@ -10517,6 +10543,12 @@ export interface UserPreferences {
     readonly displayPartsForJSDoc?: boolean;
     readonly generateReturnInDocTemplate?: boolean;
     readonly disableLineTextInReferences?: boolean;
+    /**
+     * A positive integer indicating the maximum length of a hover text before it is truncated.
+     *
+     * Default: `500`
+     */
+    readonly maximumHoverLength?: number;
 }
 
 export type OrganizeImportsTypeOrder = "last" | "inline" | "first";

diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -614,6 +614,8 @@ export const externalHelpersModuleNameText = "tslib";
 export const defaultMaximumTruncationLength = 160;
 /** @internal */
 export const noTruncationMaximumTruncationLength = 1_000_000;
+/** @internal */
+export const defaultHoverMaximumTruncationLength = 500;
 
 /** @internal */
 export function getDeclarationOfKind<T extends Declaration>(symbol: Symbol, kind: T["kind"]): T | undefined {

diff --git a/src/harness/client.ts b/src/harness/client.ts
@@ -254,7 +254,7 @@ export class SessionClient implements LanguageService {
         return { line, character: offset };
     }
 
-    getQuickInfoAtPosition(fileName: string, position: number, verbosityLevel?: number | undefined): QuickInfo {
+    getQuickInfoAtPosition(fileName: string, position: number, maximumLength?: number, verbosityLevel?: number | undefined): QuickInfo {
         const args = { ...this.createFileLocationRequestArgs(fileName, position), verbosityLevel };
 
         const request = this.processRequest<protocol.QuickInfoRequest>(protocol.CommandTypes.Quickinfo, args);

diff --git a/src/harness/fourslashImpl.ts b/src/harness/fourslashImpl.ts
@@ -2455,11 +2455,16 @@ export class TestState {
         return result;
     }
 
-    public baselineQuickInfo(verbosityLevels?: VerbosityLevels): void {
+    public baselineQuickInfo(verbosityLevels?: VerbosityLevels, maximumLength?: number): void {
         const result = ts.arrayFrom(this.testData.markerPositions.entries(), ([name, marker]) => {
             const verbosityLevel = toArray(verbosityLevels?.[name]);
             const items = verbosityLevel.map(verbosityLevel => {
-                const item: ts.QuickInfo & { verbosityLevel?: number; } | undefined = this.languageService.getQuickInfoAtPosition(marker.fileName, marker.position, verbosityLevel);
+                const item: ts.QuickInfo & { verbosityLevel?: number; } | undefined = this.languageService.getQuickInfoAtPosition(
+                    marker.fileName,
+                    marker.position,
+                    maximumLength,
+                    verbosityLevel,
+                );
                 if (item) item.verbosityLevel = verbosityLevel;
                 return {
                     marker: { ...marker, name },

diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts
@@ -449,8 +449,8 @@ export class Verify extends VerifyNegatable {
         this.state.baselineGetEmitOutput();
     }
 
-    public baselineQuickInfo(verbosityLevels?: FourSlash.VerbosityLevels): void {
-        this.state.baselineQuickInfo(verbosityLevels);
+    public baselineQuickInfo(verbosityLevels?: FourSlash.VerbosityLevels, maximumLength?: number): void {
+        this.state.baselineQuickInfo(verbosityLevels, maximumLength);
     }
 
     public baselineSignatureHelp(): void {

diff --git a/src/server/session.ts b/src/server/session.ts
@@ -2395,12 +2395,18 @@ export class Session<TMessage = string> implements EventSender {
     private getQuickInfoWorker(args: protocol.QuickInfoRequestArgs, simplifiedResult: boolean): protocol.QuickInfoResponseBody | QuickInfo | undefined {
         const { file, project } = this.getFileAndProject(args);
         const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file)!;
-        const quickInfo = project.getLanguageService().getQuickInfoAtPosition(file, this.getPosition(args, scriptInfo), args.verbosityLevel);
+        const userPreferences = this.getPreferences(file);
+        const quickInfo = project.getLanguageService().getQuickInfoAtPosition(
+            file,
+            this.getPosition(args, scriptInfo),
+            userPreferences.maximumHoverLength,
+            args.verbosityLevel,
+        );
         if (!quickInfo) {
             return undefined;
         }
 
-        const useDisplayParts = !!this.getPreferences(file).displayPartsForJSDoc;
+        const useDisplayParts = !!userPreferences.displayPartsForJSDoc;
         if (simplifiedResult) {
             const displayString = displayPartsToString(quickInfo.displayParts);
             return {

diff --git a/src/services/services.ts b/src/services/services.ts
@@ -49,6 +49,7 @@ import {
     Debug,
     Declaration,
     deduplicate,
+    defaultHoverMaximumTruncationLength,
     DefinitionInfo,
     DefinitionInfoAndBoundSpan,
     Diagnostic,
@@ -2274,7 +2275,7 @@ export function createLanguageService(
         return Completions.getCompletionEntrySymbol(program, log, getValidSourceFile(fileName), position, { name, source }, host, preferences);
     }
 
-    function getQuickInfoAtPosition(fileName: string, position: number, verbosityLevel?: number): QuickInfo | undefined {
+    function getQuickInfoAtPosition(fileName: string, position: number, maximumLength?: number, verbosityLevel?: number): QuickInfo | undefined {
         synchronizeHostData();
 
         const sourceFile = getValidSourceFile(fileName);
@@ -2310,6 +2311,7 @@ export function createLanguageService(
                     nodeForQuickInfo,
                     /*semanticMeaning*/ undefined,
                     /*alias*/ undefined,
+                    maximumLength ?? defaultHoverMaximumTruncationLength,
                     verbosityLevel,
                 ),
         );

diff --git a/src/services/symbolDisplay.ts b/src/services/symbolDisplay.ts
@@ -266,6 +266,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
     type: Type | undefined,
     semanticMeaning: SemanticMeaning,
     alias?: Symbol,
+    maximumLength?: number,
     verbosityLevel?: number,
 ): SymbolDisplayPartsDocumentationAndSymbolKind {
     const displayParts: SymbolDisplayPart[] = [];
@@ -495,6 +496,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
                 location.parent && isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol),
                 enclosingDeclaration,
                 TypeFormatFlags.InTypeAlias,
+                maximumLength,
                 verbosityLevel,
                 typeWriterOut,
             ),
@@ -602,6 +604,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
                         type,
                         semanticMeaning,
                         shouldUseAliasName ? symbol : resolvedSymbol,
+                        maximumLength,
                         verbosityLevel,
                     );
                     displayParts.push(...resolvedInfo.displayParts);
@@ -700,11 +703,12 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
                                 symbolDisplayNodeBuilderFlags,
                                 /*internalFlags*/ undefined,
                                 /*tracker*/ undefined,
+                                maximumLength,
                                 verbosityLevel,
                                 typeWriterOut,
                             )!;
                             getPrinter().writeNode(EmitHint.Unspecified, param, getSourceFileOfNode(getParseTreeNode(enclosingDeclaration)), writer);
-                        });
+                        }, maximumLength);
                         addRange(displayParts, typeParameterParts);
                     }
                     else {
@@ -715,6 +719,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
                                 type,
                                 enclosingDeclaration,
                                 /*flags*/ undefined,
+                                maximumLength,
                                 verbosityLevel,
                                 typeWriterOut,
                             ),
@@ -889,6 +894,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
                     symbol,
                     symbolMeaning,
                     TypeFormatFlags.MultilineObjectLiterals | TypeFormatFlags.UseAliasDefinedOutsideCurrentScope,
+                    maximumLength,
                     verbosityLevel !== undefined ? verbosityLevel - 1 : undefined,
                     typeWriterOut,
                 );
@@ -898,7 +904,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
                     if (i > 0) writer.writeLine();
                     printer.writeNode(EmitHint.Unspecified, node, sourceFile, writer);
                 });
-            });
+            }, maximumLength);
             addRange(displayParts, expandedDisplayParts);
             symbolWasExpanded = true;
             return true;
@@ -973,7 +979,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
     }
 
     function addSignatureDisplayParts(signature: Signature, allSignatures: readonly Signature[], flags = TypeFormatFlags.None) {
-        addRange(displayParts, signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | TypeFormatFlags.WriteTypeArgumentsOfSignature, verbosityLevel, typeWriterOut));
+        addRange(displayParts, signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | TypeFormatFlags.WriteTypeArgumentsOfSignature, maximumLength, verbosityLevel, typeWriterOut));
         if (allSignatures.length > 1) {
             displayParts.push(spacePart());
             displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
@@ -1011,9 +1017,21 @@ export function getSymbolDisplayPartsDocumentationAndSymbolKind(
     location: Node,
     semanticMeaning: SemanticMeaning = getMeaningFromLocation(location),
     alias?: Symbol,
+    maximumLength?: number,
     verbosityLevel?: number,
 ): SymbolDisplayPartsDocumentationAndSymbolKind {
-    return getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symbol, sourceFile, enclosingDeclaration, location, /*type*/ undefined, semanticMeaning, alias, verbosityLevel);
+    return getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
+        typeChecker,
+        symbol,
+        sourceFile,
+        enclosingDeclaration,
+        location,
+        /*type*/ undefined,
+        semanticMeaning,
+        alias,
+        maximumLength,
+        verbosityLevel,
+    );
 }
 
 function isLocalVariableOrFunction(symbol: Symbol) {

diff --git a/src/services/types.ts b/src/services/types.ts
@@ -581,10 +581,11 @@ export interface LanguageService {
      *
      * @param fileName The path to the file
      * @param position A zero-based index of the character where you want the quick info
+     * @param maximumLength Maximum length of a quickinfo text before it is truncated.
      */
-    getQuickInfoAtPosition(fileName: string, position: number): QuickInfo | undefined;
+    getQuickInfoAtPosition(fileName: string, position: number, maximumLength?: number): QuickInfo | undefined;
     /** @internal */
-    getQuickInfoAtPosition(fileName: string, position: number, verbosityLevel: number | undefined): QuickInfo | undefined; // eslint-disable-line @typescript-eslint/unified-signatures
+    getQuickInfoAtPosition(fileName: string, position: number, maximumLength: number | undefined, verbosityLevel: number | undefined): QuickInfo | undefined;
 
     getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan | undefined;
 

diff --git a/src/services/utilities.ts b/src/services/utilities.ts
@@ -2761,9 +2761,17 @@ export function isFirstDeclarationOfSymbolParameter(symbol: Symbol): boolean {
     return !!findAncestor(declaration, n => isParameter(n) ? true : isBindingElement(n) || isObjectBindingPattern(n) || isArrayBindingPattern(n) ? false : "quit");
 }
 
-const displayPartWriter = getDisplayPartWriter();
-function getDisplayPartWriter(): DisplayPartsSymbolWriter {
-    const absoluteMaximumLength = defaultMaximumTruncationLength * 10; // A hard cutoff to avoid overloading the messaging channel in worst-case scenarios
+const displayPartWriterCache = new Map<number, DisplayPartsSymbolWriter>();
+function getDisplayPartWriter(maximumLength: number | undefined): DisplayPartsSymbolWriter {
+    maximumLength = maximumLength || defaultMaximumTruncationLength;
+    if (!displayPartWriterCache.has(maximumLength)) {
+        displayPartWriterCache.set(maximumLength, getDisplayPartWriterWorker(maximumLength));
+    }
+    return displayPartWriterCache.get(maximumLength)!;
+}
+
+function getDisplayPartWriterWorker(maximumLength: number): DisplayPartsSymbolWriter {
+    const absoluteMaximumLength = maximumLength * 10; // A hard cutoff to avoid overloading the messaging channel in worst-case scenarios
     let displayParts: SymbolDisplayPart[];
     let lineStart: boolean;
     let indent: number;
@@ -3036,7 +3044,8 @@ export function lineBreakPart(): SymbolDisplayPart {
 }
 
 /** @internal */
-export function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void): SymbolDisplayPart[] {
+export function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void, maximumLength?: number): SymbolDisplayPart[] {
+    const displayPartWriter = getDisplayPartWriter(maximumLength);
     try {
         writeDisplayParts(displayPartWriter);
         return displayPartWriter.displayParts();
@@ -3047,10 +3056,18 @@ export function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbol
 }
 
 /** @internal */
-export function typeToDisplayParts(typechecker: TypeChecker, type: Type, enclosingDeclaration?: Node, flags: TypeFormatFlags = TypeFormatFlags.None, verbosityLevel?: number, out?: WriterContextOut): SymbolDisplayPart[] {
+export function typeToDisplayParts(
+    typechecker: TypeChecker,
+    type: Type,
+    enclosingDeclaration?: Node,
+    flags: TypeFormatFlags = TypeFormatFlags.None,
+    maximumLength?: number,
+    verbosityLevel?: number,
+    out?: WriterContextOut,
+): SymbolDisplayPart[] {
     return mapToDisplayParts(writer => {
-        typechecker.writeType(type, enclosingDeclaration, flags | TypeFormatFlags.MultilineObjectLiterals | TypeFormatFlags.UseAliasDefinedOutsideCurrentScope, writer, verbosityLevel, out);
-    });
+        typechecker.writeType(type, enclosingDeclaration, flags | TypeFormatFlags.MultilineObjectLiterals | TypeFormatFlags.UseAliasDefinedOutsideCurrentScope, writer, maximumLength, verbosityLevel, out);
+    }, maximumLength);
 }
 
 /** @internal */
@@ -3061,11 +3078,19 @@ export function symbolToDisplayParts(typeChecker: TypeChecker, symbol: Symbol, e
 }
 
 /** @internal */
-export function signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node, flags: TypeFormatFlags = TypeFormatFlags.None, verbosityLevel?: number, out?: WriterContextOut): SymbolDisplayPart[] {
+export function signatureToDisplayParts(
+    typechecker: TypeChecker,
+    signature: Signature,
+    enclosingDeclaration?: Node,
+    flags: TypeFormatFlags = TypeFormatFlags.None,
+    maximumLength?: number,
+    verbosityLevel?: number,
+    out?: WriterContextOut,
+): SymbolDisplayPart[] {
     flags |= TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | TypeFormatFlags.MultilineObjectLiterals | TypeFormatFlags.WriteTypeArgumentsOfSignature | TypeFormatFlags.OmitParameterModifiers;
     return mapToDisplayParts(writer => {
-        typechecker.writeSignature(signature, enclosingDeclaration, flags, /*kind*/ undefined, writer, verbosityLevel, out);
-    });
+        typechecker.writeSignature(signature, enclosingDeclaration, flags, /*kind*/ undefined, writer, maximumLength, verbosityLevel, out);
+    }, maximumLength);
 }
 
 /** @internal */