Merge pull request #79 from zardoy/develop

Author: zardoy

README.MD

@@ -164,7 +164,52 @@ 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
+```
+
+## Auto Imports
+
+With this plugin you have total (almost) control over auto imports that appear in completions, quick fixes and import all quick fix. Some examples of what you can do:
+
+- I never want to see `join` suggestion from `path/win32` module (it's a Node.js [module](https://nodejs.org/dist/latest-v18.x/docs/api/path.html#pathwin32), defined via module augmentation)
+- I never want to see any suggestions from `path/*` modules
+- I always want `join` to be imported from `path/posix` module on window (also would appear first in completions & single quick fix)
+- I always want `useState` to be imported from local files first
+
+Some settings examples:
+
+<!-- just duplicated from configurationType -->
+
+```jsonc
+"suggestions.ignoreAutoImports": [
+  "path", // ignore path, but not path/posix or path/win32 modules
+  "path/*", // ignore path, path/posix and path/win32
+  "path/*#join", // ignore path, path/posix and path/win32, but only join symbol
+  "path/*#join,resolve", // ignore path, path/posix and path/win32, but only join and resolve symbol
+],
+"autoImport.changeSorting": {
+    "join": ["path/posix"], // other suggestions will be below
+    "resolve": ["*", "path/posix"], // make `path/posix` appear below any other suggestions
+    "useState": ["."], // `.` (dot) is reserved for local suggestions, which makes them appear above other
+},
+// for some even more specific cases?
+// "autoImport.alwaysIgnoreInImportAll": ["lodash"] // exclude all possible imports from import all request
+```
+
+> Note: changeSorting might not preserve sorting of other existing suggestions which not defined by rules, there is WIP
+> Also I'm thinking of making it learn and syncing of most-used imports automatically
 
 ## Special Commands List
 

src/configurationType.ts

@@ -45,23 +45,42 @@ export type Configuration = {
      *  */
     'removeUselessFunctionProps.enable': boolean
     /**
+     * Of course it makes no sense to use `remove`, but `mark` might be really useful
      * @default disable
      */
-    'removeOrMarkGlobalCompletions.action': 'disable' | 'mark' | 'remove'
+    'removeOrMarkGlobalLibCompletions.action': 'disable' | 'mark' | 'remove'
     /**
      * Useful for Number types.
      * Patch `toString()`: Removes arg tabstop
      * @default true
      */
     'patchToString.enable': boolean
     /**
+     * Format of this setting is very close to `jsxCompletionsMap` setting:
+     * `path#symbol` (exact) or `path/*#symbol` (`#symbol` part can be ommited)
+     *
      * Note: Please use `javascript`/`typescript.preferences.autoImportFileExcludePatterns` when possible, to achieve better performance!
+     *
      * e.g. instead of declaring `@mui/icons-material` here, declare `node_modules/@mui/icons-material` in aforementioned setting.
      *
      * And only use this, if auto-imports coming not from physical files (e.g. some modules node imports)
+     *
+     * Examples:
+     * - `path` - ignore path, but not path/posix or path/win32 modules
+     * - `path/*` - ignore path, path/posix and path/win32
+     * - `path/*#join` - ignore path, path/posix and path/win32, but only join symbol
+     * - `path/*#join,resolve` - ignore path, path/posix and path/win32, but only join and resolve symbol
+     *
+     * - jquery/* - ignore absolutely all auto imports from jquery, even if it was declared virtually (declare module)
      * @default []
      */
-    'suggestions.banAutoImportPackages': string[]
+    'suggestions.ignoreAutoImports': string[]
+    /**
+     * Disable it only if it causes problems / crashes with TypeScript, which of course should never happen
+     * But it wasn't tested on very old versions
+     * @default false
+     */
+    // 'advanced.disableAutoImportCodeFixPatching': boolean
     /**
      * What insert text to use for keywords (e.g. `return`)
      * @default space
@@ -364,4 +383,23 @@ export type Configuration = {
      * @default false
      */
     'experiments.excludeNonJsxCompletions': boolean
+    /**
+     * Map *symbol - array of modules* to change sorting of imports - first available takes precedence in auto import code fixes (+ import all action)
+     *
+     * Examples:
+     * - `join`: ['path/posix'] // other suggestions will be below
+     * - `resolve`: ['*', 'path/posix'] // make `path/posix` appear below any other suggestions
+     * - `useEventListener`: ['.'] // `.` (dot) is reserved for local suggestions, which makes them appear above other
+     * @default {}
+     */
+    'autoImport.changeSorting': { [pathAndOrSymbol: string]: string[] }
+    /**
+     * Advanced. Use `suggestions.ignoreAutoImports` setting if possible.
+     *
+     * Packages to ignore in import all fix.
+     *
+     * TODO syntaxes /* and module#symbol unsupported (easy)
+     * @default []
+     */
+    'autoImport.alwaysIgnoreInImportAll': string[]
 }

