Add functionality to convert a ReferenceType into a "minimal" TypeNode

This is the TypeNode representation of a ReferenceType that includes
the minimal number of typeArguments that are still semantically equivalent
to the full type.

Also use this functionality in the isolatedDeclaration autofixer to
fix #58449

Author: blickly

src/compiler/checker.ts

@@ -1640,6 +1640,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         getBaseTypeOfLiteralType,
         getWidenedType,
         getWidenedLiteralType,
+        fillMissingTypeArguments,
         getTypeFromTypeNode: nodeIn => {
             const node = getParseTreeNode(nodeIn, isTypeNode);
             return node ? getTypeFromTypeNode(node) : errorType;

src/compiler/types.ts

@@ -5031,6 +5031,9 @@ export interface TypeCheckerHost extends ModuleSpecifierResolutionHost {
 }
 
 export interface TypeChecker {
+    
+    /** @internal */
+    fillMissingTypeArguments(typeArguments: readonly Type[], typeParameters: readonly TypeParameter[] | undefined, minTypeArgumentCount: number, isJavaScriptImplicitAny: boolean): Type[];
     getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;
     getTypeOfSymbol(symbol: Symbol): Type;
     getDeclaredTypeOfSymbol(symbol: Symbol): Type;

src/services/codefixes/fixMissingTypeAnnotationOnExports.ts

@@ -5,7 +5,8 @@ import {
     eachDiagnostic,
     registerCodeFix,
     typePredicateToAutoImportableTypeNode,
-    typeToAutoImportableTypeNode,
+    typeToMinimizedReferenceType,
+    typeNodeToAutoImportableTypeNode,
 } from "../_namespaces/ts.codefix.js";
 import {
     ArrayBindingPattern,
@@ -1096,9 +1097,9 @@ function withContext<T>(
         return emptyInferenceResult;
     }
 
-    function typeToTypeNode(type: Type, enclosingDeclaration: Node, flags = NodeBuilderFlags.None) {
+    function typeToTypeNode(type: Type, enclosingDeclaration: Node, flags = NodeBuilderFlags.None): TypeNode|undefined {
         let isTruncated = false;
-        const result = typeToAutoImportableTypeNode(typeChecker, importAdder, type, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags | flags, declarationEmitInternalNodeBuilderFlags, {
+        const minimizedTypeNode = typeToMinimizedReferenceType(typeChecker, type, enclosingDeclaration, declarationEmitNodeBuilderFlags | flags, declarationEmitInternalNodeBuilderFlags, {
             moduleResolverHost: program,
             trackSymbol() {
                 return true;
@@ -1107,6 +1108,10 @@ function withContext<T>(
                 isTruncated = true;
             },
         });
+        if (!minimizedTypeNode) {
+            return undefined;
+        }
+        const result = typeNodeToAutoImportableTypeNode(minimizedTypeNode, importAdder, scriptTarget);
         return isTruncated ? factory.createKeywordTypeNode(SyntaxKind.AnyKeyword) : result;
     }
 

src/services/codefixes/helpers.ts

@@ -23,6 +23,7 @@ import {
     flatMap,
     FunctionDeclaration,
     FunctionExpression,
+    GenericType,
     GetAccessorDeclaration,
     getAllAccessorDeclarations,
     getCheckFlags,
@@ -59,6 +60,8 @@ import {
     isSetAccessorDeclaration,
     isStringLiteral,
     isTypeNode,
+    isTypeReferenceNode,
+    TypeReferenceNode,
     isTypeUsableAsPropertyName,
     isYieldExpression,
     LanguageServiceHost,
@@ -595,7 +598,15 @@ function createTypeParameterName(index: number) {
 
 /** @internal */
 export function typeToAutoImportableTypeNode(checker: TypeChecker, importAdder: ImportAdder, type: Type, contextNode: Node | undefined, scriptTarget: ScriptTarget, flags?: NodeBuilderFlags, internalFlags?: InternalNodeBuilderFlags, tracker?: SymbolTracker): TypeNode | undefined {
-    let typeNode = checker.typeToTypeNode(type, contextNode, flags, internalFlags, tracker);
+    const typeNode = checker.typeToTypeNode(type, contextNode, flags, internalFlags, tracker);
+    if (!typeNode) {
+        return undefined;
+    }
+    return typeNodeToAutoImportableTypeNode(typeNode, importAdder, scriptTarget);
+}
+
+/** @internal */
+export function typeNodeToAutoImportableTypeNode(typeNode: TypeNode, importAdder: ImportAdder, scriptTarget: ScriptTarget): TypeNode | undefined {
     if (typeNode && isImportTypeNode(typeNode)) {
         const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
         if (importableReference) {
@@ -608,6 +619,43 @@ export function typeToAutoImportableTypeNode(checker: TypeChecker, importAdder:
     return getSynthesizedDeepClone(typeNode);
 }
 
+function endOfRequiredTypeParameters(checker: TypeChecker, type: GenericType, fullTypeArguments: readonly Type[]) : number {
+    if (fullTypeArguments !== type.typeArguments!) {
+        throw new Error('fullTypeArguments should be set')
+    }
+    const target = type.target;
+    next_cutoff: for (let cutoff = 0; cutoff < fullTypeArguments.length; cutoff++) {
+        const typeArguments = fullTypeArguments.slice(0, cutoff);
+        const filledIn = checker.fillMissingTypeArguments(typeArguments, target.typeParameters, cutoff, /*isJavaScriptImplicitAny*/ false);
+        for (let i = 0; i < filledIn.length; i++) {
+            // If they don't match, then we haven't yet reached the right cutoff
+            if (filledIn[i] !== fullTypeArguments[i]) continue next_cutoff;
+        }
+        return cutoff;
+    }
+    // If we make it all the way here, all the type arguments are required.
+    return fullTypeArguments.length;
+    }
+
+export function typeToMinimizedReferenceType(checker: TypeChecker, type: Type, contextNode: Node | undefined, flags?: NodeBuilderFlags, internalFlags?: InternalNodeBuilderFlags, tracker?: SymbolTracker): TypeNode | undefined {
+    const typeNode = checker.typeToTypeNode(type, contextNode, flags, internalFlags, tracker);
+    if (!typeNode) {
+        return undefined;
+    }
+    if (isTypeReferenceNode(typeNode)) {
+        const genericType = type as GenericType;
+        if (genericType.typeArguments) {
+            const cutoff = endOfRequiredTypeParameters(checker, genericType, genericType.typeArguments);
+            if (cutoff !== undefined && typeNode.typeArguments) {
+                // Looks like the wrong way to do this. What APIs should I use here?
+                (typeNode as any).typeArguments = typeNode.typeArguments.slice(0, cutoff);
+            }
+        }
+
+    }
+    return typeNode;
+}
+
 /** @internal */
 export function typePredicateToAutoImportableTypeNode(checker: TypeChecker, importAdder: ImportAdder, typePredicate: TypePredicate, contextNode: Node | undefined, scriptTarget: ScriptTarget, flags?: NodeBuilderFlags, internalFlags?: InternalNodeBuilderFlags, tracker?: SymbolTracker): TypeNode | undefined {
     let typePredicateNode = checker.typePredicateToTypePredicateNode(typePredicate, contextNode, flags, internalFlags, tracker);