Calculate the symbol table separately from debounced linting (#584)

anderson4j · web-flow · commit 3b2a8503c18c · 2025-10-15T11:35:13.000+02:00
diff --git a/packages/language-server/src/linting.ts b/packages/language-server/src/linting.ts
@@ -2,6 +2,7 @@ import {
   _internalFeatureFlags,
   clampUnsafePositions,
   parserWrapper,
+  SymbolTable,
 } from '@neo4j-cypher/language-support';
 import { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
 import debounce from 'lodash.debounce';
@@ -19,7 +20,7 @@ const defaultWorkerPath = join(__dirname, 'lintWorker.cjs');
 
 let pool = workerpool.pool(defaultWorkerPath, {
   minWorkers: 2,
-  workerTerminateTimeout: 2000,
+  workerTerminateTimeout: 0,
 });
 export let workerPath = defaultWorkerPath;
 let linterVersion: string | undefined = undefined;
@@ -37,14 +38,15 @@ export async function setLintWorker(
     linterVersion = linter;
     pool = workerpool.pool(workerPath, {
       minWorkers: 2,
-      workerTerminateTimeout: 2000,
+      workerTerminateTimeout: 0,
     });
   }
 }
 
 async function rawLintDocument(
   document: TextDocument,
   sendDiagnostics: (diagnostics: Diagnostic[]) => void,
+  notifySymbolTableDone: (symbolTable: SymbolTable[]) => Promise<void>,
   neo4j: Neo4jSchemaPoller,
 ) {
   const query = document.getText();
@@ -67,7 +69,6 @@ async function rawLintDocument(
       fixedDbSchema,
       _internalFeatureFlags,
     );
-
     const result = await lastSemanticJob;
 
     //marks the entire text if any position is negative
@@ -78,10 +79,13 @@ async function rawLintDocument(
 
     // Pass the computed symbol tables to the parser
     if (result.symbolTables) {
-      parserWrapper.setSymbolsInfo({
-        query,
-        symbolTables: result.symbolTables,
-      });
+      parserWrapper.setSymbolsInfo(
+        {
+          query,
+          symbolTables: result.symbolTables,
+        },
+        notifySymbolTableDone,
+      );
     }
 
     sendDiagnostics(positionSafeResult);
diff --git a/packages/language-server/src/server.ts b/packages/language-server/src/server.ts
@@ -11,7 +11,12 @@ import {
 } from 'vscode-languageserver/node';
 
 import { TextDocument } from 'vscode-languageserver-textdocument';
-import { syntaxColouringLegend } from '@neo4j-cypher/language-support';
+import {
+  DbSchema,
+  parserWrapper,
+  SymbolTable,
+  syntaxColouringLegend,
+} from '@neo4j-cypher/language-support';
 import { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
 import { doAutoCompletion } from './autocompletion';
 import { formatDocument } from './formatting';
@@ -24,15 +29,82 @@ import {
   Neo4jParameters,
   Neo4jSettings,
 } from './types';
+import workerpool from 'workerpool';
+import { join } from 'path';
+import { LintWorker } from '@neo4j-cypher/lint-worker';
+
+class SymbolFetcher {
+  private processing = false;
+  private nextJob: {
+    query: string;
+    uri: string;
+    schema: DbSchema;
+  };
+  private defaultWorkerPath = join(__dirname, 'lintWorker.cjs');
+  private symbolTablePool = workerpool.pool(this.defaultWorkerPath, {
+    maxWorkers: 1,
+    workerTerminateTimeout: 0,
+  });
+
+  public queueSymbolJob(query: string, uri: string, schema: DbSchema) {
+    this.nextJob = { query, uri, schema };
+    if (!this.processing) {
+      void this.processJobQueue();
+    }
+  }
+
+  private async processJobQueue() {
+    this.processing = true;
+    const proxyWorker =
+      (await this.symbolTablePool.proxy()) as unknown as LintWorker;
+    while (this.nextJob) {
+      try {
+        const query = this.nextJob.query;
+        const dbSchema = this.nextJob.schema;
+        const docUri = this.nextJob.uri;
+        this.nextJob = undefined;
+
+        const result = await proxyWorker.lintCypherQuery(query, dbSchema);
+
+        if (
+          //if this.nextJob has new doc, our result is no longer valid
+          result.symbolTables &&
+          !(this.nextJob && this.nextJob.uri != docUri)
+        ) {
+          parserWrapper.setSymbolsInfo(
+            {
+              query,
+              symbolTables: result.symbolTables,
+            },
+            async (symbolTables: SymbolTable[]) =>
+              await connection.sendNotification('symbolTableDone', {
+                symbolTables,
+              }),
+          );
+        }
+      } catch (e) {
+        //eslint-disable-next-line
+        console.log('Symbol table calculation failed');
+      }
+    }
+    this.processing = false;
+  }
+}
 
 const connection = createConnection(ProposedFeatures.all);
 let settings: Neo4jSettings | undefined = undefined;
 
 // Create a simple text document manager.
 const documents: TextDocuments<TextDocument> = new TextDocuments(TextDocument);
 const neo4jSchemaPoller = new Neo4jSchemaPoller();
+const symbolFetcher = new SymbolFetcher();
 
 async function lintSingleDocument(document: TextDocument): Promise<void> {
+  symbolFetcher.queueSymbolJob(
+    document.getText(),
+    document.uri,
+    neo4jSchemaPoller?.metadata?.dbSchema,
+  );
   if (settings?.features?.linting) {
     return lintDocument(
       document,
@@ -42,6 +114,10 @@ async function lintSingleDocument(document: TextDocument): Promise<void> {
           diagnostics,
         });
       },
+      async (symbolTables: SymbolTable[]) =>
+        await connection.sendNotification('symbolTableDone', {
+          symbolTables: symbolTables,
+        }),
       neo4jSchemaPoller,
     );
   } else {
@@ -141,6 +217,25 @@ connection.onNotification(
   },
 );
 
+connection.onNotification(
+  'fetchSymbolTable',
+  (params: {
+    query: string;
+    uri: string;
+    version: number;
+    schema: DbSchema;
+  }) => {
+    neo4jSchemaPoller.events.once(
+      'schemaFetched',
+      void symbolFetcher.queueSymbolJob(
+        params.query,
+        params.uri,
+        params.schema,
+      ),
+    );
+  },
+);
+
 connection.onNotification('updateParameters', (parameters: Neo4jParameters) => {
   neo4jSchemaPoller.setParameters(parameters);
   relintAllDocuments();
diff --git a/packages/language-server/src/types.ts b/packages/language-server/src/types.ts
@@ -1,3 +1,5 @@
+import { DbSchema } from '@neo4j-cypher/language-support';
+
 // These settings are defined in the package.json
 export type Neo4jConnectionSettings = {
   connect?: boolean;
@@ -12,6 +14,12 @@ export type LintWorkerSettings = {
   linterVersion: string;
 };
 
+export type SymbolFetchingParams = {
+  query: string;
+  uri: string;
+  schema: DbSchema;
+};
+
 export type Neo4jSettings = {
   trace: {
     server: 'off' | 'messages' | 'verbose';
diff --git a/packages/language-support/src/parserWrapper.ts b/packages/language-support/src/parserWrapper.ts
@@ -41,6 +41,7 @@ import {
   cypherVersionNumbers,
   allCypherVersions,
   SymbolsInfo,
+  SymbolTable,
 } from './types';
 
 export interface ParsedStatement {
@@ -820,7 +821,12 @@ class ParserWrapper {
     this.symbolsInfo = undefined;
   }
 
-  setSymbolsInfo(symbolsInfo: SymbolsInfo) {
+  setSymbolsInfo(
+    symbolsInfo: SymbolsInfo,
+    sendMessage?: (symbolTables: SymbolTable[]) => Promise<void>,
+  ) {
+    if (_internalFeatureFlags.schemaBasedPatternCompletion && sendMessage)
+      void sendMessage(symbolsInfo.symbolTables);
     this.symbolsInfo = symbolsInfo;
   }
 }
diff --git a/packages/vscode-extension/src/contextService.ts b/packages/vscode-extension/src/contextService.ts
@@ -1,15 +1,21 @@
 import {
   LintWorkerSettings,
   Neo4jConnectionSettings,
+  SymbolFetchingParams,
 } from '@neo4j-cypher/language-server/src/types';
 import { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
 import { ExtensionContext } from 'vscode';
 import CypherRunner from './cypherRunner';
+import { SymbolTable } from '@neo4j-cypher/language-support';
 
 type LanguageClient = {
   sendNotification: (
     method: string,
-    settings?: Neo4jConnectionSettings | LintWorkerSettings,
+    params?:
+      | Neo4jConnectionSettings
+      | LintWorkerSettings
+      | { symbolTable: SymbolTable }
+      | SymbolFetchingParams,
   ) => Promise<void>;
 };
 
diff --git a/packages/vscode-extension/src/extension.ts b/packages/vscode-extension/src/extension.ts
@@ -18,11 +18,14 @@ import {
   disconnectDatabaseConnectionOnExtensionDeactivation,
   reconnectDatabaseConnectionOnExtensionActivation,
 } from './connectionService';
-import { setContext } from './contextService';
+import { getSchemaPoller, setContext } from './contextService';
 import { sendParametersToLanguageServer } from './parameterService';
 import { registerDisposables } from './registrationService';
+import { SymbolTable } from '@neo4j-cypher/language-support';
+import { sendNotificationToLanguageClient } from './languageClientService';
 
 let client: LanguageClient;
+let symbolTableVersion = 0;
 
 export const linterStatusBarItem = window.createStatusBarItem(
   StatusBarAlignment.Right,
@@ -96,6 +99,48 @@ export async function activate(context: ExtensionContext) {
 
     context.subscriptions.push(watcher);
   }
+
+  client.onNotification('symbolTableDone', (params) => {
+    symbolTableVersion++;
+    const symbolTables = (params as { symbolTables: SymbolTable[] })
+      .symbolTables;
+    void window.showInformationMessage(
+      'Calculated symbol table nbr' +
+        symbolTableVersion +
+        '\n' +
+        stringifySymbolTables(symbolTables),
+    );
+  });
+
+  window.onDidChangeActiveTextEditor((editor) => {
+    const doc = editor.document;
+    const query = doc.getText();
+    const uri = doc.uri.fsPath;
+    const schema = getSchemaPoller().metadata?.dbSchema;
+    void sendNotificationToLanguageClient('fetchSymbolTable', {
+      query,
+      uri,
+      schema,
+    });
+  });
+}
+
+function stringifySymbolTables(symbolTables: SymbolTable[]): string {
+  if (!symbolTables) {
+    return '';
+  }
+  return symbolTables
+    .map((symbolTable) => {
+      if (symbolTable.length == 0) {
+        return '';
+      }
+      let result = ' [';
+      symbolTable.map((symbol) => {
+        result += symbol.variable + ': ' + symbol.types.toString() + ', ';
+      });
+      return result.substring(0, result.length - 2) + ']';
+    })
+    .toString();
 }
 
 export async function deactivate(): Promise<void> | undefined {
diff --git a/packages/vscode-extension/src/languageClientService.ts b/packages/vscode-extension/src/languageClientService.ts
@@ -1,14 +1,18 @@
 import {
   LintWorkerSettings,
   Neo4jConnectionSettings,
+  SymbolFetchingParams,
 } from '@neo4j-cypher/language-server/src/types';
 import { getLanguageClient } from './contextService';
+import { SymbolTable } from '@neo4j-cypher/language-support';
 
 export type MethodName =
   | 'connectionUpdated'
   | 'connectionDisconnected'
   | 'updateParameters'
-  | 'updateLintWorker';
+  | 'updateLintWorker'
+  | 'symbolTableDone'
+  | 'fetchSymbolTable';
 
 /**
  * Communicates to the language client that a connection has been updated or disconnected and needs to take action.
@@ -17,8 +21,12 @@ export type MethodName =
  */
 export async function sendNotificationToLanguageClient(
   methodName: MethodName,
-  settings?: Neo4jConnectionSettings | LintWorkerSettings,
+  params?:
+    | Neo4jConnectionSettings
+    | LintWorkerSettings
+    | { symbolTable: SymbolTable }
+    | SymbolFetchingParams,
 ) {
   const languageClient = getLanguageClient();
-  await languageClient.sendNotification(methodName, settings);
+  await languageClient.sendNotification(methodName, params);
 }
diff --git a/packages/vscode-extension/tests/mocks/mockLanguageClient.ts b/packages/vscode-extension/tests/mocks/mockLanguageClient.ts
@@ -2,12 +2,19 @@ import {
   LintWorkerSettings,
   Neo4jConnectionSettings,
   Neo4jSettings,
+  SymbolFetchingParams,
 } from '@neo4j-cypher/language-server/src/types';
+import { SymbolTable } from '@neo4j-cypher/language-support';
 
 export class MockLanguageClient {
   async sendNotification(
     methodName: string,
-    settings?: LintWorkerSettings | Neo4jConnectionSettings | Neo4jSettings,
+    settings?:
+      | LintWorkerSettings
+      | Neo4jConnectionSettings
+      | Neo4jSettings
+      | { symbolTable: SymbolTable }
+      | SymbolFetchingParams,
   ): Promise<void> {
     if (settings) {
       if ('trace' in settings) {

Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@ import {`
`41`	`41`	`cypherVersionNumbers,`
`42`	`42`	`allCypherVersions,`
`43`	`43`	`SymbolsInfo,`
	`44`	`+ SymbolTable,`
`44`	`45`	`} from './types';`
`45`	`46`
`46`	`47`	`export interface ParsedStatement {`
`@@ -820,7 +821,12 @@ class ParserWrapper {`
`820`	`821`	`this.symbolsInfo = undefined;`
`821`	`822`	`}`
`822`	`823`
`823`		`- setSymbolsInfo(symbolsInfo: SymbolsInfo) {`
	`824`	`+ setSymbolsInfo(`
	`825`	`+ symbolsInfo: SymbolsInfo,`
	`826`	`+ sendMessage?: (symbolTables: SymbolTable[]) => Promise<void>,`
	`827`	`+ ) {`
	`828`	`+ if (_internalFeatureFlags.schemaBasedPatternCompletion && sendMessage)`
	`829`	`+ void sendMessage(symbolsInfo.symbolTables);`
`824`	`830`	`this.symbolsInfo = symbolsInfo;`
`825`	`831`	`}`
`826`	`832`	`}`