feat(26217): Add missing function declaration QF

Author: a-tarasyuk

src/compiler/diagnosticMessages.json

@@ -5955,6 +5955,15 @@
         "category": "Message",
         "code": 95144
     },
+    "Add missing function declaration '{0}'": {
+        "category": "Message",
+        "code": 95145
+    },
+    "Add all missing function declarations": {
+        "category": "Message",
+        "code": 95146
+    },
+
 
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",

src/services/codefixes/fixAddMissingMember.ts

@@ -247,41 +247,51 @@ namespace ts.codefix {
         );
     }
 
-    export function createMethodFromCallExpression(
+    export function createFunctionFromCallExpression<T extends FunctionDeclaration | MethodDeclaration>(
+        kind: T["kind"] | SyntaxKind.MethodDeclaration,
         context: CodeFixContextBase,
         importAdder: ImportAdder,
         call: CallExpression,
-        methodName: string,
+        name: Identifier | string,
         modifierFlags: ModifierFlags,
-        contextNode: Node,
-        inJs: boolean
-    ): MethodDeclaration {
-        const body = !isInterfaceDeclaration(contextNode);
-        const { typeArguments, arguments: args, parent } = call;
+        contextNode: Node
+    ): T {
+        const quotePreference = getQuotePreference(context.sourceFile, context.preferences);
         const scriptTarget = getEmitScriptTarget(context.program.getCompilerOptions());
-        const checker = context.program.getTypeChecker();
         const tracker = getNoopSymbolTrackerWithResolver(context);
-        const types = map(args, arg =>
-            typeToAutoImportableTypeNode(checker, importAdder, checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(arg)), contextNode, scriptTarget, /*flags*/ undefined, tracker));
+        const checker = context.program.getTypeChecker();
+        const isJs = isInJSFile(contextNode);
+        const { typeArguments, arguments: args, parent } = call;
+
+        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 contextualType = checker.getContextualType(call);
-        const returnType = (inJs || !contextualType) ? undefined : checker.typeToTypeNode(contextualType, contextNode, /*flags*/ undefined, tracker);
-        const quotePreference = getQuotePreference(context.sourceFile, context.preferences);
-        return factory.createMethodDeclaration(
-            /*decorators*/ undefined,
-            /*modifiers*/ modifierFlags ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags)) : undefined,
-            /*asteriskToken*/ isYieldExpression(parent) ? factory.createToken(SyntaxKind.AsteriskToken) : undefined,
-            methodName,
-            /*questionToken*/ undefined,
-            /*typeParameters*/ inJs ? undefined : map(typeArguments, (_, i) =>
-                factory.createTypeParameterDeclaration(CharacterCodes.T + typeArguments!.length - 1 <= CharacterCodes.Z ? String.fromCharCode(CharacterCodes.T + i) : `T${i}`)),
-            /*parameters*/ createDummyParameters(args.length, names, types, /*minArgumentCount*/ undefined, inJs),
-            /*type*/ returnType,
-            body ? createStubbedMethodBody(quotePreference) : undefined);
+        const types = isJs ? [] : map(args, arg =>
+            typeToAutoImportableTypeNode(checker, importAdder, checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(arg)), 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(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 type = isJs || contextualType === undefined
+            ? undefined
+            : checker.typeToTypeNode(contextualType, contextNode, /*flags*/ undefined, tracker);
+
+        if (kind === SyntaxKind.MethodDeclaration) {
+            const body = isInterfaceDeclaration(contextNode) ? undefined : createStubbedMethodBody(quotePreference);
+            return factory.createMethodDeclaration(/*decorators*/ undefined, modifiers, asteriskToken, name, /*questionToken*/ undefined, typeParameters, parameters, type, body) as T;
+        }
+        return factory.createFunctionDeclaration(/*decorators*/ undefined, modifiers, asteriskToken, name, typeParameters, parameters, type, createStubbedBody("Function not implemented.", quotePreference)) as T;
     }
 
-    export function typeToAutoImportableTypeNode(checker: TypeChecker, importAdder: ImportAdder, type: Type, contextNode: Node, scriptTarget: ScriptTarget, flags?: NodeBuilderFlags, tracker?: SymbolTracker): TypeNode | undefined {
+    export function typeToAutoImportableTypeNode(checker: TypeChecker, importAdder: ImportAdder, type: Type, contextNode: Node | undefined, scriptTarget: ScriptTarget, flags?: NodeBuilderFlags, tracker?: SymbolTracker): TypeNode | undefined {
         const typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker);
         if (typeNode && isImportTypeNode(typeNode)) {
             const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
@@ -381,14 +391,18 @@ namespace ts.codefix {
             createStubbedMethodBody(quotePreference));
     }
 
-    function createStubbedMethodBody(quotePreference: QuotePreference): Block {
+    function createStubbedMethodBody(quotePreference: QuotePreference) {
+        return createStubbedBody("Method not implemented.", quotePreference);
+    }
+
+    export function createStubbedBody(text: string, quotePreference: QuotePreference): Block {
         return factory.createBlock(
             [factory.createThrowStatement(
                 factory.createNewExpression(
                     factory.createIdentifier("Error"),
                     /*typeArguments*/ undefined,
                     // TODO Handle auto quote preference.
-                    [factory.createStringLiteral("Method not implemented.", /*isSingleQuote*/ quotePreference === QuotePreference.Single)]))],
+                    [factory.createStringLiteral(text, /*isSingleQuote*/ quotePreference === QuotePreference.Single)]))],
             /*multiline*/ true);
     }
 

