Account for type parameters in missing function codefix

Author: JoshuaKGoldberg

src/services/codefixes/helpers.ts

@@ -295,20 +295,19 @@ namespace ts.codefix {
         const contextualType = isJs ? undefined : checker.getContextualType(call);
         const names = map(args, arg =>
             isIdentifier(arg) ? arg.text : isPropertyAccessExpression(arg) && isIdentifier(arg.name) ? arg.name.text : undefined);
-        const types = isJs ? [] : map(args, arg =>
-            typeToAutoImportableTypeNode(checker, importAdder, checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(arg)), contextNode, scriptTarget, /*flags*/ undefined, tracker));
+        const instanceTypes = isJs ? [] : map(args, arg => checker.getTypeAtLocation(arg));
+        const { argumentTypeNodes, argumentTypeParameters } = getArgumentTypesAndTypeParameters(
+            checker, importAdder, instanceTypes, contextNode, scriptTarget, /*flags*/ undefined, tracker
+        );
 
         const modifiers = modifierFlags
             ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags))
             : undefined;
         const asteriskToken = isYieldExpression(parent)
             ? factory.createToken(SyntaxKind.AsteriskToken)
             : undefined;
-        const typeParameters = isJs || typeArguments === undefined
-            ? undefined
-            : map(typeArguments, (_, i) =>
-                factory.createTypeParameterDeclaration(/*modifiers*/ undefined, CharacterCodes.T + typeArguments.length - 1 <= CharacterCodes.Z ? String.fromCharCode(CharacterCodes.T + i) : `T${i}`));
-        const parameters = createDummyParameters(args.length, names, types, /*minArgumentCount*/ undefined, isJs);
+        const typeParameters = isJs ? undefined : createTypeParametersForArguments(argumentTypeParameters, typeArguments);
+        const parameters = createDummyParameters(args.length, names, argumentTypeNodes, /*minArgumentCount*/ undefined, isJs);
         const type = isJs || contextualType === undefined
             ? undefined
             : checker.typeToTypeNode(contextualType, contextNode, /*flags*/ undefined, tracker);
@@ -349,7 +348,28 @@ namespace ts.codefix {
         }
     }
 
