microsoft · jakebailey · Sep 16, 2024 · Jul 25, 2024 · Aug 8, 2024 · Aug 8, 2024
diff --git a/src/compiler/checker.ts b/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;

diff --git a/src/compiler/types.ts b/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;

diff --git a/src/services/codefixes/fixMissingTypeAnnotationOnExports.ts b/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;
     }
 

diff --git a/src/services/codefixes/helpers.ts b/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);

diff --git a/tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports50-generics-with-default.ts b/tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports50-generics-with-default.ts
@@ -0,0 +1,17 @@
+/// <reference path='fourslash.ts'/>
+
+// @isolatedDeclarations: true
+// @declaration: true
+// @file lib.d.ts
+////interface MyIterator<T, TReturn = any, TNext = undefined> {}
+////let x: MyIterator<number>;
+////export const y = x;
+
+verify.codeFix({
+    description: "Add annotation of type 'MyIterator<number>'",
+    index: 0,
+    newFileContent:
+`interface MyIterator<T, TReturn = any, TNext = undefined> {}
+let x: MyIterator<number>;
+export const y: MyIterator<number> = x;`,
+});
diff --git a/...sh/codeFixMissingTypeAnnotationOnExports51-slightly-more-complex-generics-with-default.ts b/...sh/codeFixMissingTypeAnnotationOnExports51-slightly-more-complex-generics-with-default.ts
@@ -0,0 +1,19 @@
+/// <reference path='fourslash.ts'/>
+
+// @isolatedDeclarations: true
+// @declaration: true
+
+////export interface Foo<T, U = T[]> {}
+////export function foo(x: Foo<string>) {
+////    return x;
+////}
+
+verify.codeFix({
+    description: "Add return type 'Foo<string>'",
+    index: 0,
+    newFileContent:
+`export interface Foo<T, U = T[]> {}
+export function foo(x: Foo<string>): Foo<string> {
+    return x;
+}`,
+});
diff --git a/...s/cases/fourslash/codeFixMissingTypeAnnotationOnExports52-gerenrics-oversimplification.ts b/...s/cases/fourslash/codeFixMissingTypeAnnotationOnExports52-gerenrics-oversimplification.ts
@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts'/>
+
+// In the abstract, we might prefer the inferred return type annotation to
+// be identical to the parameter type (with 2 type parameters).
+// Our current heursitic to avoid overly complex types in this case creates
+// "overly simple" types, but this tradeoff seems reasonable.
+
+// @isolatedDeclarations: true
+// @declaration: true
+////export interface Foo<T, U = T[]> {}
+////export function foo(x: Foo<string, string[]>) {
+////    return x;
+////}
+
+verify.codeFix({
+    description: "Add return type 'Foo<string>'",
+    index: 0,
+    newFileContent:
+`export interface Foo<T, U = T[]> {}
+export function foo(x: Foo<string, string[]>): Foo<string> {
+    return x;
+}`,
+});
diff --git a/tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports53-nested-generic-types.ts b/tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports53-nested-generic-types.ts
@@ -0,0 +1,21 @@
+/// <reference path='fourslash.ts'/>
+
+// Our current heursitic to avoid overly verbose generic types
+// doesn't handle generic types nested inside other types.
+
+// @isolatedDeclarations: true
+// @declaration: true
+////export interface Foo<T, U = T[]> {}
+////export function foo(x: Map<number, Foo<string>>) {
+////    return x;
+////}
+
+verify.codeFix({
+    description: "Add return type 'Map<number, Foo<string, string[]>>'",
+    index: 0,
+    newFileContent:
+`export interface Foo<T, U = T[]> {}
+export function foo(x: Map<number, Foo<string>>): Map<number, Foo<string, string[]>> {
+    return x;
+}`,
+});