fix: rewrite method-snippets so they are faster and compatible with Windows on latest vscode release. Now they are resolved when showing documentation (much earlier), instead of when completion accepted.

zardoy · zardoy · commit 20c53f4eb8dd · 2023-04-05T19:31:58.000+03:00
diff --git a/src/onCompletionAccepted.ts b/src/onCompletionAccepted.ts
@@ -13,7 +13,7 @@ export default (tsApi: { onCompletionAccepted }) => {
     let onCompletionAcceptedOverride: ((item: any) => void) | undefined
 
     // eslint-disable-next-line complexity
-    tsApi.onCompletionAccepted(async (item: vscode.CompletionItem & { document: vscode.TextDocument }) => {
+    tsApi.onCompletionAccepted(async (item: vscode.CompletionItem & { document: vscode.TextDocument; tsEntry }) => {
         if (onCompletionAcceptedOverride) {
             onCompletionAcceptedOverride(item)
             return
@@ -36,57 +36,56 @@ export default (tsApi: { onCompletionAccepted }) => {
             return
         }
 
-        const enableMethodSnippets = vscode.workspace.getConfiguration(process.env.IDS_PREFIX, item.document).get('enableMethodSnippets')
-
-        if (enableMethodSnippets && /* snippet by vscode or by us to ignore pos */ typeof insertText !== 'object') {
+        if (/* snippet is by vscode or by us to ignore pos */ typeof insertText !== 'object') {
             const editor = getActiveRegularEditor()!
-            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', {
-                    inputOptions: {
-                        acceptAmbiguous: lastAcceptedAmbiguousMethodSnippetSuggestion === suggestionName,
-                    } satisfies RequestOptionsTypes['getFullMethodSnippet'],
+            if (item.tsEntry.source) {
+                await new Promise<void>(resolve => {
+                    vscode.workspace.onDidChangeTextDocument(({ document }) => {
+                        if (editor.document !== document) return
+                        resolve()
+                    })
                 })
+                await new Promise(resolve => {
+                    setTimeout(resolve, 0)
+                })
+            }
 
-                if (controller.signal.aborted) return
-                if (params === 'ambiguous') {
-                    lastAcceptedAmbiguousMethodSnippetSuggestion = suggestionName
-                    return
-                }
-
-                if (!params) {
-                    return
-                }
+            const documentation = typeof item.documentation === 'object' ? item.documentation.value : item.documentation
+            const dataMarker = '<!--tep '
+            if (!documentation?.startsWith(dataMarker)) return
+            const parsed = JSON.parse(documentation.slice(dataMarker.length, documentation.indexOf('e-->')))
+            const { methodSnippet: params, isAmbiguous } = parsed
+            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 (isAmbiguous && lastAcceptedAmbiguousMethodSnippetSuggestion !== suggestionName) {
+                lastAcceptedAmbiguousMethodSnippetSuggestion = suggestionName
+                return
+            }
 
-                    if (i !== params.length - 1) snippet.appendText(', ')
+            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)
                 }
 
-                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 (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')
             }
         }
     })
diff --git a/typescript/src/completionEntryDetails.ts b/typescript/src/completionEntryDetails.ts
@@ -1,4 +1,5 @@
 import { PrevCompletionMap, PrevCompletionsAdditionalData } from './completionsAtPosition'
+import constructMethodSnippet from './constructMethodSnippet'
 import { RequestResponseTypes } from './ipcTypes'
 import namespaceAutoImports from './namespaceAutoImports'
 import { GetConfig } from './types'
@@ -12,7 +13,7 @@ export default function completionEntryDetails(
     languageService: ts.LanguageService,
     prevCompletionsMap: PrevCompletionMap,
     c: GetConfig,
-    prevCompletionsAdittionalData: PrevCompletionsAdditionalData,
+    { enableMethodCompletion, completionsSymbolMap }: PrevCompletionsAdditionalData,
 ): ts.CompletionEntryDetails | undefined {
     const [fileName, position, entryName, formatOptions, source, preferences, data] = inputArgs
     lastResolvedCompletion.value = { name: entryName }
@@ -48,6 +49,23 @@ export default function completionEntryDetails(
         prior.displayParts = [{ kind: 'text', text: detailPrepend }, ...prior.displayParts]
     }
     if (!prior) return
+    const nextChar = sourceFile.getFullText().slice(position, position + 1)
+
+    if (enableMethodCompletion && c('enableMethodSnippets') && !['(', '.', '`'].includes(nextChar)) {
+        const symbol = completionsSymbolMap.get(entryName)?.find(c => c.source === source)?.symbol
+        if (symbol) {
+            const resolveData = {
+                isAmbiguous: false,
+            }
+            console.time('resolve methodSnippet')
+            const methodSnippet = constructMethodSnippet(languageService, sourceFile, position, symbol, c, resolveData)
+            console.timeEnd('resolve methodSnippet')
+            if (methodSnippet) {
+                const data = JSON.stringify({ methodSnippet, isAmbiguous: resolveData.isAmbiguous })
+                prior.documentation = [{ kind: 'text', text: `<!--tep ${data} e-->` }, ...(prior.documentation ?? [])]
+            }
+        }
+    }
     if (source) {
         const namespaceImport = namespaceAutoImports(
             c,
diff --git a/typescript/src/completionsAtPosition.ts b/typescript/src/completionsAtPosition.ts
@@ -45,6 +45,7 @@ export type PrevCompletionMap = Record<
 >
 export type PrevCompletionsAdditionalData = {
     enableMethodCompletion: boolean
+    completionsSymbolMap: Map</*entryName*/ string, Array<{ symbol: ts.Symbol; source?: string }>>
 }
 
 type GetCompletionAtPositionReturnType = {
@@ -363,14 +364,28 @@ export const getCompletionsAtPosition = (
         prior.entries = prior.entries.map(({ ...entry }, index) => ({
             ...entry,
             sortText: `${entry.sortText ?? ''}${index.toString().padStart(4, '0')}`,
-            symbol: undefined,
         }))
     }
+    const needsCompletionsSymbolMap = c('enableMethodSnippets')
+    const completionsSymbolMap: PrevCompletionsAdditionalData['completionsSymbolMap'] = new Map()
+    if (needsCompletionsSymbolMap) {
+        for (const { name, source, symbol } of prior.entries) {
+            if (!symbol) continue
+            completionsSymbolMap.set(name, [
+                ...(completionsSymbolMap.get(name) ?? []),
+                {
+                    symbol,
+                    source,
+                },
+            ])
+        }
+    }
     return {
         completions: prior,
         prevCompletionsMap,
         prevCompletionsAdittionalData: {
             enableMethodCompletion: goodPositionForMethodCompletions,
+            completionsSymbolMap,
         },
     }
 }
diff --git a/typescript/src/constructMethodSnippet.ts b/typescript/src/constructMethodSnippet.ts
@@ -4,18 +4,30 @@ import { GetConfig } from './types'
 import { findChildContainingExactPosition } from './utils'
 
 // 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
+export default (
+    languageService: ts.LanguageService,
+    sourceFile: ts.SourceFile,
+    position: number,
+    symbol: ts.Symbol,
+    c: GetConfig,
+    // acceptAmbiguous: boolean,
+    resolveData: {
+        isAmbiguous: boolean
+    },
+) => {
+    let containerNode = findChildContainingExactPosition(sourceFile, position)
+    if (!containerNode || isTypeNode(containerNode)) return
 
     const checker = languageService.getProgram()!.getTypeChecker()!
-    const type = checker.getTypeAtLocation(node)
+    const type = checker.getTypeOfSymbol(symbol)
 
-    if (ts.isIdentifier(node)) node = node.parent
-    if (ts.isPropertyAccessExpression(node)) node = node.parent
+    if (ts.isIdentifier(containerNode)) containerNode = containerNode.parent
+    if (ts.isPropertyAccessExpression(containerNode)) containerNode = containerNode.parent
 
-    const isNewExpression = ts.isNewExpression(node)
-    if (!isNewExpression && !acceptAmbiguous && (type.getProperties().length > 0 || type.getStringIndexType() || type.getNumberIndexType())) return 'ambiguous'
+    const isNewExpression = ts.isNewExpression(containerNode)
+    if (!isNewExpression && (type.getProperties().length > 0 || type.getStringIndexType() || type.getNumberIndexType())) {
+        resolveData.isAmbiguous = true
+    }
 
     const signatures = checker.getSignaturesOfType(type, isNewExpression ? ts.SignatureKind.Construct : ts.SignatureKind.Call)
     // ensure node is not used below
diff --git a/typescript/src/ipcTypes.ts b/typescript/src/ipcTypes.ts
@@ -13,7 +13,6 @@ export const triggerCharacterCommands = [
     'twoStepCodeActionSecondStep',
     'getFixAllEdits',
     'acceptRenameWithParams',
-    'getFullMethodSnippet',
     'getExtendedCodeActionEdits',
     'getLastResolvedCompletion',
 ] as const
@@ -78,7 +77,6 @@ export type RequestResponseTypes = {
           }
     turnArrayIntoObjectEdit: ts.TextChange[]
     getFixAllEdits: ts.TextChange[]
-    getFullMethodSnippet: string[] | 'ambiguous' | undefined
     getExtendedCodeActionEdits: ApplyExtendedCodeActionResult
     getLastResolvedCompletion: {
         name: string
@@ -114,9 +112,6 @@ 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
@@ -94,16 +94,6 @@ export default (
         const node = findChildContainingPosition(ts, sourceFile, position)
         return !node ? undefined : nodeToApiResponse(node)
     }
-    if (specialCommand === '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)
     }
