finializing method snippets by replacing public api and adding tests!

zardoy · zardoy · commit db09aca7b36b · 2023-02-25T09:41:32.000+03:00
also refactor test utils in its own file
diff --git a/README.MD b/README.MD
@@ -244,9 +244,9 @@ There are value descriptions for two settings:
 
 ```ts
 const example = ({ a }, b?, c = 5, ...d) => { }
-// prefer-name (default)
+// binding-name (default)
 example({ a }, b, c, ...d)
-// always-declaration (recommended)
+// always-declaration (also popular)
 example({ a }, b?, c = 5, ...d)
 // always-name
 example(__0, b, c, d)
@@ -264,6 +264,30 @@ example({ a })
 example({ a }, b, c, ...d)
 ```
 
+`tsEssentialPlugins.methodSnippets.multipleSignatures`:
+
+```ts
+// overload 1
+function foo(this: {}, a)
+// overload 2
+function foo(this: {}, b)
+function foo(this: {}) {}
+
+// pick-first (default)
+foo(a)
+// empty
+foo(|)
+```
+
+`disableMethodSnippets.jsxAttributes`:
+
+```tsx
+const callback = (arg) => {}
+function Foo() {
+    return <div onClick={callback/* when true (default) - no expansion here */} />
+}
+```
+
 ## 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:
diff --git a/src/configurationType.ts b/src/configurationType.ts
@@ -326,16 +326,16 @@ export type Configuration = {
      * ```ts
      * const example = ({ a }, b?, c = 5, ...d) => { }
      *
-     * // prefer-name (default)
+     * // binding-name (default)
      * example({ a }, b, c, ...d)
-     * // always-declaration (popular)
+     * // always-declaration (also popular)
      * example({ a }, b?, c = 5, ...d)
      * // always-name
      * example(__0, b, c, d)
      * ```
-     * @default prefer-name
+     * @default binding-name
      */
-    'methodSnippets.insertText': 'prefer-name' | 'always-declaration' | 'always-name'
+    'methodSnippets.insertText': 'binding-name' | 'always-declaration' | 'always-name'
     /**
      * ```ts
      * const example = ({ a }, b?, c = 5, ...d) => { }
@@ -350,6 +350,10 @@ export type Configuration = {
      * @default no-skip
      */
     'methodSnippets.skip': 'only-rest' | 'optional-and-rest' | 'no-skip'
+    /**
+     * @default pick-first
+     */
+    'methodSnippets.multipleSignatures': 'pick-first' | 'empty' /* DON'T SEE A NEED TO IMPLEMENT: | 'pick-longest'  | 'pick-shortest' */
     /**
      * Wether to disable our and builtin method snippets within jsx attributes
      * @default true
diff --git a/src/onCompletionAccepted.ts b/src/onCompletionAccepted.ts
@@ -8,10 +8,10 @@ import { RequestOptionsTypes, RequestResponseTypes } from '../typescript/src/ipc
 import { sendCommand } from './sendCommand'
 
 export default (tsApi: { onCompletionAccepted }) => {
+    let inFlightMethodSnippetOperation: undefined | AbortController
     let justAcceptedReturnKeywordSuggestion = false
     let onCompletionAcceptedOverride: ((item: any) => void) | undefined
 
-    // eslint-disable-next-line complexity
     tsApi.onCompletionAccepted(async (item: vscode.CompletionItem & { document: vscode.TextDocument }) => {
         if (onCompletionAcceptedOverride) {
             onCompletionAcceptedOverride(item)
@@ -41,55 +41,24 @@ export default (tsApi: { onCompletionAccepted }) => {
             const startPos = editor.selection.start
             const nextSymbol = editor.document.getText(new vscode.Range(startPos, startPos.translate(0, 1)))
             if (!['(', '.'].includes(nextSymbol)) {
-                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 (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 controller = new AbortController()
+                inFlightMethodSnippetOperation = controller
+                const params: RequestResponseTypes['getFullMethodSnippet'] | undefined = await sendCommand('getFullMethodSnippet')
+                if (!controller.signal.aborted && params) {
                     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
-                        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(', ')
+                    for (const [i, param] of params.entries()) {
+                        snippet.appendPlaceholder(param)
+                        if (i !== params.length - 1) snippet.appendText(', ')
                     }
 
-                    const allFiltered = data.parameters.length > parameters.length
-                    // TODO when many, but at least one not empty
-                    if (allFiltered || data.hasManySignatures) snippet.appendTabstop()
-
                     snippet.appendText(')')
                     void editor.insertSnippet(snippet, undefined, {
                         undoStopAfter: false,
                         undoStopBefore: false,
                     })
-                    if (vscode.workspace.getConfiguration('editor.parameterHints').get('enabled')) {
+                    if (vscode.workspace.getConfiguration('editor.parameterHints').get('enabled') && params.length > 0) {
                         void vscode.commands.executeCommand('editor.action.triggerParameterHints')
                     }
                 }
@@ -120,40 +89,42 @@ export default (tsApi: { onCompletionAccepted }) => {
         )
     })
 
-    conditionallyRegister(
-        'suggestions.keywordsInsertText',
-        () =>
-            vscode.workspace.onDidChangeTextDocument(({ document, contentChanges, reason }) => {
-                if (!justAcceptedReturnKeywordSuggestion) return
-                if (document !== vscode.window.activeTextEditor?.document) return
-                try {
-                    if (oneOf(reason, vscode.TextDocumentChangeReason.Redo, vscode.TextDocumentChangeReason.Undo)) {
-                        return
-                    }
+    vscode.workspace.onDidChangeTextDocument(({ document, contentChanges, reason }) => {
+        if (document !== vscode.window.activeTextEditor?.document) return
+        // do the same for position change?
+        if (inFlightMethodSnippetOperation) {
+            inFlightMethodSnippetOperation.abort()
+            inFlightMethodSnippetOperation = undefined
+        }
 
-                    const char = contentChanges[0]?.text
-                    if (char?.length !== 1 || contentChanges.some(({ text }) => text !== char)) {
-                        return
-                    }
+        if (!justAcceptedReturnKeywordSuggestion) return
 
-                    if (char === ';' || char === '\n') {
-                        void vscode.window.activeTextEditor.edit(
-                            builder => {
-                                for (const { range } of contentChanges) {
-                                    const pos = range.start
-                                    builder.delete(expandPosition(document, pos, -1))
-                                }
-                            },
-                            {
-                                undoStopAfter: false,
-                                undoStopBefore: false,
-                            },
-                        )
-                    }
-                } finally {
-                    justAcceptedReturnKeywordSuggestion = false
-                }
-            }),
-        () => getExtensionSetting('suggestions.keywordsInsertText') !== 'none',
-    )
+        try {
+            if (oneOf(reason, vscode.TextDocumentChangeReason.Redo, vscode.TextDocumentChangeReason.Undo)) {
+                return
+            }
+
+            const char = contentChanges[0]?.text
+            if (char?.length !== 1 || contentChanges.some(({ text }) => text !== char)) {
+                return
+            }
+
+            if (char === ';' || char === '\n') {
+                void vscode.window.activeTextEditor.edit(
+                    builder => {
+                        for (const { range } of contentChanges) {
+                            const pos = range.start
+                            builder.delete(expandPosition(document, pos, -1))
+                        }
+                    },
+                    {
+                        undoStopAfter: false,
+                        undoStopBefore: false,
+                    },
+                )
+            }
+        } finally {
+            justAcceptedReturnKeywordSuggestion = false
+        }
+    })
 }
diff --git a/tsconfig.json b/tsconfig.json
@@ -4,7 +4,8 @@
         "lib": [
             "ESNext",
             "WebWorker"
-        ]
+        ],
+        "noFallthroughCasesInSwitch": true
     },
     // type-check sources
     "include": [
diff --git a/typescript/src/codeActions/getCodeActions.ts b/typescript/src/codeActions/getCodeActions.ts
@@ -2,6 +2,7 @@ import { compact } from '@zardoy/utils'
 import { findChildContainingPosition } from '../utils'
 import objectSwapKeysAndValues from './custom/objectSwapKeysAndValues'
 import changeStringReplaceToRegex from './custom/changeStringReplaceToRegex'
+import splitDeclarationAndInitialization from './custom/splitDeclarationAndInitialization'
 
 type SimplifiedRefactorInfo =
     | {
@@ -30,7 +31,7 @@ export type CodeAction = {
     tryToApply: ApplyCodeAction
 }
 
-const codeActions: CodeAction[] = [/* toggleBraces */ objectSwapKeysAndValues, changeStringReplaceToRegex]
+const codeActions: CodeAction[] = [/* toggleBraces */ objectSwapKeysAndValues, changeStringReplaceToRegex, splitDeclarationAndInitialization]
 
 export const REFACTORS_CATEGORY = 'essential-refactors'
 
