remove addFunctionDeclarationFromSignature. fix formatting

a-tarasyuk · a-tarasyuk · commit 6927c19a5539 · 2022-07-29T13:53:47.000+03:00
diff --git a/src/services/codefixes/fixAddMissingMember.ts b/src/services/codefixes/fixAddMissingMember.ts
@@ -15,6 +15,15 @@ namespace ts.codefix {
         Diagnostics.Cannot_find_name_0.code
     ];
 
+    enum InfoKind {
+        TypeLikeDeclaration,
+        Enum,
+        Function,
+        ObjectLiteral,
+        JsxAttributes,
+        Signature,
+    }
+
     registerCodeFix({
         errorCodes,
         getCodeActions(context) {
@@ -32,8 +41,7 @@ namespace ts.codefix {
                 return [createCodeFixAction(fixMissingAttributes, changes, Diagnostics.Add_missing_attributes, fixMissingAttributes, Diagnostics.Add_all_missing_attributes)];
             }
             if (info.kind === InfoKind.Function || info.kind === InfoKind.Signature) {
-                const changes = textChanges.ChangeTracker.with(context, t =>
-                    info.kind === InfoKind.Signature ? addFunctionDeclarationFromSignature(t, context, info) : addFunctionDeclaration(t, context, info));
+                const changes = textChanges.ChangeTracker.with(context, t => addFunctionDeclaration(t, context, info));
                 return [createCodeFixAction(fixMissingFunctionDeclaration, changes, [Diagnostics.Add_missing_function_declaration_0, info.token.text], fixMissingFunctionDeclaration, Diagnostics.Add_all_missing_function_declarations)];
             }
             if (info.kind === InfoKind.Enum) {
@@ -56,12 +64,7 @@ namespace ts.codefix {
                         return;
                     }
                     if (fixId === fixMissingFunctionDeclaration && (info.kind === InfoKind.Function || info.kind === InfoKind.Signature)) {
-                        if (info.kind === InfoKind.Signature) {
-                            addFunctionDeclarationFromSignature(changes, context, info);
-                        }
-                        else {
-                            addFunctionDeclaration(changes, context, info);
-                        }
+                        addFunctionDeclaration(changes, context, info);
                     }
                     else if (fixId === fixMissingProperties && info.kind === InfoKind.ObjectLiteral) {
                         addObjectLiteralProperties(changes, context, info);
@@ -112,7 +115,6 @@ namespace ts.codefix {
         },
     });
 
-    const enum InfoKind { TypeLikeDeclaration, Enum, Function, ObjectLiteral, JsxAttributes, Signature }
     type Info = TypeLikeDeclarationInfo | EnumInfo | FunctionInfo | ObjectLiteralInfo | JsxAttributesInfo | SignatureInfo;
 
     interface EnumInfo {
@@ -137,7 +139,7 @@ namespace ts.codefix {
         readonly token: Identifier;
         readonly sourceFile: SourceFile;
         readonly modifierFlags: ModifierFlags;
-        readonly parentDeclaration: SourceFile | ModuleDeclaration;
+        readonly parentDeclaration: SourceFile | ModuleDeclaration | ReturnStatement;
     }
 
     interface ObjectLiteralInfo {
@@ -208,10 +210,10 @@ namespace ts.codefix {
             if (type && getObjectFlags(type) & ObjectFlags.Anonymous) {
                 const signature = firstOrUndefined(checker.getSignaturesOfType(type, SignatureKind.Call));
                 if (signature === undefined) return undefined;
-                return { kind: InfoKind.Signature, token, signature, sourceFile, parentDeclaration: token.parent };
+                return { kind: InfoKind.Signature, token, signature, sourceFile, parentDeclaration: findScope(token) };
             }
             if (isCallExpression(parent)) {
-                return { kind: InfoKind.Function, token, call: parent, sourceFile, modifierFlags: ModifierFlags.None, parentDeclaration: sourceFile };
+                return { kind: InfoKind.Function, token, call: parent, sourceFile, modifierFlags: ModifierFlags.None, parentDeclaration: findScope(token) };
             }
         }
 
@@ -472,28 +474,19 @@ namespace ts.codefix {
         });
     }
 
-    function addFunctionDeclaration(changes: textChanges.ChangeTracker, context: CodeFixContextBase, info: FunctionInfo) {
-        const importAdder = createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
-        const functionDeclaration = createSignatureDeclarationFromCallExpression(SyntaxKind.FunctionDeclaration, context, importAdder, info.call, idText(info.token), info.modifierFlags, info.parentDeclaration) as FunctionDeclaration;
-        changes.insertNodeAtEndOfScope(info.sourceFile, info.parentDeclaration, functionDeclaration);
-        importAdder.writeFixes(changes);
-    }
-
-    function addFunctionDeclarationFromSignature(changes: textChanges.ChangeTracker, context: CodeFixContextBase, info: SignatureInfo) {
+    function addFunctionDeclaration(changes: textChanges.ChangeTracker, context: CodeFixContextBase, info: FunctionInfo | SignatureInfo) {
         const quotePreference = getQuotePreference(context.sourceFile, context.preferences);
         const importAdder = createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
-        const functionDeclaration = createSignatureDeclarationFromSignature(SyntaxKind.FunctionExpression, context, quotePreference, info.signature,
-            createStubbedBody(Diagnostics.Function_not_implemented.message, quotePreference), info.token, /*modifiers*/ undefined, /*optional*/ undefined, /*enclosingDeclaration*/ undefined, importAdder);
+        const functionDeclaration = info.kind === InfoKind.Function
+            ? createSignatureDeclarationFromCallExpression(SyntaxKind.FunctionDeclaration, context, importAdder, info.call, idText(info.token), info.modifierFlags, info.parentDeclaration)
+            : createSignatureDeclarationFromSignature(SyntaxKind.FunctionDeclaration, context, quotePreference, info.signature, createStubbedBody(Diagnostics.Function_not_implemented.message, quotePreference), info.token, /*modifiers*/ undefined, /*optional*/ undefined, /*enclosingDeclaration*/ undefined, importAdder);
         if (functionDeclaration === undefined) {
             Debug.fail("fixMissingFunctionDeclaration codefix got unexpected error.");
         }
-        const returnStatement = isJsxExpression(info.parentDeclaration) ? findAncestor(info.parentDeclaration, isReturnStatement) : undefined;
-        if (returnStatement) {
-            changes.insertNodeBefore(info.sourceFile, returnStatement, functionDeclaration, /*blankLineBetween*/ true);
-        }
-        else {
-            changes.insertNodeAtEndOfScope(info.sourceFile, info.sourceFile, functionDeclaration);
-        }
+
+        isReturnStatement(info.parentDeclaration)
+            ? changes.insertNodeBefore(info.sourceFile, info.parentDeclaration, functionDeclaration, /*blankLineBetween*/ true)
+            : changes.insertNodeAtEndOfScope(info.sourceFile, info.parentDeclaration, functionDeclaration);
         importAdder.writeFixes(changes);
     }
 
@@ -657,4 +650,12 @@ namespace ts.codefix {
         }
         return createPropertyNameNodeForIdentifierOrLiteral(symbol.name, target, quotePreference === QuotePreference.Single);
     }
+
+    function findScope(node: Node) {
+        if (findAncestor(node, isJsxExpression)) {
+            const returnStatement = findAncestor(node.parent, isReturnStatement);
+            if (returnStatement) return returnStatement;
+        }
+        return getSourceFileOfNode(node);
+    }
 }
diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts
@@ -169,13 +169,17 @@ namespace ts.codefix {
         }
 
         function outputMethod(quotePreference: QuotePreference, signature: Signature, modifiers: NodeArray<Modifier> | undefined, name: PropertyName, body?: Block): void {
-            const method = createSignatureDeclarationFromSignature(SyntaxKind.MethodDeclaration, context, quotePreference, signature, body, name, modifiers, optional && !!(preserveOptional & PreserveOptionalFlags.Method), enclosingDeclaration, importAdder);
+            const method = createSignatureDeclarationFromSignature(SyntaxKind.MethodDeclaration, context, quotePreference, signature, body, name, modifiers, optional && !!(preserveOptional & PreserveOptionalFlags.Method), enclosingDeclaration, importAdder) as MethodDeclaration;
             if (method) addClassElement(method);
         }
     }
 
     export function createSignatureDeclarationFromSignature(
-        kind: SyntaxKind.MethodDeclaration | SyntaxKind.FunctionExpression | SyntaxKind.ArrowFunction,
+        kind:
+            | SyntaxKind.MethodDeclaration
+            | SyntaxKind.FunctionExpression
+            | SyntaxKind.ArrowFunction
+            | SyntaxKind.FunctionDeclaration,
         context: TypeConstructionContext,
         quotePreference: QuotePreference,
         signature: Signature,
@@ -194,7 +198,7 @@ namespace ts.codefix {
             | NodeBuilderFlags.SuppressAnyReturnType
             | NodeBuilderFlags.AllowEmptyTuple
             | (quotePreference === QuotePreference.Single ? NodeBuilderFlags.UseSingleQuotesForStringLiteralType : NodeBuilderFlags.None);
-        const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context)) as ArrowFunction | FunctionExpression | MethodDeclaration;
+        const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context)) as ArrowFunction | FunctionExpression | MethodDeclaration | FunctionDeclaration;
         if (!signatureDeclaration) {
             return undefined;
         }
