Drop unnecessary type arguments in the isolated declarations quick fix

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

@@ -5394,6 +5394,7 @@ export interface TypeChecker {
  /** @internal */ isTypeParameterPossiblyReferenced(tp: TypeParameter, node: Node): boolean;
  /** @internal */ typeHasCallOrConstructSignatures(type: Type): boolean;
  /** @internal */ getSymbolFlags(symbol: Symbol): SymbolFlags;
+ /** @internal */ fillMissingTypeArguments(typeArguments: readonly Type[], typeParameters: readonly TypeParameter[] | undefined, minTypeArgumentCount: number, isJavaScriptImplicitAny: boolean): Type[];
 }
 
 /** @internal */

src/services/codefixes/fixMissingTypeAnnotationOnExports.ts

@@ -4,8 +4,9 @@ import {
  createImportAdder,
  eachDiagnostic,
  registerCodeFix,
+ typeNodeToAutoImportableTypeNode,
  typePredicateToAutoImportableTypeNode,
-typeToAutoImportableTypeNode,
+typeToMinimizedReferenceType,
 } 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,7 @@ import {
  isSetAccessorDeclaration,
  isStringLiteral,
  isTypeNode,
+ isTypeReferenceNode,
  isTypeUsableAsPropertyName,
  isYieldExpression,
  LanguageServiceHost,
@@ -595,7 +597,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 +618,40 @@ export function typeToAutoImportableTypeNode(checker: TypeChecker, importAdder:
  return getSynthesizedDeepClone(typeNode);
 }
 
+function endOfRequiredTypeParameters(checker: TypeChecker, type: GenericType): number {
+ Debug.assert(type.typeArguments);
+ const fullTypeArguments = type.typeArguments;
+ const target = type.target;
+ for (let cutoff = 0; cutoff < fullTypeArguments.length; cutoff++) {
+ const typeArguments = fullTypeArguments.slice(0, cutoff);
+ const filledIn = checker.fillMissingTypeArguments(typeArguments, target.typeParameters, cutoff, /*isJavaScriptImplicitAny*/ false);
+ if (filledIn.every((fill, i) => fill === fullTypeArguments[i])) {
+ return cutoff;
+ }
+ }
+ // If we make it all the way here, all the type arguments are required.
+ return fullTypeArguments.length;
+}
+
+/** @internal */
+export function typeToMinimizedReferenceType(checker: TypeChecker, type: Type, contextNode: Node | undefined, flags?: NodeBuilderFlags, internalFlags?: InternalNodeBuilderFlags, tracker?: SymbolTracker): TypeNode | undefined {
+ let typeNode = checker.typeToTypeNode(type, contextNode, flags, internalFlags, tracker);
+ if (!typeNode) {
+ return undefined;
+ }
+ if (isTypeReferenceNode(typeNode)) {
+ const genericType = type as GenericType;
+ if (genericType.typeArguments && typeNode.typeArguments) {
+ const cutoff = endOfRequiredTypeParameters(checker, genericType);
+ if (cutoff < typeNode.typeArguments.length) {
+ const newTypeArguments = factory.createNodeArray(typeNode.typeArguments.slice(0, cutoff));
+ typeNode = factory.updateTypeReferenceNode(typeNode, typeNode.typeName, newTypeArguments);
+ }
+ }
+ }
+ 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);

tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports50-generics-with-default.ts

@@ -0,0 +1,15 @@
+/// <reference path='fourslash.ts'/>
+
+// @isolatedDeclarations: true
+// @declaration: true
+// @lib: es2015
+////let x: Iterator<number>;
+////export const y = x;
+
+verify.codeFix({
+ description: "Add annotation of type 'Iterator<number>'",
+ index: 0,
+ newFileContent:
+`let x: Iterator<number>;
+export const y: Iterator<number> = x;`,
+});

tests/cases/fourslash/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;
+}`,
+});

tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports52-generics-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 heuristic 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;
+}`,
+});

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;
+}`,
+});

tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports54-generator-generics.ts

@@ -0,0 +1,17 @@
+/// <reference path='fourslash.ts'/>
+
+// @isolatedDeclarations: true
+// @declaration: true
+// @lib: es2015
+//// export function foo(x: Generator<number>) {
+//// return x;
+//// }
+
+verify.codeFix({
+ description: "Add return type 'Generator<number>'",
+ index: 0,
+ newFileContent:
+`export function foo(x: Generator<number>): Generator<number> {
+ return x;
+}`
+});

tests/cases/fourslash/codeFixMissingTypeAnnotationOnExports55-generator-return.ts

@@ -0,0 +1,17 @@
+/// <reference path='fourslash.ts'/>
+
+// @isolatedDeclarations: true
+// @declaration: true
+// @lib: es2015
+//// export function *foo() {
+//// yield 5;
+//// }
+
+verify.codeFix({
+ description: "Add return type 'Generator<number, void, unknown>'",
+ index: 0,
+ newFileContent:
+`export function *foo(): Generator<number, void, unknown> {
+ yield 5;
+}`
+});