src/migrateSettings.ts

@@ -17,6 +17,13 @@ export default () => {
                     mustBePrimitive: true,
                 },
             },
+            {
+                rename: {
+                    old: 'suggestions.banAutoImportPackages',
+                    new: 'suggestions.ignoreAutoImports',
+                    mustBePrimitive: false,
+                },
+            },
         ],
         process.env.IDS_PREFIX!,
     )

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

typescript/src/adjustAutoImports.ts

@@ -0,0 +1,99 @@
+import { GetConfig } from './types'
+import { addObjectMethodResultInterceptors, findChildContainingExactPosition } from './utils'
+
+let currentSymbolName: string | undefined
+
+interface ParsedIgnoreSetting {
+    module: string
+    symbols: string[]
+    isAnySymbol: boolean
+    moduleCompare: 'startsWith' | 'strict'
+}
+
+// will be removed once I'm sure performance can't be improved
+const initIgnoreAutoImport = () => {
+    addObjectMethodResultInterceptors(tsFull, {
+        // todo
+        createPackageJsonImportFilter(res, fromFile) {
+            return {
+                ...res,
+                allowsImportingAmbientModule(moduleSymbol, moduleSpecifierResolutionHost) {
+                    return true
+                    // return isModuleShouldBeIgnored(moduleSymbol.name.slice(1, -1), '')
+                },
+                // allowsImportingSourceFile(sourceFile, moduleSpecifierResolutionHost) {
+                //     return false
+                // },
+                allowsImportingSpecifier(moduleSpecifier) {
+                    const result = res.allowsImportingSpecifier(moduleSpecifier)
+                    if (!result) return false
+                    return false
+                },
+            }
+        },
+    })
+    // addObjectMethodResultInterceptors(tsFull.codefix, {
+    //     getAllFixes(res) {
+    //         return res
+    //     },
+    // })
+}
+
+export const getIgnoreAutoImportSetting = (c: GetConfig) => {
+    return c('suggestions.ignoreAutoImports').map((spec): ParsedIgnoreSetting => {
+        const hashIndex = spec.indexOf('#')
+        let module = hashIndex === -1 ? spec : spec.slice(0, hashIndex)
+        const moduleCompare = module.endsWith('/*') ? 'startsWith' : 'strict'
+        if (moduleCompare === 'startsWith') {
+            module = module.slice(0, -'/*'.length)
+        }
+        if (hashIndex === -1) {
+            return {
+                module,
+                symbols: [],
+                isAnySymbol: true,
+                moduleCompare,
+            }
+        }
+        const symbolsString = spec.slice(hashIndex + 1)
+        // * (glob asterisk) is reserved for future ussage
+        const isAnySymbol = symbolsString === '*'
+        return {
+            module,
+            symbols: isAnySymbol ? [] : symbolsString.split(','),
+            isAnySymbol,
+            moduleCompare,
+        }
+    })
+}
+
+export const isAutoImportEntryShouldBeIgnored = (ignoreAutoImportsSetting: ParsedIgnoreSetting[], targetModule: string, symbol: string) => {
+    for (const { module, moduleCompare, isAnySymbol, symbols } of ignoreAutoImportsSetting) {
+        const isIgnoreModule = moduleCompare === 'startsWith' ? targetModule.startsWith(module) : targetModule === module
+        if (!isIgnoreModule) continue
+        if (isAnySymbol) return true
+        if (!symbols.includes(symbol)) continue
+        return true
+    }
+    return false
+}
+
+export const shouldChangeSortingOfAutoImport = (symbolName: string, c: GetConfig) => {
+    const arr = c('autoImport.changeSorting')[symbolName]
+    return arr && arr.length > 0
+}
+
+export const changeSortingOfAutoImport = (c: GetConfig, symbolName: string): ((module: string) => number) => {
+    const arr = c('autoImport.changeSorting')[symbolName]
+    if (!arr || !arr.length) return () => 0
+    const maxIndex = arr.length
+    return module => {
+        let actualIndex = arr.findIndex(x => {
+            return x.endsWith('/*') ? module.startsWith(x.slice(0, -'/*'.length)) : module === x
+        })
+        // . - index, don't treat some node_modules-ignored modules as local such as `.vite`
+        const isLocal = module.startsWith('./') || module.startsWith('../') || module === '.'
+        if (actualIndex === -1) actualIndex = arr.findIndex(x => (isLocal ? x === '.' : x === '*'))
+        return actualIndex === -1 ? maxIndex : actualIndex
+    }
+}