diff --git a/typescript/src/constructMethodSnippet.ts b/typescript/src/constructMethodSnippet.ts
@@ -0,0 +1,85 @@
+import { compact } from '@zardoy/utils'
+import { isTypeNode } from './completions/keywordsSpace'
+import { GetConfig } from './types'
+import { findChildContainingExactPosition } from './utils'
+
+export default (languageService: ts.LanguageService, sourceFile: ts.SourceFile, position: number, c: GetConfig) => {
+    const node = findChildContainingExactPosition(sourceFile, position)
+    if (!node || isTypeNode(node)) return
+
+    const typeChecker = languageService.getProgram()!.getTypeChecker()!
+    const type = typeChecker.getContextualType(node as any) ?? typeChecker.getTypeAtLocation(node)
+    const signatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call)
+    if (signatures.length === 0) return
+    const signature = signatures[0]
+    if (signatures.length > 1 && c('methodSnippets.multipleSignatures') === 'empty') {
+        return ['']
+    }
+    if (!signature) return
+
+    const insertMode = c('methodSnippets.insertText')
+    const skipMode = c('methodSnippets.skip')
+
+    // Investigate merging signatures
+    const { parameters } = signatures[0]!
+    const printer = ts.createPrinter()
+    const paramsToInsert = compact(
+        parameters.map(param => {
+            const valueDeclaration = param.valueDeclaration as ts.ParameterDeclaration | undefined
+            const isOptional =
+                valueDeclaration && (valueDeclaration.questionToken || valueDeclaration.initializer || valueDeclaration.dotDotDotToken) ? true : false
+            switch (skipMode) {
+                case 'only-rest':
+                    if (valueDeclaration?.dotDotDotToken) return undefined
+                    break
+                case 'optional-and-rest':
+                    if (isOptional) return undefined
+                    break
+            }
+            const insertName = insertMode === 'always-name' || !valueDeclaration
+            const insertText = insertName
+                ? param.name
+                : printer.printNode(
+                      ts.EmitHint.Unspecified,
+                      ts.factory.createParameterDeclaration(
+                          undefined,
+                          valueDeclaration.dotDotDotToken,
+                          !ts.isIdentifier(valueDeclaration.name) && insertMode !== 'always-declaration'
+                              ? cloneBindingName(valueDeclaration.name)
+                              : valueDeclaration.name,
+                          valueDeclaration.questionToken,
+                          undefined,
+                          insertMode === 'always-declaration' ? valueDeclaration.initializer : undefined,
+                      ),
+                      valueDeclaration.getSourceFile(),
+                  )
+            return insertText
+        }),
+    )
+
+    const allFiltered = paramsToInsert.length === 0 && parameters.length > paramsToInsert.length
+    if (allFiltered) return ['']
+
+    return paramsToInsert
+    // return `(${paramsToInsert.map((param, i) => `\${${i + 1}:${param.replaceAll}}`).join(', ')})`
+
+    function cloneBindingName(node: ts.BindingName): ts.BindingName {
+        return elideInitializerAndSetEmitFlags(node) as ts.BindingName
+        function elideInitializerAndSetEmitFlags(node: ts.Node): ts.Node {
+            let visited = ts.visitEachChild(
+                node,
+                elideInitializerAndSetEmitFlags,
+                tsFull.nullTransformationContext as any,
+                /*nodesVisitor*/ undefined,
+                elideInitializerAndSetEmitFlags,
+            )!
+            if (ts.isBindingElement(visited)) {
+                visited = ts.factory.updateBindingElement(visited, visited.dotDotDotToken, visited.propertyName, visited.name, /*initializer*/ undefined)
+            }
+            // if (!tsFull.nodeIsSynthesized(visited)) {
+            //     visited = ts.factory.cloneNode(visited);
+            // }
+            return ts.setEmitFlags(visited, ts.EmitFlags.SingleLine | ts.EmitFlags.NoAsciiEscaping)
+        }
+    }
+}
diff --git a/typescript/src/decorateProxy.ts b/typescript/src/decorateProxy.ts
@@ -63,7 +63,7 @@ export const decorateLanguageService = (
                   position,
                   options.triggerCharacter as TriggerCharacterCommand,
                   languageService,
-                  config.config,
+                  config.config && c,
                   options,
                   formatOptions,
               )