-    export function typeToAutoImportableTypeNode(checker: TypeChecker, importAdder: ImportAdder, type: Type, contextNode: Node | undefined, scriptTarget: ScriptTarget, flags?: NodeBuilderFlags, tracker?: SymbolTracker): TypeNode | undefined {
+    function createTypeParametersForArguments(argumentTypeParameters: string[], typeArguments: NodeArray<TypeNode> | undefined) {
+        const usedNames = new Set(argumentTypeParameters);
+
+        if (typeArguments) {
+            for (let i = 0, targetSize = usedNames.size + typeArguments.length; usedNames.size < targetSize; i += 1) {
+                usedNames.add(
+                    CharacterCodes.T + i <= CharacterCodes.Z
+                        ? String.fromCharCode(CharacterCodes.T + i)
+                        : `T${i}`
+                );
+            }
+        }
+
+        return map(
+            arrayFrom(usedNames.values()),
+            (usedName) => factory.createTypeParameterDeclaration(/*modifiers*/ undefined, usedName),
+        );
+    }
+
+    export function typeToAutoImportableTypeNode(checker: TypeChecker, importAdder: ImportAdder, instanceType: Type, contextNode: Node | undefined, scriptTarget: ScriptTarget, flags?: NodeBuilderFlags, tracker?: SymbolTracker): TypeNode | undefined {
+        // Widen the type so we don't emit nonsense annotations like "function fn(x: 3) {"
+        const type = checker.getBaseTypeOfLiteralType(instanceType);
         let typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker);
         if (typeNode && isImportTypeNode(typeNode)) {
             const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
@@ -362,6 +382,42 @@ namespace ts.codefix {
         return getSynthesizedDeepClone(typeNode);
     }
 
+    export function getArgumentTypesAndTypeParameters(checker: TypeChecker, importAdder: ImportAdder, instanceTypes: Type[], contextNode: Node | undefined, scriptTarget: ScriptTarget, flags?: NodeBuilderFlags, tracker?: SymbolTracker) {
+        const argumentTypeNodes: TypeNode[] = [];
+        const argumentTypeParameters = new Set<string>();
+
+        for (const instanceType of instanceTypes) {
+            const argumentTypeNode = typeToAutoImportableTypeNode(checker, importAdder, instanceType, contextNode, scriptTarget, flags, tracker);
+            if (!argumentTypeNode) {
+                continue;
+            }
+
+            argumentTypeNodes.push(argumentTypeNode);
+            const argumentTypeParameter = getFirstTypeParameterName(instanceType);
+
+            if (argumentTypeParameter) {
+                argumentTypeParameters.add(argumentTypeParameter);
+            }
+        }
+
+        return { argumentTypeNodes, argumentTypeParameters: arrayFrom(argumentTypeParameters.values()) };
+    }
+
+    function getFirstTypeParameterName(type: Type): string | undefined {
+        if (type.flags & TypeFlags.Intersection) {
+            for (const subType of (type as IntersectionType).types) {
+                const subTypeName = getFirstTypeParameterName(subType);
+                if (subTypeName) {
+                    return subTypeName;
+                }
+            }
+        }
+
+        return type.flags & TypeFlags.TypeParameter
+            ? type.getSymbol()?.getName()
+            : undefined;
+    }
+
     function createDummyParameters(argCount: number, names: (string | undefined)[] | undefined, types: (TypeNode | undefined)[] | undefined, minArgumentCount: number | undefined, inJs: boolean): ParameterDeclaration[] {
         const parameters: ParameterDeclaration[] = [];
         for (let i = 0; i < argCount; i++) {

src/services/refactors/extractSymbol.ts

@@ -878,13 +878,16 @@ namespace ts.refactor.extractSymbol {
         const callArguments: Identifier[] = [];
         let writes: UsageEntry[] | undefined;
         usagesInScope.forEach((usage, name) => {
-            let typeNode: TypeNode | undefined;
-            if (!isJS) {
-                let type = checker.getTypeOfSymbolAtLocation(usage.symbol, usage.node);
-                // Widen the type so we don't emit nonsense annotations like "function fn(x: 3) {"
-                type = checker.getBaseTypeOfLiteralType(type);
-                typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, type, scope, scriptTarget, NodeBuilderFlags.NoTruncation);
-            }
+            const typeNode = isJS
+                ? undefined
+                : codefix.typeToAutoImportableTypeNode(
+                    checker,
+                    importAdder,
+                    checker.getTypeOfSymbolAtLocation(usage.symbol, usage.node),
+                    scope,
+                    scriptTarget,
+                    NodeBuilderFlags.NoTruncation,
+                );
 
             const paramDecl = factory.createParameterDeclaration(
                 /*modifiers*/ undefined,

tests/cases/fourslash/incompleteFunctionCallCodefixTypeKeyof.ts

@@ -0,0 +1,22 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+////function existing<T>(value: T) {
+////  const keyofTypeof = Object.keys(value)[0] as keyof T;
+////  added/*1*/(value);
+////}
+
+goTo.marker("1");
+verify.codeFix({
+  description: "Add missing function declaration 'added'",
+  index: 0,
+  newFileContent: `function existing<T>(value: T) {
+  const keyofTypeof = Object.keys(value)[0] as keyof T;
+  added(value);
+}
+
+function added<T>(value: T) {
+    throw new Error("Function not implemented.");
+}
+`,
+});

tests/cases/fourslash/incompleteFunctionCallCodefixTypeParameter.ts

@@ -0,0 +1,20 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+////function existing<T>(value: T) {
+////  added/*1*/(value);
+////}
+
+goTo.marker("1");
+verify.codeFix({
+  description: "Add missing function declaration 'added'",
+  index: 0,
+  newFileContent: `function existing<T>(value: T) {
+  added(value);
+}
+
+function added<T>(value: T) {
+    throw new Error("Function not implemented.");
+}
+`,
+});

tests/cases/fourslash/incompleteFunctionCallCodefixTypeParameterConstrained.ts

@@ -0,0 +1,20 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+////function existing<T extends string>(value: T) {
+////  added/*1*/(value);
+////}
+
+goTo.marker("1");
+verify.codeFix({
+  description: "Add missing function declaration 'added'",
+  index: 0,
+  newFileContent: `function existing<T extends string>(value: T) {
+  added(value);
+}
+
+function added<T>(value: T) {
+    throw new Error("Function not implemented.");
+}
+`,
+});

tests/cases/fourslash/incompleteFunctionCallCodefixTypeParameterNarrowed.ts

@@ -0,0 +1,24 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+////function existing<T>(value: T) {
+////  if (typeof value === "number") {
+////    added/*1*/(value);
+////  }
+////}
+
+goTo.marker("1");
+verify.codeFix({
+  description: "Add missing function declaration 'added'",
+  index: 0,
+  newFileContent: `function existing<T>(value: T) {
+  if (typeof value === "number") {
+    added(value);
+  }
+}
+
+function added<T>(value: T & number) {
+    throw new Error("Function not implemented.");
+}
+`,
+});

tests/cases/fourslash/incompleteFunctionCallCodefixTypeParameters.ts

@@ -0,0 +1,20 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+////function existing<T1, T, T2>(t1: T1, t: T, t2a: T2, t2b: T2, t2c: T2) {
+////  added/*1*/(t2a, t2b, t2c, t1, t, t2a, t2c, t2b);
+////}
+
+goTo.marker("1");
+verify.codeFix({
+  description: "Add missing function declaration 'added'",
+  index: 0,
+  newFileContent: `function existing<T1, T, T2>(t1: T1, t: T, t2a: T2, t2b: T2, t2c: T2) {
+  added(t2a, t2b, t2c, t1, t, t2a, t2c, t2b);
+}
+
+function added<T2, T1, T>(t2a: T2, t2b: T2, t2c: T2, t1: T1, t: T, t2a: T2, t2c: T2, t2b: T2) {
+    throw new Error("Function not implemented.");
+}
+`,
+});

tests/cases/fourslash/incompleteFunctionCallCodefixTypeParametersConstrained.ts

@@ -0,0 +1,20 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+////function existing<T extends string, U extends T>(value: T, other: U) {
+////  added/*1*/(value, other);
+////}
+
+goTo.marker("1");
+verify.codeFix({
+  description: "Add missing function declaration 'added'",
+  index: 0,
+  newFileContent: `function existing<T extends string, U extends T>(value: T, other: U) {
+  added(value, other);
+}
+
+function added<T, U>(value: T, other: U) {
+    throw new Error("Function not implemented.");
+}
+`,
+});

tests/cases/fourslash/incompleteFunctionCallCodefixTypeParametersNested2D.ts

@@ -0,0 +1,24 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+////function outer<O>(o: O) {
+////  return function inner<I>(i: I) {
+////    added/*1*/(o, i);
+////  }
+////}
+
+goTo.marker("1");
+verify.codeFix({
+  description: "Add missing function declaration 'added'",
+  index: 0,
+  newFileContent: `function outer<O>(o: O) {
+  return function inner<I>(i: I) {
+    added(o, i);
+  }
+}
+
+function added<O, I>(o: O, i: I) {
+    throw new Error("Function not implemented.");
+}
+`,
+});

tests/cases/fourslash/incompleteFunctionCallCodefixTypeParametersNested3D.ts

@@ -0,0 +1,28 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitAny: true
+////function outer<O>(o: O) {
+////  return function middle<M>(m: M) {
+////    return function inner<I>(i: I) {
+////      added/*1*/(o, m, i);
+////    }
+////  }
+////}
+
+goTo.marker("1");
+verify.codeFix({
+  description: "Add missing function declaration 'added'",
+  index: 0,
+  newFileContent: `function outer<O>(o: O) {
+  return function middle<M>(m: M) {
+    return function inner<I>(i: I) {
+      added(o, m, i);
+    }
+  }
+}
+
+function added<O, M, I>(o: O, m: M, i: I) {
+    throw new Error("Function not implemented.");
+}
+`,
+});