implement extended code actions with snippet support

fix: bump minimal supported vscode version to 1.72.0 to support code actions with snippets

Author: zardoy

package.json

@@ -111,7 +111,7 @@
         "@types/fs-extra": "^9.0.13",
         "@types/node": "^16.11.21",
         "@types/semver": "^7.3.13",
-        "@types/vscode": "^1.63.1",
+        "@types/vscode": "1.72.0",
         "@zardoy/tsconfig": "^1.3.1",
         "esbuild": "^0.16.16",
         "fs-extra": "^10.1.0",

pnpm-lock.yaml

@@ -8,7 +8,10 @@ type SendCommandData<K> = {
     document?: vscode.TextDocument
     inputOptions?: K
 }
-export const sendCommand = async <T, K = any>(command: TriggerCharacterCommand, sendCommandDataArg?: SendCommandData<K>): Promise<T | undefined> => {
+export const sendCommand = async <Response, K = any>(
+    command: TriggerCharacterCommand,
+    sendCommandDataArg?: SendCommandData<K>,
+): Promise<Response | undefined> => {
     // plugin id disabled, languageService would not understand the special trigger character
     if (!getExtensionSetting('enablePlugin')) {
         console.warn('Ignoring request because plugin is disabled')

src/sendCommand.ts

@@ -1,3 +1,4 @@
+/* eslint-disable unicorn/consistent-destructuring */
 import * as vscode from 'vscode'
 import { getActiveRegularEditor } from '@zardoy/vscode-utils'
 import { getExtensionCommandId, getExtensionSetting, registerExtensionCommand, VSCodeQuickPickItem } from 'vscode-framework'
@@ -9,7 +10,15 @@ import { offsetPosition } from '@zardoy/vscode-utils/build/position'
 import { relative, join } from 'path-browserify'
 import { RequestOptionsTypes, RequestResponseTypes } from '../typescript/src/ipcTypes'
 import { sendCommand } from './sendCommand'
-import { getTsLikePath, pickFileWithQuickPick, tsRangeToVscode, tsRangeToVscodeSelection, tsTextChangesToVcodeTextEdits } from './util'
+import {
+    getTsLikePath,
+    pickFileWithQuickPick,
+    tsRangeToVscode,
+    tsRangeToVscodeSelection,
+    tsTextChangesToVscodeSnippetTextEdits,
+    tsTextChangesToVscodeTextEdits,
+    vscodeRangeToTs,
+} from './util'
 
 export default () => {
     registerExtensionCommand('removeFunctionArgumentsTypesInSelection', async () => {
@@ -227,7 +236,7 @@ export default () => {
             document,
             position: range.start,
             inputOptions: {
-                range: [document.offsetAt(range.start), document.offsetAt(range.end)] as [number, number],
+                range: vscodeRangeToTs(document, range),
             },
         })
     }
@@ -239,7 +248,7 @@ export default () => {
                 document,
                 position: range.start,
                 inputOptions: {
-                    range: [document.offsetAt(range.start), document.offsetAt(range.end)] as [number, number],
+                    range: vscodeRangeToTs(document, range),
                     data: secondStepData,
                 },
             },
@@ -343,10 +352,12 @@ export default () => {
         }
 
         if (!mainChanges) return
-        edit.set(editor.document.uri, tsTextChangesToVcodeTextEdits(editor.document, mainChanges))
+        edit.set(editor.document.uri, tsTextChangesToVscodeTextEdits(editor.document, mainChanges))
         await vscode.workspace.applyEdit(edit)
     })
 
+    type ExtendedCodeAction = vscode.CodeAction & { document: vscode.TextDocument; requestRange: vscode.Range }
+
     // most probably will be moved to ts-code-actions extension
     vscode.languages.registerCodeActionsProvider(defaultJsSupersetLangsWithVue, {
         async provideCodeActions(document, range, context, token) {
@@ -355,18 +366,20 @@ export default () => {
             }
 
             if (context.only?.contains(vscode.CodeActionKind.SourceFixAll)) {
-                const fixAllEdits = await sendCommand<RequestResponseTypes['getFixAllEdits']>('getFixAllEdits')
-                if (!fixAllEdits) return
+                const fixAllEdits = await sendCommand<RequestResponseTypes['getFixAllEdits']>('getFixAllEdits', {
+                    document,
+                })
+                if (!fixAllEdits || token.isCancellationRequested) return
                 const edit = new vscode.WorkspaceEdit()
-                edit.set(document.uri, tsTextChangesToVcodeTextEdits(document, fixAllEdits))
+                edit.set(document.uri, tsTextChangesToVscodeTextEdits(document, fixAllEdits))
                 await vscode.workspace.applyEdit(edit)
                 return
             }
 
             if (context.triggerKind !== vscode.CodeActionTriggerKind.Invoke) return
             const result = await getPossibleTwoStepRefactorings(range)
             if (!result) return
-            const { turnArrayIntoObject, moveToExistingFile } = result
+            const { turnArrayIntoObject, moveToExistingFile, extendedCodeActions } = result
             const codeActions: vscode.CodeAction[] = []
             const getCommand = (arg): vscode.Command | undefined => ({
                 title: '',
@@ -390,8 +403,55 @@ export default () => {
                 // })
             }
 
+            codeActions.push(
+                ...compact(
+                    extendedCodeActions.map(({ title, kind, codes }): ExtendedCodeAction | undefined => {
+                        let diagnostics: vscode.Diagnostic[] | undefined
+                        if (codes) {
+                            diagnostics = context.diagnostics.filter(({ source, code }) => {
+                                if (source !== 'ts' || !code) return
+                                const codeNumber = +(typeof code === 'object' ? code.value : code)
+                                return codes.includes(codeNumber)
+                            })
+                            if (diagnostics.length === 0) return
+                        }
+
+                        return {
+                            title,
+                            diagnostics,
+                            kind: vscode.CodeActionKind.Empty.append(kind),
+                            requestRange: range,
+                            document,
+                        }
+                    }),
+                ),
+            )
+
             return codeActions
         },
+        async resolveCodeAction(codeAction: ExtendedCodeAction, token) {
+            const { document } = codeAction
+            if (!document) throw new Error('Unresolved code action without document')
+            const result = await sendCommand<RequestResponseTypes['getExtendedCodeActionEdits'], RequestOptionsTypes['getExtendedCodeActionEdits']>(
+                'getExtendedCodeActionEdits',
+                {
+                    document,
+                    inputOptions: {
+                        applyCodeActionTitle: codeAction.title,
+                        range: vscodeRangeToTs(document, codeAction.diagnostics?.length ? codeAction.diagnostics[0]!.range : codeAction.requestRange),
+                    },
+                },
+            )
+            if (!result) throw new Error('No code action edits. Try debug.')
+            const { edits = [], snippetEdits = [] } = result
+            const workspaceEdit = new vscode.WorkspaceEdit()
+            workspaceEdit.set(document.uri, [
+                ...tsTextChangesToVscodeTextEdits(document, edits),
+                ...tsTextChangesToVscodeSnippetTextEdits(document, snippetEdits),
+            ])
+            codeAction.edit = workspaceEdit
+            return codeAction
+        },
     })
     // #endregion
 }

src/specialCommands.ts

@@ -12,7 +12,7 @@ export const tsRangeToVscode = (document: vscode.TextDocument, [start, end]: [nu
 export const tsRangeToVscodeSelection = (document: vscode.TextDocument, [start, end]: [number, number]) =>
     new vscode.Selection(document.positionAt(start), document.positionAt(end))
 
-export const tsTextChangesToVcodeTextEdits = (document: vscode.TextDocument, edits: Array<import('typescript').TextChange>): vscode.TextEdit[] =>
+export const tsTextChangesToVscodeTextEdits = (document: vscode.TextDocument, edits: Array<import('typescript').TextChange>): vscode.TextEdit[] =>
     edits.map(({ span, newText }) => {
         const start = document.positionAt(span.start)
         return {
@@ -21,6 +21,18 @@ export const tsTextChangesToVcodeTextEdits = (document: vscode.TextDocument, edi
         }
     })
 
+export const tsTextChangesToVscodeSnippetTextEdits = (document: vscode.TextDocument, edits: Array<import('typescript').TextChange>): vscode.SnippetTextEdit[] =>
+    edits.map(({ span, newText }) => {
+        const start = document.positionAt(span.start)
+        return {
+            range: new vscode.Range(start, offsetPosition(document, start, span.length)),
+            snippet: new vscode.SnippetString(newText),
+        }
+    })
+
+export const vscodeRangeToTs = (document: vscode.TextDocument, range: vscode.Range) =>
+    [document.offsetAt(range.start), document.offsetAt(range.end)] as [number, number]
+
 export const getTsLikePath = <T extends vscode.Uri | undefined>(uri: T): T extends undefined ? undefined : string =>
     uri && (normalizeWindowPath(uri.fsPath) as any)
 

src/util.ts

@@ -5,7 +5,7 @@ export default {
     name: 'Split Declaration and Initialization',
     id: 'splitDeclarationAndInitialization',
     kind: 'refactor.rewrite.split-declaration-and-initialization',
-    tryToApply(sourceFile, position, range, node, formatOptions, languageService, languageServiceHost) {
+    tryToApply(sourceFile, position, range, node, formatOptions, languageService) {
         if (range || !node) return
         if (!ts.isVariableDeclarationList(node) || node.declarations.length !== 1) return
         const declaration = node.declarations[0]!

typescript/src/codeActions/custom/splitDeclarationAndInitialization.ts

@@ -0,0 +1,49 @@
+import { ExtendedCodeAction } from '../getCodeActions'
+
+export default {
+    codes: [2339],
+    kind: 'quickfix',
+    title: 'Declare missing property',
+    tryToApply({ sourceFile, node }) {
+        if (node && ts.isIdentifier(node) && ts.isObjectBindingPattern(node.parent.parent) && ts.isParameter(node.parent.parent.parent)) {
+            const param = node.parent.parent.parent
+            // special react pattern
+            if (ts.isArrowFunction(param.parent) && ts.isVariableDeclaration(param.parent.parent)) {
+                const variableDecl = param.parent.parent
+                if (variableDecl.type?.getText().match(/(React\.)?FC/)) {
+                    // handle interface
+                }
+            }
+            // general patterns
+            if (param.type && ts.isTypeLiteralNode(param.type) && param.type.members) {
+                const hasMembers = param.type.members.length !== 0
+                const insertPos = param.type.members.at(-1)?.end ?? param.type.end - 1
+                const insertComma = hasMembers && sourceFile.getFullText().slice(insertPos - 1, insertPos) !== ','
+                let insertText = node.text
+                if (insertComma) insertText = `, ${insertText}`
+                // alternatively only one snippetEdit could be used with tsFull.escapeSnippetText(insertText) + $0
+                return {
+                    edits: [
+                        {
+                            newText: insertText,
+                            span: {
+                                length: 0,
+                                start: insertPos,
+                            },
+                        },
+                    ],
+                    snippetEdits: [
+                        {
+                            newText: '$0',
+                            span: {
+                                length: 0,
+                                start: insertPos + insertText.length - 1,
+                            },
+                        },
+                    ],
+                }
+            }
+        }
+        return
+    },
+} as ExtendedCodeAction