diff --git a/typescript/src/ipcTypes.ts b/typescript/src/ipcTypes.ts
@@ -1,4 +1,4 @@
-export const passthroughExposedApiCommands = ['getNodePath', 'getSpanOfEnclosingComment', 'getNodeAtPosition', 'getSignatureInfo'] as const
+export const passthroughExposedApiCommands = ['getNodePath', 'getSpanOfEnclosingComment', 'getNodeAtPosition'] as const
 
 export const triggerCharacterCommands = [
     ...passthroughExposedApiCommands,
@@ -10,6 +10,7 @@ export const triggerCharacterCommands = [
     'turnArrayIntoObject',
     'getFixAllEdits',
     'acceptRenameWithParams',
+    'getFullMethodSnippet',
 ] as const
 
 export type TriggerCharacterCommand = (typeof triggerCharacterCommands)[number]
@@ -54,12 +55,7 @@ export type RequestResponseTypes = {
     }
     turnArrayIntoObjectEdit: ts.TextChange[]
     getFixAllEdits: ts.TextChange[]
-    getSignatureInfo: {
-        // stable
-        parameters: GetSignatureInfoParameter[]
-        // unstable
-        hasManySignatures: boolean
-    }
+    getFullMethodSnippet: string[] | undefined
 }
 
 // INPUT
@@ -76,9 +72,6 @@ export type RequestOptionsTypes = {
         strings: boolean
         alias: boolean
     }
-    getSignatureInfo: {
-        includeInitializer?: boolean
-    }
 }
 
 // export type EmmetResult = {
diff --git a/typescript/src/specialCommands/handle.ts b/typescript/src/specialCommands/handle.ts
diff --git a/typescript/test/completions.spec.ts b/typescript/test/completions.spec.ts
diff --git a/typescript/test/testing.ts b/typescript/test/testing.ts

Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ export const decorateLanguageService = (`
`63`	`63`	`position,`
`64`	`64`	`options.triggerCharacter as TriggerCharacterCommand,`
`65`	`65`	`languageService,`
`66`		`- config.config,`
	`66`	`+ config.config && c,`
`67`	`67`	`options,`
`68`	`68`	`formatOptions,`
`69`	`69`	`)`