feat: Rewrote enableMethodSnippets from the ground, fixing old bugs and introducing absolutely new modes (settings). Now enableMethodSnippets works on absolutely any variable that actually has signature. Finally!

Author: zardoy

README.MD

@@ -7,6 +7,7 @@ TOC:
 
 - [Top Features](#top-features)
 - [Minor Useful Features](#minor-useful-features)
+- [Method Snippets](#method-snippets)
 - [Auto Imports](#auto-imports)
 - [Rename Features](#rename-features)
 - [Special Commands List](#special-commands-list)
@@ -35,19 +36,6 @@ Also is not supported in the web.
 
 90% work done in this extension highly improves completions experience!
 
-### Method Snippets
-
-(*enabled by default*)
-
-Expands arrow callbacks with signature snippet with adding additional undo stack!
-
-Example:
-
-```ts
-const callback = (arg) => {}
-callback -> callback(arg)
-```
-
 ### Strict Emmet
 
 (*enabled by default*) when react langs are in `emmet.excludeLanguages`
@@ -205,6 +193,47 @@ const a = 5
 a = 6
 ```
 
+### Method Snippets
+
+(*enabled by default*)
+
+Expands arrow callback completions with signature snippet. Also adds additional undo stack!
+
+Example:
+
+```ts
+const callback = (arg) => {}
+callback -> callback(arg)
+```
+
+#### Configuration
+
+There are value descriptions for two settings:
+
+`tsEssentialPlugins.methodSnippets.insertText`:
+
+```ts
+const example = ({ a }, b?, c = 5, ...d) => { }
+// prefer-name (default)
+example({ a }, b, c, ...d)
+// always-declaration (recommended)
+example({ a }, b?, c = 5, ...d)
+// always-name
+example(__0, b, c, d)
+```
+
+`tsEssentialPlugins.methodSnippets.skip`:
+
+```ts
+const example = ({ a }, b?, c = 5, ...d) => { }
+// only-rest
+example({ a }, b, c)
+// optional-and-rest
+example({ a })
+// no-skip (default)
+example({ a }, b, c, ...d)
+```
+
 ## 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:

src/configurationType.ts

@@ -311,10 +311,45 @@ export type Configuration = {
      */
     changeDtsFileDefinitionToJs: boolean
     /**
-     * Experimental. Also includes optional args
+     * Wether to enable method call snippets after completion (suggestion) accept eg:
+     * ```ts
+     * const simple = (foo: boolean) => {}
+     * const complex = ({ a }, b?, c = 5) => { }
+     *
+     * simple(foo)
+     * test({ a }, b, c)
+     * ```
      * @default true
      */
     enableMethodSnippets: boolean
+    /**
+     * ```ts
+     * const example = ({ a }, b?, c = 5, ...d) => { }
+     *
+     * // prefer-name (default)
+     * example({ a }, b, c, ...d)
+     * // always-declaration (popular)
+     * example({ a }, b?, c = 5, ...d)
+     * // always-name
+     * example(__0, b, c, d)
+     * ```
+     * @default prefer-name
+     */
+    'methodSnippets.insertText': 'prefer-name' | 'always-declaration' | 'always-name'
+    /**
+     * ```ts
+     * const example = ({ a }, b?, c = 5, ...d) => { }
+     *
+     * // only-rest
+     * example({ a }, b, c)
+     * // optional-and-rest (popular)
+     * example({ a })
+     * // no-skip (default)
+     * example({ a }, b, c, ...d)
+     * ```
+     * @default no-skip
+     */
+    'methodSnippets.skip': 'only-rest' | 'optional-and-rest' | 'no-skip'
     /**
      * Wether to disable our and builtin method snippets within jsx attributes
      * @default true

src/onCompletionAccepted.ts

@@ -4,12 +4,15 @@ import { conditionallyRegister } from '@zardoy/vscode-utils/build/settings'
 import { expandPosition } from '@zardoy/vscode-utils/build/position'
 import { getExtensionSetting, registerExtensionCommand } from 'vscode-framework'
 import { oneOf } from '@zardoy/utils'
+import { RequestOptionsTypes, RequestResponseTypes } from '../typescript/src/ipcTypes'
+import { sendCommand } from './sendCommand'
 
 export default (tsApi: { onCompletionAccepted }) => {
     let justAcceptedReturnKeywordSuggestion = false
     let onCompletionAcceptedOverride: ((item: any) => void) | undefined
 
-    tsApi.onCompletionAccepted((item: vscode.CompletionItem & { document: vscode.TextDocument }) => {
+    // eslint-disable-next-line complexity
+    tsApi.onCompletionAccepted(async (item: vscode.CompletionItem & { document: vscode.TextDocument }) => {
         if (onCompletionAcceptedOverride) {
             onCompletionAcceptedOverride(item)
             return
@@ -32,32 +35,59 @@ export default (tsApi: { onCompletionAccepted }) => {
         }
 
         const enableMethodSnippets = vscode.workspace.getConfiguration(process.env.IDS_PREFIX, item.document).get('enableMethodSnippets')
-        const documentationString = documentation instanceof vscode.MarkdownString ? documentation.value : documentation
-        const insertFuncArgs = /<!-- insert-func: (.*)-->/.exec(documentationString)?.[1]
-        console.debug('insertFuncArgs', insertFuncArgs)
-        if (enableMethodSnippets && insertFuncArgs !== undefined) {
+
+        if (enableMethodSnippets && (typeof insertText !== 'object' || !insertText.value.endsWith(')$0'))) {
             const editor = getActiveRegularEditor()!
             const startPos = editor.selection.start
             const nextSymbol = editor.document.getText(new vscode.Range(startPos, startPos.translate(0, 1)))
             if (!['(', '.'].includes(nextSymbol)) {
-                const snippet = new vscode.SnippetString('')
-                snippet.appendText('(')
-                const args = insertFuncArgs.split(',')
-                for (let [i, arg] of args.entries()) {
-                    if (!arg) continue
-                    // skip empty, but add tabstops if we explicitly want it!
-                    if (arg === ' ') arg = ''
-                    snippet.appendPlaceholder(arg)
-                    if (i !== args.length - 1) snippet.appendText(', ')
-                }
-
-                snippet.appendText(')')
-                void editor.insertSnippet(snippet, undefined, {
-                    undoStopAfter: false,
-                    undoStopBefore: false,
+                const insertMode = getExtensionSetting('methodSnippets.insertText')
+                const skipMode = getExtensionSetting('methodSnippets.skip')
+                const data: RequestResponseTypes['getSignatureInfo'] | undefined = await sendCommand('getSignatureInfo', {
+                    inputOptions: {
+                        includeInitializer: insertMode === 'always-declaration',
+                    } satisfies RequestOptionsTypes['getSignatureInfo'],
                 })
-                if (vscode.workspace.getConfiguration('editor.parameterHints').get('enabled')) {
-                    void vscode.commands.executeCommand('editor.action.triggerParameterHints')
+                if (data) {
+                    const parameters = data.parameters.filter(({ insertText, isOptional }) => {
+                        const isRest = insertText.startsWith('...')
+                        if (skipMode === 'only-rest' && isRest) return false
+                        if (skipMode === 'optional-and-rest' && isOptional) return false
+                        return true
+                    })
+
+                    const snippet = new vscode.SnippetString('')
+                    snippet.appendText('(')
+                    // todo maybe when have skipped, add a way to leave trailing , (previous behavior)
+                    for (const [i, { insertText, name }] of parameters.entries()) {
+                        const isRest = insertText.startsWith('...')
+                        let text: string
+                        // eslint-disable-next-line default-case, @typescript-eslint/switch-exhaustiveness-check
+                        switch (insertMode) {
+                            case 'always-name':
+                                text = name
+                                break
+                            case 'prefer-name':
+                                // prefer name, but only if identifier and not binding pattern & rest
+                                text = oneOf(insertText[0], '[', '{') ? insertText : isRest ? insertText : name
+                                break
+                            case 'always-declaration':
+                                text = insertText
+                                break
+                        }
+
+                        snippet.appendPlaceholder(text)
+                        if (i !== parameters.length - 1) snippet.appendText(', ')
+                    }
+
+                    snippet.appendText(')')
+                    void editor.insertSnippet(snippet, undefined, {
+                        undoStopAfter: false,
+                        undoStopBefore: false,
+                    })
+                    if (vscode.workspace.getConfiguration('editor.parameterHints').get('enabled')) {
+                        void vscode.commands.executeCommand('editor.action.triggerParameterHints')
+                    }
                 }
             }
         }

src/sendCommand.ts

@@ -4,8 +4,8 @@ import { getExtensionSetting } from 'vscode-framework'
 import { passthroughExposedApiCommands, TriggerCharacterCommand } from '../typescript/src/ipcTypes'
 
 type SendCommandData<K> = {
-    position: vscode.Position
-    document: vscode.TextDocument
+    position?: vscode.Position
+    document?: vscode.TextDocument
     inputOptions?: K
 }
 export const sendCommand = async <T, K = any>(command: TriggerCharacterCommand, sendCommandDataArg?: SendCommandData<K>): Promise<T | undefined> => {
@@ -27,21 +27,12 @@ export const sendCommand = async <T, K = any>(command: TriggerCharacterCommand,
         return
     }
 
-    if (sendCommandDataArg?.inputOptions) {
-        command = `${command}?${JSON.stringify(sendCommandDataArg.inputOptions)}` as any
-    }
+    const _editor = getActiveRegularEditor()!
+    const { document: { uri } = _editor.document, position = _editor.selection.active, inputOptions } = sendCommandDataArg ?? {}
 
-    const {
-        document: { uri },
-        position,
-    } = ((): SendCommandData<any> => {
-        if (sendCommandDataArg) return sendCommandDataArg
-        const editor = getActiveRegularEditor()!
-        return {
-            document: editor.document,
-            position: editor.selection.active,
-        }
-    })()
+    if (inputOptions) {
+        command = `${command}?${JSON.stringify(inputOptions)}` as any
+    }
 
     if (process.env.NODE_ENV === 'development') console.time(`request ${command}`)
     let requestFile = uri.fsPath

typescript/src/completionEntryDetails.ts

@@ -1,64 +1,7 @@
-import { oneOf } from '@zardoy/utils'
-import { getParameterListParts } from './completions/snippetForFunctionCall'
 import { PrevCompletionMap, PrevCompletionsAdditionalData } from './completionsAtPosition'
 import namespaceAutoImports from './namespaceAutoImports'
 import { GetConfig } from './types'
 
-const handleMethodSnippets = (prior: ts.CompletionEntryDetails, c: GetConfig, { enableMethodCompletion }: PrevCompletionsAdditionalData) => {
-    if (
-        c('enableMethodSnippets') &&
-        oneOf(
-            prior.kind,
-            ts.ScriptElementKind.constElement,
-            ts.ScriptElementKind.letElement,
-            ts.ScriptElementKind.alias,
-            ts.ScriptElementKind.variableElement,
-            ts.ScriptElementKind.memberVariableElement,
-        )
-    ) {
-        // - 1 to look for possibly previous completing item
-        let rawPartsOverride: ts.SymbolDisplayPart[] | undefined
-        if (enableMethodCompletion && prior.kind === ts.ScriptElementKind.alias) {
-            enableMethodCompletion =
-                prior.displayParts[5]?.text === 'method' || (prior.displayParts[4]?.kind === 'keyword' && prior.displayParts[4].text === 'function')
-            const { parts, gotMethodHit, hasOptionalParameters } = getParameterListParts(prior.displayParts)
-            if (gotMethodHit) rawPartsOverride = hasOptionalParameters ? [...parts, { kind: '', text: ' ' }] : parts
-        }
-        const punctuationIndex = prior.displayParts.findIndex(({ kind, text }) => kind === 'punctuation' && text === ':')
-        if (enableMethodCompletion && punctuationIndex !== 1) {
-            const isParsableMethod = prior.displayParts
-                // next is space
-                .slice(punctuationIndex + 2)
-                .map(({ text }) => text)
-                .join('')
-                .match(/^\((.*)\) => /)
-            if (rawPartsOverride || isParsableMethod) {
-                let firstArgMeet = false
-                const args = (
-                    rawPartsOverride ||
-                    prior.displayParts.filter(({ kind }, index, array) => {
-                        if (kind !== 'parameterName') return false
-                        if (array[index - 1]!.text === '(') {
-                            if (!firstArgMeet) {
-                                // bad parsing, as it doesn't take second and more args
-                                firstArgMeet = true
-                                return true
-                            }
-                            return false
-                        }
-                        return true
-                    })
-                ).map(({ text }) => text)
-                prior = {
-                    ...prior,
-                    documentation: [...(prior.documentation ?? []), { kind: 'text', text: `<!-- insert-func: ${args.join(',')}-->` }],
-                }
-            }
-        }
-    }
-    return prior
-}
-
 export default function completionEntryDetails(
     inputArgs: Parameters<ts.LanguageService['getCompletionEntryDetails']>,
     languageService: ts.LanguageService,
@@ -125,5 +68,5 @@ export default function completionEntryDetails(
     if (documentationAppend) {
         prior.documentation = [...(prior.documentation ?? []), { kind: 'text', text: documentationAppend }]
     }
-    return handleMethodSnippets(prior, c, prevCompletionsAdittionalData)
+    return prior
 }