@@ -273,6 +277,9 @@ namespace ts.codefix {
         if (isMethodDeclaration(signatureDeclaration)) {
             return factory.updateMethodDeclaration(signatureDeclaration, modifiers, asteriskToken, name ?? factory.createIdentifier(""), questionToken, typeParameters, parameters, type, body);
         }
+        if (isFunctionDeclaration(signatureDeclaration)) {
+            return factory.updateFunctionDeclaration(signatureDeclaration, modifiers, signatureDeclaration.asteriskToken, tryCast(name, isIdentifier), typeParameters, parameters, type, body ?? signatureDeclaration.body);
+        }
         return undefined;
     }
 
diff --git a/tests/cases/fourslash/codeFixAddMissingFunctionDeclaration23.ts b/tests/cases/fourslash/codeFixAddMissingFunctionDeclaration23.ts
@@ -0,0 +1,21 @@
+/// <reference path="fourslash.ts" />
+
+// @jsx: preserve
+// @filename: foo.tsx
+
+////const A = () => {
+////    return (<div onClick={() => handleClick()}></div>);
+////}
+
+verify.codeFix({
+    index: 0,
+    description: [ts.Diagnostics.Add_missing_function_declaration_0.message, "handleClick"],
+    newFileContent:
+`const A = () => {
+    function handleClick() {
+        throw new Error("Function not implemented.");
+    }
+
+    return (<div onClick={() => handleClick()}></div>);
+}`
+});