src/services/codefixes/helpers.ts

@@ -2,4 +2,14 @@
 
 ////[x, y()] = [0, () => 1];
 
-verify.not.codeFixAvailable();
+verify.codeFix({
+    index: 0,
+    description: [ts.Diagnostics.Add_missing_function_declaration_0.message, "y"],
+    newFileContent:
+`[x, y()] = [0, () => 1];
+
+function y() {
+    throw new Error("Function not implemented.");
+}
+`
+});

tests/cases/fourslash/codeFixAddMissingConstToArrayDestructuring4.ts

@@ -0,0 +1,15 @@
+/// <reference path='fourslash.ts' />
+
+////foo();
+
+verify.codeFix({
+    index: 0,
+    description: [ts.Diagnostics.Add_missing_function_declaration_0.message, "foo"],
+    newFileContent:
+`foo();
+
+function foo() {
+    throw new Error("Function not implemented.");
+}
+`
+});

tests/cases/fourslash/codeFixAddMissingFunctionDeclaration1.ts

@@ -0,0 +1,22 @@
+/// <reference path='fourslash.ts' />
+
+////namespace Foo {
+////    export const x = 0;
+////}
+////
+////Foo.test<string, number>();
+
+verify.codeFix({
+    index: 0,
+    description: [ts.Diagnostics.Add_missing_function_declaration_0.message, "test"],
+    newFileContent:
+`namespace Foo {
+    export const x = 0;
+
+    export function test<T, U>() {
+        throw new Error("Function not implemented.");
+    }
+}
+
+Foo.test<string, number>();`
+});

tests/cases/fourslash/codeFixAddMissingFunctionDeclaration10.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts' />
+
+// @filename: /test.ts
+////export const x = 1;
+
+// @filename: /foo.ts
+////import * as test from "./test";
+////test.foo();
+
+goTo.file("/foo.ts");
+verify.codeFix({
+    index: 0,
+    description: [ts.Diagnostics.Add_missing_function_declaration_0.message, "foo"],
+    newFileContent: {
+        "/test.ts":
+`export const x = 1;
+
+export function foo() {
+    throw new Error("Function not implemented.");
+}
+`
+    }
+});

tests/cases/fourslash/codeFixAddMissingFunctionDeclaration11.ts

@@ -0,0 +1,28 @@
+/// <reference path='fourslash.ts' />
+
+// @filename: /test.ts
+////export const x = 1;
+
+// @filename: /foo.ts
+////import * as test from "./test";
+////test.foo();
+////test.foo();
+////test.foo();
+
+goTo.file("/foo.ts");
+verify.codeFix({
+    index: 0,
+    description: [ts.Diagnostics.Add_missing_function_declaration_0.message, "foo"],
+    applyChanges: true,
+    newFileContent: {
+        "/test.ts":
+`export const x = 1;
+
+export function foo() {
+    throw new Error("Function not implemented.");
+}
+`
+    }
+});
+
+verify.not.codeFixAvailable();

tests/cases/fourslash/codeFixAddMissingFunctionDeclaration12.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts' />
+
+// @filename: /test.ts
+////export const x = 1;
+
+// @filename: /foo.ts
+////import * as test from "./test";
+////test.foo(1, "", { x: 1, y: 1 });
+
+goTo.file("/foo.ts");
+verify.codeFix({
+    index: 0,
+    description: [ts.Diagnostics.Add_missing_function_declaration_0.message, "foo"],
+    newFileContent: {
+        "/test.ts":
+`export const x = 1;
+
+export function foo(arg0: number, arg1: string, arg2: { x: number; y: number; }) {
+    throw new Error("Function not implemented.");
+}
+`
+    }
+});

tests/cases/fourslash/codeFixAddMissingFunctionDeclaration13.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts' />
+
+// @filename: /test.ts
+////export const x = 1;
+
+// @filename: /foo.ts
+////import * as test from "./test";
+////const foo: string = test.foo();
+
+goTo.file("/foo.ts");
+verify.codeFix({
+    index: 0,
+    description: [ts.Diagnostics.Add_missing_function_declaration_0.message, "foo"],
+    newFileContent: {
+        "/test.ts":
+`export const x = 1;
+
+export function foo(): string {
+    throw new Error("Function not implemented.");
+}
+`
+    }
+});