fix: hardly cache API responses, now we make as few requests as possible to TS server. eg now thousands of extensions can use api in completion providers without affecting performance

fix: also allow to pass document and position (offset alternative) in API commands options as second arg

Author: zardoy

src/apiCommands.ts

@@ -4,17 +4,53 @@ import { passthroughExposedApiCommands, TriggerCharacterCommand } from '../types
 import { sendCommand } from './sendCommand'
 
 export default () => {
-    const sharedRequest = (type: TriggerCharacterCommand, { offset, relativeOffset = 0 }: RequestOptions) => {
+    /** @unique */
+    const cacheableCommands: Set<typeof passthroughExposedApiCommands[number]> = new Set(['getNodePath', 'getSpanOfEnclosingComment', 'getNodeAtPosition'])
+    const operationsCache = new Map<string, { key: string; data }>()
+    const sharedRequest = async (type: TriggerCharacterCommand, { offset, relativeOffset = 0, document, position }: RequestOptions) => {
+        if (position && offset) throw new Error('Only position or offset parameter can be provided')
+        if (document && !offset && !position) throw new Error('When custom document is provided, offset or position must be provided')
+
         const { activeTextEditor } = vscode.window
-        if (!activeTextEditor) return
-        const { document, selection } = activeTextEditor
-        offset ??= document.offsetAt(selection.active) + relativeOffset
-        return sendCommand(type, { document, position: document.positionAt(offset) })
+        document ??= activeTextEditor?.document
+        if (!document) return
+        if (!position) offset ??= document.offsetAt(activeTextEditor!.selection.active) + relativeOffset
+        const requestOffset = offset ?? document.offsetAt(position!)
+        const requestPos = position ?? document.positionAt(offset!)
+        const getData = async () => sendCommand(type, { document: document!, position: requestPos })
+        if (cacheableCommands.has(type as any)) {
+            const cacheEntry = operationsCache.get(type)
+            const operationKey = `${document.uri.toString()}:${document.version}:${requestOffset}`
+            if (cacheEntry?.key === operationKey) {
+                return cacheEntry.data
+            }
+
+            const data = getData()
+            // intentionally storing data only per one offset because it was created for this specific case:
+            // extension 1 completion provider requests API data
+            // at the same time:
+            // extension 2 completion provider requests API data at the same document and position
+            // and so on
+            operationsCache.set(type, { key: operationKey, data })
+            if (type === 'getNodePath') {
+                operationsCache.set('getNodeAtPosition', { key: operationKey, data: data.then((path: any) => path[path.length - 1]) })
+            }
+
+            return data
+        }
+
+        return getData()
     }
 
     type RequestOptions = Partial<{
+        /**
+         * Should be rarely overrided, this document must be part of opened project
+         * If specificed, offset or position must be provided too
+         */
+        document: vscode.TextDocument
         offset: number
         relativeOffset: number
+        position: vscode.Position
     }>
     for (const cmd of passthroughExposedApiCommands)
         vscode.commands.registerCommand(getExtensionCommandId(cmd as never), async (options: RequestOptions = {}) => sharedRequest(cmd, options))

typescript/src/specialCommands/handle.ts

@@ -46,6 +46,7 @@ export default (
         }
     }
     if (specialCommand === 'getNodeAtPosition') {
+        // ensure return data is the same as for node in getNodePath
         const node = findChildContainingPosition(ts, sourceFile, position)
         return {
             entries: [],