Adapts procedure registry to depend on the cypher version

package.json

@@ -35,6 +35,7 @@
   "devDependencies": {
     "@changesets/cli": "^2.27.8",
     "@typescript-eslint/eslint-plugin": "^7.8.0",
+    "cross-env": "^7.0.3",
     "eslint": "^8.32.0",
     "eslint-config-prettier": "^8.6.0",
     "husky": "^8.0.0",

packages/language-support/package.json

@@ -48,7 +48,7 @@
     "vscode-languageserver-types": "^3.17.3"
   },
   "scripts": {
-    "gen-parser": "ANTLR4_TOOLS_ANTLR_VERSION=4.13.2 antlr4 -Dlanguage=TypeScript -visitor src/antlr-grammar/CypherCmdLexer.g4 src/antlr-grammar/CypherCmdParser.g4 -o src/generated-parser/ -Xexact-output-dir",
+    "gen-parser": "cross-env ANTLR4_TOOLS_ANTLR_VERSION=4.13.2 antlr4 -Dlanguage=TypeScript -visitor src/antlr-grammar/CypherCmdLexer.g4 src/antlr-grammar/CypherCmdParser.g4 -o src/generated-parser/ -Xexact-output-dir",
     "build": "npm run gen-parser && concurrently 'npm:build-types' 'npm:build-esm' 'npm:build-commonjs'",
     "build-types": "tsc --emitDeclarationOnly --outDir dist/types",
     "build-esm": "esbuild ./src/index.ts --bundle --format=esm --sourcemap --outfile=dist/esm/index.mjs",

packages/language-support/src/autocompletion/completionCoreCompletions.ts

@@ -103,7 +103,7 @@ const procedureReturnCompletions = (
   cypherVersion: CypherVersion,
 ): CompletionItem[] => {
   return (
-    dbSchema?.procedures?.[cypherVersion]?.[
+    dbSchema.procedures?.[cypherVersion]?.[
       procedureName
     ]?.returnDescription?.map((x) => {
       return { label: x.name, kind: CompletionItemKind.Variable };
@@ -120,7 +120,7 @@ const functionNameCompletions = (
   namespacedCompletion(
     candidateRule,
     tokens,
-    dbSchema?.functions?.[cypherVersion] ?? {},
+    dbSchema.functions?.[cypherVersion] ?? {},
     'function',
   );
 
@@ -133,7 +133,7 @@ const procedureNameCompletions = (
   namespacedCompletion(
     candidateRule,
     tokens,
-    dbSchema?.procedures?.[cypherVersion] ?? {},
+    dbSchema.procedures?.[cypherVersion] ?? {},
     'procedure',
   );
 
@@ -796,7 +796,7 @@ function completeAliasName({
   ) {
     return [
       ...parameterSuggestions,
-      ...(dbSchema?.aliasNames ?? []).map((aliasName) => ({
+      ...(dbSchema.aliasNames ?? []).map((aliasName) => ({
         label: aliasName,
         kind: CompletionItemKind.Value,
         insertText: backtickDbNameIfNeeded(aliasName),
@@ -861,7 +861,7 @@ function completeSymbolicName({
   if (rulesThatAcceptExistingUsers.some((rule) => ruleList.includes(rule))) {
     const result = [
       ...parameterSuggestions,
-      ...(dbSchema?.userNames ?? []).map((userName) => ({
+      ...(dbSchema.userNames ?? []).map((userName) => ({
         label: userName,
         kind: CompletionItemKind.Value,
       })),
@@ -879,7 +879,7 @@ function completeSymbolicName({
   if (rulesThatAcceptExistingRoles.some((rule) => ruleList.includes(rule))) {
     return [
       ...parameterSuggestions,
-      ...(dbSchema?.roleNames ?? []).map((roleName) => ({
+      ...(dbSchema.roleNames ?? []).map((roleName) => ({
         label: roleName,
         kind: CompletionItemKind.Value,
       })),

packages/language-support/src/dbSchema.ts

@@ -1,5 +1,8 @@
 import { CypherVersion, Neo4jFunction, Neo4jProcedure } from './types';
 
+export type Registry<T> = Record<string, T>;
+type ScopedRegistry<T> = Partial<Record<CypherVersion, Registry<T>>>;
+
 export interface DbSchema {
   labels?: string[];
   relationshipTypes?: string[];
@@ -9,7 +12,7 @@ export interface DbSchema {
   roleNames?: string[];
   parameters?: Record<string, unknown>;
   propertyKeys?: string[];
-  procedures?: Partial<Record<CypherVersion, Record<string, Neo4jProcedure>>>;
-  functions?: Partial<Record<CypherVersion, Record<string, Neo4jFunction>>>;
+  procedures?: ScopedRegistry<Neo4jProcedure>;
+  functions?: ScopedRegistry<Neo4jFunction>;
   defaultLanguage?: CypherVersion;
 }

packages/language-support/src/formatting/formatting.ts

@@ -399,7 +399,7 @@ export function formatQuery(
 ): string | FormattingResultWithCursor {
   const { tree, tokens } = getParseTreeAndTokens(query);
   const visitor = new TreePrintVisitor(tokens);
-  
+
   tokens.fill();
 
   if (cursorPosition === undefined) return visitor.format(tree);

packages/language-support/src/helpers.ts

@@ -212,8 +212,7 @@ export function resolveCypherVersion(
 ) {
   if (_internalFeatureFlags.cypher25) {
     const cypherVersion: CypherVersion =
-      parsedVersion ??
-      (dbSchema.defaultLanguage ? dbSchema.defaultLanguage : 'CYPHER 5');
+      parsedVersion ?? dbSchema.defaultLanguage ?? 'CYPHER 5';
 
     return cypherVersion;
   } else {

packages/language-support/src/index.ts

@@ -3,6 +3,7 @@ export { autocomplete } from './autocompletion/autocompletion';
 export { shouldAutoCompleteYield } from './autocompletion/autocompletionHelpers';
 export type { DbSchema } from './dbSchema';
 export { _internalFeatureFlags } from './featureFlags';
+export { formatQuery } from './formatting/formatting';
 export { antlrUtils } from './helpers';
 export { CypherTokenType, lexerSymbols } from './lexerSymbols';
 export { parse, parserWrapper, parseStatementsStrs } from './parserWrapper';
@@ -27,4 +28,3 @@ export type {
 export { CypherLexer, CypherParser };
 import CypherLexer from './generated-parser/CypherCmdLexer';
 import CypherParser from './generated-parser/CypherCmdParser';
-export { formatQuery } from './formatting/formatting'

packages/language-support/src/signatureHelp.ts

@@ -206,12 +206,12 @@ export function signatureHelp(
         );
         if (method.methodType === MethodType.function) {
           result = toSignatureHelp(
-            dbSchema?.functions?.[cypherVersion] ?? {},
+            dbSchema.functions?.[cypherVersion] ?? {},
             method,
           );
         } else {
           result = toSignatureHelp(
-            dbSchema?.procedures?.[cypherVersion] ?? {},
+            dbSchema.procedures?.[cypherVersion] ?? {},
             method,
           );
         }

packages/language-support/src/syntaxValidation/semanticAnalysisWrapper.ts

@@ -3,8 +3,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 
 import { DiagnosticSeverity, Position } from 'vscode-languageserver-types';
-import { DbSchema } from '../dbSchema';
-import { CypherVersion, cypherVersions } from '../types';
+import { DbSchema, Registry } from '../dbSchema';
+import { CypherVersion, Neo4jFunction, Neo4jProcedure } from '../types';
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import { analyzeQuery, updateSignatureResolver } from './semanticAnalysis';
@@ -29,7 +29,12 @@ export interface SemanticAnalysisElement {
   };
 }
 
-let previousSchema: DbSchema | undefined = undefined;
+const previousResolvers: {
+  [cypherVersion: CypherVersion]: {
+    functions: Registry<Neo4jFunction>;
+    procedures: Registry<Neo4jProcedure>;
+  };
+} = {};
 
 function copySettingSeverity(
   elements: SemanticAnalysisElement[],
@@ -49,44 +54,41 @@ function copySettingSeverity(
   }));
 }
 
+function updateResolverForVersion(
+  dbSchema: DbSchema,
+  cypherVersion: CypherVersion,
+) {
+  const previousResolver = previousResolvers?.[cypherVersion];
+  const currentResolver = {
+    procedures: dbSchema?.procedures?.[cypherVersion],
+    functions: dbSchema?.functions?.[cypherVersion],
+  };
+  if (JSON.stringify(previousResolver) !== JSON.stringify(currentResolver)) {
+    previousResolvers[cypherVersion] = currentResolver;
+    const procedures = Object.values(
+      dbSchema?.procedures?.[cypherVersion] ?? {},
+    );
+    const functions = Object.values(dbSchema?.functions?.[cypherVersion] ?? {});
+    updateSignatureResolver(
+      {
+        procedures: procedures,
+        functions: functions,
+      },
+      cypherVersion,
+    );
+  }
+}
+
 export function wrappedSemanticAnalysis(
   query: string,
   dbSchema: DbSchema,
   parsedVersion?: CypherVersion,
 ): SemanticAnalysisResult {
   try {
-    if (JSON.stringify(dbSchema) !== JSON.stringify(previousSchema)) {
-      previousSchema = dbSchema;
-
-      cypherVersions.forEach((cypherVersion) => {
-        const procedures = Object.values(
-          dbSchema?.procedures?.[cypherVersion] ?? {},
-        );
-        const functions = Object.values(
-          dbSchema?.functions?.[cypherVersion] ?? {},
-        );
-        updateSignatureResolver(
-          {
-            procedures: procedures,
-            functions: functions,
-          },
-          cypherVersion,
-        );
-      });
-    }
-
-    let cypherVersion = 'CYPHER 5';
-    const defaultVersion = dbSchema.defaultLanguage?.toUpperCase();
-
-    if (parsedVersion) {
-      cypherVersion = parsedVersion;
-    } else if (dbSchema.defaultLanguage) {
-      cypherVersion = defaultVersion;
-    }
-    const semanticErrorsResult = analyzeQuery(
-      query,
-      cypherVersion.toLowerCase(),
-    );
+    const defaultVersion = dbSchema?.defaultLanguage;
+    const cypherVersion = parsedVersion ?? defaultVersion ?? 'CYPHER 5';
+    updateResolverForVersion(dbSchema, cypherVersion);
+    const semanticErrorsResult = analyzeQuery(query, cypherVersion);
     const errors: SemanticAnalysisElement[] = semanticErrorsResult.errors;
     const notifications: SemanticAnalysisElement[] =
       semanticErrorsResult.notifications;

packages/language-support/src/tests/autocompletion/functionsCompletion.test.ts

@@ -8,12 +8,15 @@ import { testData } from '../testData';
 import { testCompletions } from './completionAssertionHelpers';
 
 describe('function invocations', () => {
+  let isCypher25: boolean;
+
   beforeAll(() => {
+    isCypher25 = _internalFeatureFlags.cypher25;
     _internalFeatureFlags.cypher25 = true;
   });
 
   afterAll(() => {
-    _internalFeatureFlags.cypher25 = false;
+    _internalFeatureFlags.cypher25 = isCypher25;
   });
 
   const dbSchema: DbSchema = testData.mockSchema;

packages/language-support/src/tests/autocompletion/procedureCompletion.test.ts

@@ -8,12 +8,15 @@ import { testData } from '../testData';
 import { testCompletions } from './completionAssertionHelpers';
 
 describe('Procedures auto-completion', () => {
+  let isCypher25: boolean;
+
   beforeAll(() => {
+    isCypher25 = _internalFeatureFlags.cypher25;
     _internalFeatureFlags.cypher25 = true;
   });
 
   afterAll(() => {
-    _internalFeatureFlags.cypher25 = false;
+    _internalFeatureFlags.cypher25 = isCypher25;
   });
 
   const procedures = testData.mockSchema.procedures;

packages/language-support/src/tests/consoleCommands.test.ts

@@ -36,12 +36,15 @@ function expectErrorMessage(query: string, msg: string) {
 }
 
 describe('sanity checks', () => {
+  let consoleCommands: boolean;
+
   beforeAll(() => {
+    consoleCommands = _internalFeatureFlags.consoleCommands;
     _internalFeatureFlags.consoleCommands = true;
   });
 
   afterAll(() => {
-    _internalFeatureFlags.consoleCommands = false;
+    _internalFeatureFlags.consoleCommands = consoleCommands;
   });
 
   test('parses simple commands without args ', () => {
@@ -219,11 +222,14 @@ describe('sanity checks', () => {
 });
 
 describe(':use', () => {
+  let consoleCommands: boolean;
+
   beforeAll(() => {
+    consoleCommands = _internalFeatureFlags.consoleCommands;
     _internalFeatureFlags.consoleCommands = true;
   });
   afterAll(() => {
-    _internalFeatureFlags.consoleCommands = false;
+    _internalFeatureFlags.consoleCommands = consoleCommands;
   });
   test('parses without arg', () => {
     expectParsedCommands(':use', [{ type: 'use' }]);
@@ -285,11 +291,14 @@ describe(':use', () => {
 });
 
 describe('parameters', () => {
+  let consoleCommands: boolean;
+
   beforeAll(() => {
+    consoleCommands = _internalFeatureFlags.consoleCommands;
     _internalFeatureFlags.consoleCommands = true;
   });
   afterAll(() => {
-    _internalFeatureFlags.consoleCommands = false;
+    _internalFeatureFlags.consoleCommands = consoleCommands;
   });
   test('basic param usage', () => {
     expectParsedCommands(':param', [{ type: 'list-parameters' }]);
@@ -550,12 +559,15 @@ describe('parameters', () => {
 });
 
 describe('server', () => {
+  let consoleCommands: boolean;
+
   beforeAll(() => {
+    consoleCommands = _internalFeatureFlags.consoleCommands;
     _internalFeatureFlags.consoleCommands = true;
   });
 
   afterAll(() => {
-    _internalFeatureFlags.consoleCommands = false;
+    _internalFeatureFlags.consoleCommands = consoleCommands;
   });
 
   test('basic server usage', () => {
@@ -655,12 +667,17 @@ describe('server', () => {
 });
 
 describe('command parser also handles cypher', () => {
+  let consoleCommands: boolean;
+
   beforeAll(() => {
+    consoleCommands = _internalFeatureFlags.consoleCommands;
     _internalFeatureFlags.consoleCommands = true;
   });
+
   afterAll(() => {
-    _internalFeatureFlags.consoleCommands = false;
+    _internalFeatureFlags.consoleCommands = consoleCommands;
   });
+
   test('parses cypher', () => {
     expectParsedCommands('MATCH (n) RETURN n', [
       { statement: 'MATCH (n) RETURN n', type: 'cypher' },