fix: preserve passing formatOptions to TS completions

feat: new fix for builtin Code Fix on ctrl+s (fix all): add missing await now works correctly (only one async is added if have several awaits)

Author: zardoy

README.MD

@@ -164,7 +164,20 @@ Mark all TS code actions with `🔵`, so you can be sure they're coming from Typ
 type A<T extends 'foo' | 'bar' = ''> = ...
 ```
 
-### Builtin CodeFix Fixes
+### Builtin Code Fix Fixes
+
+With this plugin fixes some builtin code actions and these code fixes will work *correctly*:
+
+```ts
+// ctrl+s fix: only one async is added
+const syncFunction = () => {
+    await fetch()
+    await fetch()
+}
+const a = 5
+// const to let fix
+a = 6
+```
 
 ## Special Commands List
 

src/specialCommands.ts

@@ -8,7 +8,7 @@ import { defaultJsSupersetLangsWithVue } from '@zardoy/vscode-utils/build/langs'
 import { offsetPosition } from '@zardoy/vscode-utils/build/position'
 import { RequestOptionsTypes, RequestResponseTypes } from '../typescript/src/ipcTypes'
 import { sendCommand } from './sendCommand'
-import { tsRangeToVscode, tsRangeToVscodeSelection } from './util'
+import { tsRangeToVscode, tsRangeToVscodeSelection, tsTextChangesToVcodeTextEdits } from './util'
 
 export default () => {
     registerExtensionCommand('removeFunctionArgumentsTypesInSelection', async () => {
@@ -260,23 +260,27 @@ export default () => {
         const editor = vscode.window.activeTextEditor!
         const edits = await sendTurnIntoArrayRequest<RequestResponseTypes['turnArrayIntoObjectEdit']>(editor.selection, selectedKey)
         if (!edits) throw new Error('Unknown error. Try debug.')
-        await editor.edit(builder => {
-            for (const { span, newText } of edits) {
-                const start = editor.document.positionAt(span.start)
-                builder.replace(new vscode.Range(start, offsetPosition(editor.document, start, span.length)), newText)
-            }
-        })
+        const edit = new vscode.WorkspaceEdit()
+        edit.set(editor.document.uri, tsTextChangesToVcodeTextEdits(editor.document, edits))
+        await vscode.workspace.applyEdit(edit)
     })
 
     // its actually a code action, but will be removed from there soon
     vscode.languages.registerCodeActionsProvider(defaultJsSupersetLangsWithVue, {
         async provideCodeActions(document, range, context, token) {
-            if (
-                context.triggerKind !== vscode.CodeActionTriggerKind.Invoke ||
-                document !== vscode.window.activeTextEditor?.document ||
-                !getExtensionSetting('enablePlugin')
-            )
+            if (document !== vscode.window.activeTextEditor?.document || !getExtensionSetting('enablePlugin')) {
                 return
+            }
+
+            if (context.only?.contains(vscode.CodeActionKind.SourceFixAll)) {
+                const fixAllEdits = await sendCommand<RequestResponseTypes['getFixAllEdits']>('getFixAllEdits')
+                if (!fixAllEdits) return
+                const edit = new vscode.WorkspaceEdit()
+                edit.set(document.uri, tsTextChangesToVcodeTextEdits(document, fixAllEdits))
+                await vscode.workspace.applyEdit(edit)
+            }
+
+            if (context.triggerKind !== vscode.CodeActionTriggerKind.Invoke) return
             const result = await sendTurnIntoArrayRequest(range)
             if (!result) return
             const { keysCount, totalCount, totalObjectCount } = result

src/util.ts

@@ -1,7 +1,19 @@
+import { offsetPosition } from '@zardoy/vscode-utils/build/position'
+import ts from 'typescript'
 import * as vscode from 'vscode'
 
 export const tsRangeToVscode = (document: vscode.TextDocument, [start, end]: [number, number]) =>
     new vscode.Range(document.positionAt(start), document.positionAt(end))
 
 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: ts.TextChange[]): vscode.TextEdit[] => {
+    return edits.map(({ span, newText }) => {
+        const start = document.positionAt(span.start)
+        return {
+            range: new vscode.Range(start, offsetPosition(document, start, span.length)),
+            newText,
+        }
+    })
+}

typescript/src/codeFixes.ts

@@ -1,4 +1,3 @@
-import type tslib from 'typescript/lib/tsserverlibrary'
 import addMissingProperties from './codeFixes/addMissingProperties'
 import { GetConfig } from './types'
 import { findChildContainingPosition, getIndentFromPos } from './utils'
@@ -17,6 +16,10 @@ export default (proxy: ts.LanguageService, languageService: ts.LanguageService,
                 fix.changes[0]!.textChanges[0]!.span.start = start + length - fixedLength
                 fix.changes[0]!.textChanges[0]!.span.length = fixedLength
             }
+            // don't let it trigger on ctrl+s https://github.com/microsoft/vscode/blob/e8a3071ea4344d9d48ef8a4df2c097372b0c5161/extensions/typescript-language-features/src/languageFeatures/fixAll.ts#L142
+            if (fix.fixName === 'fixAwaitInSyncFunction') {
+                fix.fixName = 'fixedFixAwaitInSyncFunction'
+            }
             return fix
         })
         // #endregion

typescript/src/completions/markOrRemoveGlobalLibCompletions.ts

@@ -23,12 +23,12 @@ export default (entries: ts.CompletionEntry[], position: number, languageService
             if (action === 'remove') return undefined
             return {
                 ...entry,
-                sourceDisplay: [
-                    {
-                        kind: 'text',
-                        text: libCompletionEnding,
-                    },
-                ],
+                // TODO for some reason in member compl client (vscode) resolves it to [object Object] with labelDetails
+                insertText: entry.name,
+                labelDetails: {
+                    ...entry.labelDetails,
+                    description: libCompletionEnding,
+                },
             }
         }),
     )

typescript/src/completionsAtPosition.ts

@@ -1,5 +1,4 @@
 import _ from 'lodash'
-import type tslib from 'typescript/lib/tsserverlibrary'
 import inKeywordCompletions from './inKeywordCompletions'
 // import * as emmet from '@vscode/emmet-helper'
 import isInBannedPosition from './completions/isInBannedPosition'
@@ -32,7 +31,7 @@ export const getCompletionsAtPosition = (
     c: GetConfig,
     languageService: ts.LanguageService,
     scriptSnapshot: ts.IScriptSnapshot,
-    ts: typeof tslib,
+    formatOptions?: ts.FormatCodeSettings,
 ):
     | {
           completions: ts.CompletionInfo
@@ -45,7 +44,7 @@ export const getCompletionsAtPosition = (
     const sourceFile = program?.getSourceFile(fileName)
     if (!program || !sourceFile) return
     if (!scriptSnapshot || isInBannedPosition(position, scriptSnapshot, sourceFile)) return
-    let prior = languageService.getCompletionsAtPosition(fileName, position, options)
+    let prior = languageService.getCompletionsAtPosition(fileName, position, options, formatOptions)
     const ensurePrior = () => {
         if (!prior) prior = { entries: [], isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false }
         return true
@@ -235,7 +234,7 @@ export const getCompletionsAtPosition = (
         })
     }
 
-    prior.entries = markOrRemoveGlobalCompletions(prior.entries, position, languageService, c) ?? prior.entries
+    if (prior.isGlobalCompletion) prior.entries = markOrRemoveGlobalCompletions(prior.entries, position, languageService, c) ?? prior.entries
     if (exactNode) prior.entries = filterJsxElements(prior.entries, exactNode, position, languageService, c) ?? prior.entries
 
     if (c('correctSorting.enable')) {

typescript/src/index.ts

@@ -39,22 +39,31 @@ const decorateLanguageService = (info: ts.server.PluginCreateInfo, existingProxy
 
     let prevCompletionsMap: PrevCompletionMap
     // eslint-disable-next-line complexity
-    proxy.getCompletionsAtPosition = (fileName, position, options) => {
+    proxy.getCompletionsAtPosition = (fileName, position, options, formatOptions) => {
         const updateConfigCommand = 'updateConfig'
         if (options?.triggerCharacter?.startsWith(updateConfigCommand)) {
             _configuration = JSON.parse(options.triggerCharacter.slice(updateConfigCommand.length))
             return { entries: [] }
         }
         const specialCommandResult = options?.triggerCharacter
-            ? handleSpecialCommand(info, fileName, position, options.triggerCharacter as TriggerCharacterCommand, languageService, _configuration)
+            ? handleSpecialCommand(
+                  info,
+                  fileName,
+                  position,
+                  options.triggerCharacter as TriggerCharacterCommand,
+                  languageService,
+                  _configuration,
+                  options,
+                  formatOptions,
+              )
             : undefined
         // handled specialCommand request
         if (specialCommandResult !== undefined) return specialCommandResult as any
         prevCompletionsMap = {}
         const scriptSnapshot = info.project.getScriptSnapshot(fileName)
         // have no idea in which cases its possible, but we can't work without it
         if (!scriptSnapshot) return
-        const result = getCompletionsAtPosition(fileName, position, options, c, info.languageService, scriptSnapshot, ts)
+        const result = getCompletionsAtPosition(fileName, position, options, c, info.languageService, scriptSnapshot, formatOptions)
         if (!result) return
         prevCompletionsMap = result.prevCompletionsMap
         return result.completions
@@ -93,6 +102,12 @@ const decorateLanguageService = (info: ts.server.PluginCreateInfo, existingProxy
     decorateReferences(proxy, info.languageService, c)
     decorateDocumentHighlights(proxy, info.languageService, c)
 
+    // todo arg definition
+    proxy.getCombinedCodeFix = (scope, fixId, formatOptions, preferences) => {
+        const prior = proxy.getCombinedCodeFix(scope, fixId, formatOptions, preferences)
+        return prior
+    }
+
     if (!__WEB__) {
         // dedicated syntax server (which is enabled by default), which fires navtree doesn't seem to receive onConfigurationChanged
         // so we forced to communicate via fs

typescript/src/ipcTypes.ts

@@ -9,6 +9,7 @@ export const triggerCharacterCommands = [
     'pickAndInsertFunctionArguments',
     'getRangeOfSpecialValue',
     'turnArrayIntoObject',
+    'getFixAllEdits',
 ] as const
 
 export type TriggerCharacterCommand = typeof triggerCharacterCommands[number]
@@ -45,6 +46,7 @@ export type RequestResponseTypes = {
         totalObjectCount: number
     }
     turnArrayIntoObjectEdit: ts.TextChange[]
+    getFixAllEdits: ts.TextChange[]
 }
 
 export type RequestOptionsTypes = {

typescript/src/specialCommands/handle.ts

@@ -12,6 +12,8 @@ export default (
     specialCommand: TriggerCharacterCommand,
     languageService: ts.LanguageService,
     configuration: any,
+    preferences: ts.UserPreferences,
+    formatOptions?: ts.FormatCodeSettings,
 ): void | {
     entries: []
     typescriptEssentialsResponse: any
@@ -71,6 +73,32 @@ export default (
             typescriptEssentialsResponse: postfixesAtPosition(position, fileName, scriptSnapshot, info.languageService),
         } as any
     }
+    if (specialCommand === 'getFixAllEdits') {
+        // code adopted is for asyncInSync fix for now
+        const interestedCodes = [1308]
+        const recordedStarts = new Set<number>()
+        const diagnostics = languageService.getSemanticDiagnostics(fileName)
+        const edits: ts.TextChange[] = []
+        for (const { code, start, length } of diagnostics) {
+            if (!interestedCodes.includes(code)) continue
+            const fixes = languageService.getCodeFixesAtPosition(fileName, start!, start! + length!, [code], formatOptions ?? {}, preferences)
+            for (const fix of fixes) {
+                if (fix.fixName === 'fixAwaitInSyncFunction') {
+                    const textChange = fix.changes[0]!.textChanges[0]!
+                    const { start } = textChange.span
+                    if (!recordedStarts.has(start)) {
+                        recordedStarts.add(start)
+                        edits.push(textChange)
+                    }
+                    break
+                }
+            }
+        }
+        return {
+            entries: [],
+            typescriptEssentialsResponse: edits,
+        } as any
+    }
     if (specialCommand === 'removeFunctionArgumentsTypesInSelection') {
         changeType<RequestOptionsTypes['removeFunctionArgumentsTypesInSelection']>(specialCommandArg)