feat: add configurable typeHierarchyMaxResults preference

- Add typeHierarchyMaxResults to UserPreferences (default: 1000)
- Update type hierarchy API to accept preferences parameter
- Pass preferences through services.ts and session.ts
- Use configurable limit in getSubtypes for performance control
- Document in PR_DESCRIPTION.md

Author: kbrilla

PR_DESCRIPTION.md

@@ -66,15 +66,18 @@ Types are annotated with descriptive `kindModifiers` to help distinguish differe
    - `resolveTypeHierarchyDeclaration()` - Entry point for type hierarchy requests
    - `createTypeHierarchyItem()` - Creates hierarchy items with proper metadata
    - `getSupertypes()` - Collects base types, implemented interfaces, and type parameter constraints
-   - `getSubtypes()` - Finds derived types using hybrid approach with performance limits
+   - `getSubtypes()` - Finds derived types using hybrid approach with configurable limits
    - `getTypeHierarchyKindModifiers()` - Returns modifiers based on type pattern
    - `findMixinVariablesUsingSymbol()` - Reverse mixin lookup
    - `collectTypeParameterConstraints()` - Collects type parameter constraints as supertypes
 
-2. **`src/harness/fourslashImpl.ts`** (modified)
+2. **`src/compiler/types.ts`** (modified)
+   - Added `typeHierarchyMaxResults` to `UserPreferences` for configurable result limits
+
+3. **`src/harness/fourslashImpl.ts`** (modified)
    - Added `kindModifiers` display in type hierarchy baselines
 
-3. **Test Files** (27 new fourslash tests)
+4. **Test Files** (27 new fourslash tests)
    - Comprehensive coverage of all supported patterns
    - Multi-file tests for cross-file scenarios
    - Edge case and negative case testing
@@ -187,7 +190,8 @@ Conditional types like `ExtractDog<T> = T extends Dog ? T : never` are shown as
 - **AST Traversal**: Avoided when possible; uses targeted lookups
 - **Seen Sets**: Prevents duplicate processing
 - **Cancellation Tokens**: Supports responsiveness during long operations
-- **Results Limit**: Subtype collection is capped at 1000 results per level to prevent issues in very large codebases
+- **Results Limit**: Subtype collection is capped at a configurable limit (default: 1000) to prevent performance issues in very large codebases
+- **Configurable via `UserPreferences.typeHierarchyMaxResults`**: The limit can be adjusted per-request
 
 ## Known Limitations
 
@@ -198,10 +202,10 @@ Conditional types like `ExtractDog<T> = T extends Dog ? T : never` are shown as
 
 ## Future Enhancements
 
+- [ ] **Truncation indicator** - Show indicator when results exceed the configured limit
 - [ ] Handle more complex generic type inference
 - [ ] Show inferred type widening in hierarchy
 - [ ] Enhanced cross-project reference support
-- [ ] Add truncation indicator when results exceed limit
 
 ---
 

src/compiler/types.ts

@@ -10564,6 +10564,14 @@ export interface UserPreferences {
      * Default: `500`
      */
     readonly maximumHoverLength?: number;
+    /**
+     * Maximum number of results to return per level in type hierarchy requests.
+     * A positive integer limiting the number of supertypes/subtypes returned to prevent
+     * performance issues in very large codebases.
+     *
+     * Default: `1000`
+     */
+    readonly typeHierarchyMaxResults?: number;
 }
 
 export type OrganizeImportsTypeOrder = "last" | "inline" | "first";

src/server/session.ts

