feat(codeAction): rename parameter to name from type (#107)

Author: Ilanaya

typescript/src/codeActions/custom/renameParameterToNameFromType.ts

@@ -0,0 +1,110 @@
+import { pipe, groupBy, map, compact } from 'lodash/fp'
+import { CodeAction } from '../getCodeActions'
+import extractType from '../../utils/extractType'
+
+const getTypeParamName = (parameterName: string, parameterIndex: number, functionDeclaration: ts.Node, languageService: ts.LanguageService) => {
+    const typeChecker = languageService.getProgram()!.getTypeChecker()
+    const type = extractType(typeChecker, functionDeclaration)
+
+    const typeSignatureParams = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call)[0]?.parameters
+    if (!typeSignatureParams) return
+    const typeSignatureParam = typeSignatureParams[parameterIndex]
+    if (!typeSignatureParam) return
+    const typeParamName = typeSignatureParam.name
+    const isInternal = typeParamName.startsWith('__')
+    if (isInternal || parameterName === typeParamName) return
+
+    return typeParamName
+}
+
+const getEdits = (fileName: string, position: number, newText: string, languageService: ts.LanguageService): ts.FileTextChanges[] | undefined => {
+    const renameLocations = languageService.findRenameLocations(fileName, position, false, false, {})
+    if (!renameLocations) return
+
+    const extractFileName = ({ fileName }: ts.RenameLocation) => fileName
+
+    return pipe(
+        groupBy(extractFileName),
+        Object.entries,
+        map(
+            ([fileName, changes]): ts.FileTextChanges => ({
+                fileName,
+                textChanges: changes.map(
+                    ({ textSpan }): ts.TextChange => ({
+                        newText,
+                        span: textSpan,
+                    }),
+                ),
+            }),
+        ),
+    )(renameLocations)
+}
+
+export const renameParameterToNameFromType = {
+    id: 'renameParameterToNameFromType',
+    name: '',
+    kind: 'refactor.rewrite.renameParameterToNameFromType',
+    tryToApply(sourceFile, position, range, node, formatOptions, languageService) {
+        if (!node || !position) return
+        const functionSignature = node.parent.parent
+        if (
+            !ts.isIdentifier(node) ||
+            !ts.isParameter(node.parent) ||
+            !ts.isFunctionLike(functionSignature) ||
+            !ts.isVariableDeclaration(functionSignature.parent)
+        )
+            return
+        const { parent: functionDecl, parameters: functionParameters } = functionSignature
+
+        const parameterIndex = functionParameters.indexOf(node.parent)
+        const parameterName = functionParameters[parameterIndex]!.name.getText()
+        const typeParamName = getTypeParamName(parameterName, functionParameters.indexOf(node.parent), functionDecl, languageService)
+        if (!typeParamName) return
+        this.name = `Rename Parameter to Name from Type '${functionDecl.type!.getText()}'`
+        if (!formatOptions) return true
+
+        const edits = compact(getEdits(sourceFile.fileName, position, typeParamName, languageService))
+        return {
+            edits,
+        }
+    },
+} satisfies CodeAction
+
+export const renameAllParametersToNameFromType = {
+    id: 'renameAllParametersToNameFromType',
+    name: '',
+    kind: 'refactor.rewrite.renameAllParametersToNameFromType',
+    tryToApply(sourceFile, position, range, node, formatOptions, languageService) {
+        if (!node || !position) return
+        const functionSignature = node.parent.parent
+        if (
+            !ts.isIdentifier(node) ||
+            !ts.isParameter(node.parent) ||
+            !ts.isFunctionLike(functionSignature) ||
+            !ts.isVariableDeclaration(functionSignature.parent)
+        )
+            return
+        const { parent: functionDecl, parameters: functionParameters } = functionSignature
+        const paramsToRename = compact(
+            functionParameters.map((functionParameter, index) => {
+                const typeParamName = getTypeParamName(functionParameter.getText(), index, functionDecl, languageService)
+                if (!typeParamName) return
+                return { param: functionParameter, typeParamName }
+            }),
+        )
+
+        if (paramsToRename.length < 2) return
+
+        this.name = `Rename All Parameters to Name from Type '${functionDecl.type!.getText()}'`
+        if (!formatOptions) return true
+
+        const edits = compact(
+            paramsToRename.flatMap(({ param, typeParamName }) => {
+                return getEdits(sourceFile.fileName, param.getStart(), typeParamName, languageService)
+            }),
+        )
+        return {
+            edits,
+        }
+    },
+} satisfies CodeAction

typescript/src/codeActions/getCodeActions.ts

@@ -6,8 +6,15 @@ import objectSwapKeysAndValues from './custom/objectSwapKeysAndValues'
 import changeStringReplaceToRegex from './custom/changeStringReplaceToRegex'
 import splitDeclarationAndInitialization from './custom/splitDeclarationAndInitialization'
 import addMissingProperties from './extended/addMissingProperties'
+import { renameParameterToNameFromType, renameAllParametersToNameFromType } from './custom/renameParameterToNameFromType'
 
-const codeActions: CodeAction[] = [objectSwapKeysAndValues, changeStringReplaceToRegex, splitDeclarationAndInitialization]
+const codeActions: CodeAction[] = [
+    objectSwapKeysAndValues,
+    changeStringReplaceToRegex,
+    splitDeclarationAndInitialization,
+    renameParameterToNameFromType,
+    renameAllParametersToNameFromType,
+]
 const extendedCodeActions: ExtendedCodeAction[] = [addMissingProperties]
 
 type SimplifiedRefactorInfo =

typescript/src/constructMethodSnippet.ts

@@ -2,6 +2,7 @@ import { compact, oneOf } from '@zardoy/utils'
 import { isTypeNode } from './completions/keywordsSpace'
 import { GetConfig } from './types'
 import { findChildContainingExactPosition } from './utils'
+import extractType from './utils/extractType'
 
 // todo-low-ee inspect any last arg infer
 export default (
@@ -17,11 +18,9 @@ export default (
 ) => {
     let containerNode = findChildContainingExactPosition(sourceFile, position)
     if (!containerNode || isTypeNode(containerNode)) return
-
     const checker = languageService.getProgram()!.getTypeChecker()!
-    let type = symbol ? checker.getTypeOfSymbol(symbol) : checker.getTypeAtLocation(containerNode)
-    // give another chance
-    if (symbol && type['intrinsicName'] === 'error') type = checker.getTypeOfSymbolAtLocation(symbol, containerNode)
+
+    const type = extractType(checker, containerNode, symbol)
 
     if (ts.isIdentifier(containerNode)) containerNode = containerNode.parent
     if (ts.isPropertyAccessExpression(containerNode)) containerNode = containerNode.parent

typescript/src/utils/extractType.ts

@@ -0,0 +1,6 @@
+export default (typeChecker: ts.TypeChecker, node: ts.Node, symbol?: ts.Symbol) => {
+    const type = symbol ? typeChecker.getTypeOfSymbol(symbol) : typeChecker.getTypeAtLocation(node)
+    // give another chance
+    if (symbol && type['intrinsicName'] === 'error') return typeChecker.getTypeOfSymbolAtLocation(symbol, node)
+    return type
+}