Original file line number	Diff line number	Diff line change
`@@ -169,13 +169,17 @@ namespace ts.codefix {`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`function outputMethod(quotePreference: QuotePreference, signature: Signature, modifiers: NodeArray<Modifier> \| undefined, name: PropertyName, body?: Block): void {`
`172`		`- const method = createSignatureDeclarationFromSignature(SyntaxKind.MethodDeclaration, context, quotePreference, signature, body, name, modifiers, optional && !!(preserveOptional & PreserveOptionalFlags.Method), enclosingDeclaration, importAdder);`
	`172`	`+ const method = createSignatureDeclarationFromSignature(SyntaxKind.MethodDeclaration, context, quotePreference, signature, body, name, modifiers, optional && !!(preserveOptional & PreserveOptionalFlags.Method), enclosingDeclaration, importAdder) as MethodDeclaration;`
`173`	`173`	`if (method) addClassElement(method);`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`export function createSignatureDeclarationFromSignature(`
`178`		`- kind: SyntaxKind.MethodDeclaration \| SyntaxKind.FunctionExpression \| SyntaxKind.ArrowFunction,`
	`178`	`+ kind:`
	`179`	`+ \| SyntaxKind.MethodDeclaration`
	`180`	`+ \| SyntaxKind.FunctionExpression`
	`181`	`+ \| SyntaxKind.ArrowFunction`
	`182`	`+ \| SyntaxKind.FunctionDeclaration,`
`179`	`183`	`context: TypeConstructionContext,`
`180`	`184`	`quotePreference: QuotePreference,`
`181`	`185`	`signature: Signature,`
`@@ -194,7 +198,7 @@ namespace ts.codefix {`
`194`	`198`	`\| NodeBuilderFlags.SuppressAnyReturnType`
`195`	`199`	`\| NodeBuilderFlags.AllowEmptyTuple`
`196`	`200`	`\| (quotePreference === QuotePreference.Single ? NodeBuilderFlags.UseSingleQuotesForStringLiteralType : NodeBuilderFlags.None);`
`197`		`- const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context)) as ArrowFunction \| FunctionExpression \| MethodDeclaration;`
	`201`	`+ const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context)) as ArrowFunction \| FunctionExpression \| MethodDeclaration \| FunctionDeclaration;`
`198`	`202`	`if (!signatureDeclaration) {`
`199`	`203`	`return undefined;`
`200`	`204`	`}`
`@@ -273,6 +277,9 @@ namespace ts.codefix {`
`273`	`277`	`if (isMethodDeclaration(signatureDeclaration)) {`
`274`	`278`	`return factory.updateMethodDeclaration(signatureDeclaration, modifiers, asteriskToken, name ?? factory.createIdentifier(""), questionToken, typeParameters, parameters, type, body);`
`275`	`279`	`}`
	`280`	`+ if (isFunctionDeclaration(signatureDeclaration)) {`
	`281`	`+ return factory.updateFunctionDeclaration(signatureDeclaration, modifiers, signatureDeclaration.asteriskToken, tryCast(name, isIdentifier), typeParameters, parameters, type, body ?? signatureDeclaration.body);`
	`282`	`+ }`
`276`	`283`	`return undefined;`
`277`	`284`	`}`
`278`	`285`