@@ -3416,14 +3416,14 @@ export class Session<TMessage = string> implements EventSender {
     private provideTypeHierarchySupertypes(args: protocol.FileLocationRequestArgs): protocol.TypeHierarchyItem[] {
         const { file, project } = this.getFileAndProject(args);
         const scriptInfo = this.getScriptInfoFromProjectService(file);
-        const supertypes = project.getLanguageService().provideTypeHierarchySupertypes(file, this.getPosition(args, scriptInfo));
+        const supertypes = project.getLanguageService().provideTypeHierarchySupertypes(file, this.getPosition(args, scriptInfo), this.getPreferences(file));
         return supertypes.map(item => this.toProtocolTypeHierarchyItem(item));
     }
 
     private provideTypeHierarchySubtypes(args: protocol.FileLocationRequestArgs): protocol.TypeHierarchyItem[] {
         const { file, project } = this.getFileAndProject(args);
         const scriptInfo = this.getScriptInfoFromProjectService(file);
-        const subtypes = project.getLanguageService().provideTypeHierarchySubtypes(file, this.getPosition(args, scriptInfo));
+        const subtypes = project.getLanguageService().provideTypeHierarchySubtypes(file, this.getPosition(args, scriptInfo), this.getPreferences(file));
         return subtypes.map(item => this.toProtocolTypeHierarchyItem(item));
     }
 

src/services/services.ts

@@ -3375,18 +3375,18 @@ export function createLanguageService(
         return position === 0 ? sourceFile : getTouchingPropertyName(sourceFile, position);
     }
 
-    function provideTypeHierarchySupertypes(fileName: string, position: number): TypeHierarchyItem[] {
+    function provideTypeHierarchySupertypes(fileName: string, position: number, preferences: UserPreferences = emptyOptions): TypeHierarchyItem[] {
         synchronizeHostData();
         const sourceFile = getValidSourceFile(fileName);
         const declaration = TypeHierarchy.resolveTypeHierarchyDeclaration(program, getTypeHierarchyNodeAtPosition(sourceFile, position));
-        return declaration ? TypeHierarchy.getSupertypes(program, declaration, cancellationToken) : [];
+        return declaration ? TypeHierarchy.getSupertypes(program, declaration, cancellationToken, preferences) : [];
     }
 
-    function provideTypeHierarchySubtypes(fileName: string, position: number): TypeHierarchyItem[] {
+    function provideTypeHierarchySubtypes(fileName: string, position: number, preferences: UserPreferences = emptyOptions): TypeHierarchyItem[] {
         synchronizeHostData();
         const sourceFile = getValidSourceFile(fileName);
         const declaration = TypeHierarchy.resolveTypeHierarchyDeclaration(program, getTypeHierarchyNodeAtPosition(sourceFile, position));
-        return declaration ? TypeHierarchy.getSubtypes(program, declaration, cancellationToken) : [];
+        return declaration ? TypeHierarchy.getSubtypes(program, declaration, cancellationToken, preferences) : [];
     }
 
     function provideInlayHints(fileName: string, span: TextSpan, preferences: UserPreferences = emptyOptions): InlayHint[] {

src/services/typeHierarchy.ts

@@ -43,9 +43,13 @@ import {
     TypeHierarchyItem,
     TypeReference,
     TypeReferenceNode,
+    UserPreferences,
     VariableDeclaration,
 } from "./_namespaces/ts.js";
 
+/** Default maximum results per level in type hierarchy */
+const DEFAULT_TYPE_HIERARCHY_MAX_RESULTS = 1000;
+
 /** @internal */
 export type TypeHierarchyDeclaration =
     | ClassDeclaration
@@ -410,9 +414,12 @@ function getSymbolFromHeritageClauseType(typeNode: ExpressionWithTypeArguments,
  *
  * @internal
  */
-export function getSupertypes(program: Program, declaration: TypeHierarchyDeclaration, _cancellationToken: CancellationToken): TypeHierarchyItem[] {
+export function getSupertypes(program: Program, declaration: TypeHierarchyDeclaration, _cancellationToken: CancellationToken, _preferences?: UserPreferences): TypeHierarchyItem[] {
     const typeChecker = program.getTypeChecker();
     const result: TypeHierarchyItem[] = [];
+    // Note: maxResults is not used for supertypes as they are naturally limited
+    // (a class has one base class plus some interfaces). The preference is accepted
+    // for API consistency with getSubtypes.
 
     if (isClassDeclaration(declaration) || isClassExpression(declaration)) {
         // Get base class
@@ -678,10 +685,11 @@ function addTypeReferenceToResult(
  *
  * @internal
  */
-export function getSubtypes(program: Program, declaration: TypeHierarchyDeclaration, cancellationToken: CancellationToken): TypeHierarchyItem[] {
+export function getSubtypes(program: Program, declaration: TypeHierarchyDeclaration, cancellationToken: CancellationToken, preferences?: UserPreferences): TypeHierarchyItem[] {
     const typeChecker = program.getTypeChecker();
     const result: TypeHierarchyItem[] = [];
     const seen = new Set<TypeHierarchyDeclaration>();
+    const maxResults = preferences?.typeHierarchyMaxResults ?? DEFAULT_TYPE_HIERARCHY_MAX_RESULTS;
 
     // Get the name node - for assigned class expressions and mixin variables, use the variable name
     let locationNode: Node | undefined;
@@ -705,9 +713,6 @@ export function getSubtypes(program: Program, declaration: TypeHierarchyDeclarat
         return result;
     }
 
-    // Maximum number of subtypes to return for performance
-    const maxResults = 1000;
-
     // PART 1: Use FindAllReferences with { implementations: true } for heritage clauses
     // This efficiently finds classes/interfaces that extend/implement the target using the name index
     const entries = FindAllReferences.getReferenceEntriesForNode(

src/services/types.ts

@@ -627,8 +627,8 @@ export interface LanguageService {
     provideCallHierarchyOutgoingCalls(fileName: string, position: number): CallHierarchyOutgoingCall[];
 
     prepareTypeHierarchy(fileName: string, position: number): TypeHierarchyItem | TypeHierarchyItem[] | undefined;
-    provideTypeHierarchySupertypes(fileName: string, position: number): TypeHierarchyItem[];
-    provideTypeHierarchySubtypes(fileName: string, position: number): TypeHierarchyItem[];
+    provideTypeHierarchySupertypes(fileName: string, position: number, preferences?: UserPreferences): TypeHierarchyItem[];
+    provideTypeHierarchySubtypes(fileName: string, position: number, preferences?: UserPreferences): TypeHierarchyItem[];
 
     provideInlayHints(fileName: string, span: TextSpan, preferences: UserPreferences | undefined): InlayHint[];