feat(method-snippets): Now to insert a method snippet for Object or lodash you need to accept suggestion twice (ambiguous suggestions)

zardoy · zardoy · commit 3270caca6332 · 2023-03-18T04:32:30.000+03:00
diff --git a/README.MD b/README.MD
@@ -315,6 +315,22 @@ function Foo() {
 }
 ```
 
+### Ambiguous Suggestions
+
+Some variables like `Object` or `lodash` are common to access properties as well as call directly:
+
+```ts
+Object.assign(...)
+Object()
+// or
+lodash.version
+lodash(...)
+```
+
+To not be annoying, we don't insert a method snippet on such suggestion accept.
+
+Instead, for these *ambiguous* suggestions we require you to accept the same suggestion twice to ensure you actually want a method snippet.
+
 ## 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/onCompletionAccepted.ts b/src/onCompletionAccepted.ts
@@ -3,12 +3,13 @@ import { getActiveRegularEditor } from '@zardoy/vscode-utils'
 import { expandPosition } from '@zardoy/vscode-utils/build/position'
 import { getExtensionSetting, registerExtensionCommand } from 'vscode-framework'
 import { oneOf } from '@zardoy/utils'
-import { RequestResponseTypes } from '../typescript/src/ipcTypes'
+import { RequestOptionsTypes, RequestResponseTypes } from '../typescript/src/ipcTypes'
 import { sendCommand } from './sendCommand'
 
 export default (tsApi: { onCompletionAccepted }) => {
     let inFlightMethodSnippetOperation: undefined | AbortController
     let justAcceptedReturnKeywordSuggestion = false
+    let lastAcceptedAmbiguousMethodSnippetSuggestion: string | undefined
     let onCompletionAcceptedOverride: ((item: any) => void) | undefined
 
     // eslint-disable-next-line complexity
@@ -19,6 +20,7 @@ export default (tsApi: { onCompletionAccepted }) => {
         }
 
         const { label, insertText, kind } = item
+        const suggestionName = typeof label === 'object' ? label.label : label
         if (kind === vscode.CompletionItemKind.Keyword) {
             if (insertText === 'return ') justAcceptedReturnKeywordSuggestion = true
             else if (insertText === 'default ') void vscode.commands.executeCommand('editor.action.triggerSuggest')
@@ -41,35 +43,49 @@ 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)) {
+                // all-in handling
                 const controller = new AbortController()
                 inFlightMethodSnippetOperation = controller
-                const params: RequestResponseTypes['getFullMethodSnippet'] | undefined = await sendCommand('getFullMethodSnippet')
-                if (!controller.signal.aborted && params) {
-                    const replaceArguments = getExtensionSetting('methodSnippets.replaceArguments')
-
-                    const snippet = new vscode.SnippetString('')
-                    snippet.appendText('(')
-                    // todo maybe when have optional (skipped), add a way to leave trailing , with tabstop (previous behavior)
-                    for (const [i, param] of params.entries()) {
-                        const replacer = replaceArguments[param.replace(/\?$/, '')]
-                        if (replacer === null) continue
-                        if (replacer) {
-                            useReplacer(snippet, replacer)
-                        } else {
-                            snippet.appendPlaceholder(param)
-                        }
+                const params: RequestResponseTypes['getFullMethodSnippet'] | undefined = await sendCommand('getFullMethodSnippet', {
+                    inputOptions: {
+                        acceptAmbiguous: lastAcceptedAmbiguousMethodSnippetSuggestion === suggestionName,
+                    } satisfies RequestOptionsTypes['getFullMethodSnippet'],
+                })
 
-                        if (i !== params.length - 1) snippet.appendText(', ')
-                    }
+                if (controller.signal.aborted) return
+                if (params === 'ambiguous') {
+                    lastAcceptedAmbiguousMethodSnippetSuggestion = suggestionName
+                    return
+                }
 
-                    snippet.appendText(')')
-                    void editor.insertSnippet(snippet, undefined, {
-                        undoStopAfter: false,
-                        undoStopBefore: false,
-                    })
-                    if (vscode.workspace.getConfiguration('editor.parameterHints').get('enabled') && params.length > 0) {
-                        void vscode.commands.executeCommand('editor.action.triggerParameterHints')
+                if (!params) {
+                    return
+                }
+
+                const replaceArguments = getExtensionSetting('methodSnippets.replaceArguments')
+
+                const snippet = new vscode.SnippetString('')
+                snippet.appendText('(')
+                // todo maybe when have optional (skipped), add a way to leave trailing , with tabstop (previous behavior)
+                for (const [i, param] of params.entries()) {
+                    const replacer = replaceArguments[param.replace(/\?$/, '')]
+                    if (replacer === null) continue
+                    if (replacer) {
+                        useReplacer(snippet, replacer)
+                    } else {
+                        snippet.appendPlaceholder(param)
                     }
+
+                    if (i !== params.length - 1) snippet.appendText(', ')
+                }
+
+                snippet.appendText(')')
+                void editor.insertSnippet(snippet, undefined, {
+                    undoStopAfter: false,
+                    undoStopBefore: false,
+                })
+                if (vscode.workspace.getConfiguration('editor.parameterHints').get('enabled') && params.length > 0) {
+                    void vscode.commands.executeCommand('editor.action.triggerParameterHints')
                 }
             }
         }
@@ -136,6 +152,12 @@ export default (tsApi: { onCompletionAccepted }) => {
             justAcceptedReturnKeywordSuggestion = false
         }
     })
+
+    vscode.window.onDidChangeTextEditorSelection(({ textEditor }) => {
+        if (textEditor !== vscode.window.activeTextEditor) return
+        // cursor position changed
+        lastAcceptedAmbiguousMethodSnippetSuggestion = undefined
+    })
 }
 
 function useReplacer(snippet: vscode.SnippetString, replacer: string) {
diff --git a/typescript/src/constructMethodSnippet.ts b/typescript/src/constructMethodSnippet.ts
@@ -3,7 +3,8 @@ 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) => {
+// todo-low-ee inspect any last arg infer
+export default (languageService: ts.LanguageService, sourceFile: ts.SourceFile, position: number, c: GetConfig, acceptAmbiguous: boolean) => {
     let node = findChildContainingExactPosition(sourceFile, position)
     if (!node || isTypeNode(node)) return
 
@@ -14,6 +15,8 @@ export default (languageService: ts.LanguageService, sourceFile: ts.SourceFile,
     if (ts.isPropertyAccessExpression(node)) node = node.parent
 
     const isNewExpression = ts.isNewExpression(node)
+    if (!isNewExpression && !acceptAmbiguous && (type.getProperties().length || type.getStringIndexType() || type.getNumberIndexType())) return 'ambiguous'
+
     const signatures = checker.getSignaturesOfType(type, isNewExpression ? ts.SignatureKind.Construct : ts.SignatureKind.Call)
     // ensure node is not used below
     if (signatures.length === 0) return
diff --git a/typescript/src/ipcTypes.ts b/typescript/src/ipcTypes.ts
@@ -77,7 +77,7 @@ export type RequestResponseTypes = {
           }
     turnArrayIntoObjectEdit: ts.TextChange[]
     getFixAllEdits: ts.TextChange[]
-    getFullMethodSnippet: string[] | undefined
+    getFullMethodSnippet: string[] | 'ambiguous' | undefined
     getExtendedCodeActionEdits: ApplyExtendedCodeActionResult
 }
 
@@ -110,6 +110,9 @@ export type RequestOptionsTypes = {
         range: [number, number]
         applyCodeActionTitle: string
     }
+    getFullMethodSnippet: {
+        acceptAmbiguous: boolean
+    }
 }
 
 // export type EmmetResult = {
diff --git a/typescript/src/specialCommands/handle.ts b/typescript/src/specialCommands/handle.ts
@@ -101,7 +101,14 @@ export default (
         return !node ? undefined : nodeToApiResponse(node)
     }
     if (specialCommand === 'getFullMethodSnippet') {
-        return constructMethodSnippet(languageService, sourceFile, position, configuration) satisfies RequestResponseTypes['getFullMethodSnippet']
+        changeType<RequestOptionsTypes['getFullMethodSnippet']>(specialCommandArg)
+        return constructMethodSnippet(
+            languageService,
+            sourceFile,
+            position,
+            configuration,
+            specialCommandArg.acceptAmbiguous,
+        ) satisfies RequestResponseTypes['getFullMethodSnippet']
     }
     if (specialCommand === 'getSpanOfEnclosingComment') {
         return languageService.getSpanOfEnclosingComment(fileName, position, false)
diff --git a/typescript/test/completions.spec.ts b/typescript/test/completions.spec.ts
@@ -109,7 +109,11 @@ test('Function props: cleans & highlights', () => {
 const compareMethodSnippetAgainstMarker = (inputMarkers: number[], marker: number, expected: string | null | string[]) => {
     const obj = Object.fromEntries(inputMarkers.entries())
     const markerPos = obj[marker]!
-    const methodSnippet = constructMethodSnippet(languageService, getSourceFile(), markerPos, defaultConfigFunc)
+    const methodSnippet = constructMethodSnippet(languageService, getSourceFile(), markerPos, defaultConfigFunc, false)
+    if (methodSnippet === 'ambiguous') {
+        expect(methodSnippet).toEqual(expected)
+        return
+    }
     const snippetToInsert = methodSnippet ? `(${methodSnippet.join(', ')})` : null
     expect(Array.isArray(expected) ? methodSnippet : snippetToInsert, `At marker ${marker}`).toEqual(expected)
 }
@@ -254,6 +258,20 @@ describe('Method snippets', () => {
         compareMethodSnippetAgainstMarker(markers, 2, [''])
         settingsOverride['methodSnippets.skip'] = 'no-skip'
     })
+
+    test('Ambiguous', () => {
+        const [, _, markers] = fileContentsSpecialPositions(/* ts */ `
+            declare const a: {
+                (): void
+                [a: string]: 5
+            }
+            a/*1*/
+            Object/*2*/
+        `)
+
+        compareMethodSnippetAgainstMarker(markers, 1, 'ambiguous')
+        compareMethodSnippetAgainstMarker(markers, 2, 'ambiguous')
+    })
 })
 
 test('Emmet completion', () => {

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ export type RequestResponseTypes = {`
`77`	`77`	`}`
`78`	`78`	`turnArrayIntoObjectEdit: ts.TextChange[]`
`79`	`79`	`getFixAllEdits: ts.TextChange[]`
`80`		`- getFullMethodSnippet: string[] \| undefined`
	`80`	`+ getFullMethodSnippet: string[] \| 'ambiguous' \| undefined`
`81`	`81`	`getExtendedCodeActionEdits: ApplyExtendedCodeActionResult`
`82`	`82`	`}`
`83`	`83`
`@@ -110,6 +110,9 @@ export type RequestOptionsTypes = {`
`110`	`110`	`range: [number, number]`
`111`	`111`	`applyCodeActionTitle: string`
`112`	`112`	`}`
	`113`	`+ getFullMethodSnippet: {`
	`114`	`+ acceptAmbiguous: boolean`
	`115`	`+ }`
`113`	`116`	`}`
`114`	`117`
`115`	`118`	`// export type EmmetResult = {`