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-server/src/lintWorker.ts

@@ -1,6 +1,25 @@
-import { lintCypherQuery } from '@neo4j-cypher/language-support';
+import {
+  DbSchema,
+  lintCypherQuery as _lintCypherQuery,
+  _internalFeatureFlags,
+} from '@neo4j-cypher/language-support';
 import workerpool from 'workerpool';
 
+function lintCypherQuery(
+  query: string,
+  dbSchema: DbSchema,
+  featureFlags: { consoleCommands?: boolean; cypher25?: boolean } = {},
+) {
+  // We allow to override the consoleCommands feature flag
+  if (featureFlags.consoleCommands !== undefined) {
+    _internalFeatureFlags.consoleCommands = featureFlags.consoleCommands;
+  }
+  if (featureFlags.cypher25 !== undefined) {
+    _internalFeatureFlags.cypher25 = featureFlags.cypher25;
+  }
+  return _lintCypherQuery(query, dbSchema);
+}
+
 workerpool.worker({ lintCypherQuery });
 
 type LinterArgs = Parameters<typeof lintCypherQuery>;

packages/language-server/src/linting.ts

@@ -1,3 +1,4 @@
+import { _internalFeatureFlags } from '@neo4j-cypher/language-support';
 import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
 import debounce from 'lodash.debounce';
 import { join } from 'path';
@@ -31,7 +32,11 @@ async function rawLintDocument(
     }
 
     const proxyWorker = (await pool.proxy()) as unknown as LintWorker;
-    lastSemanticJob = proxyWorker.lintCypherQuery(query, dbSchema);
+    lastSemanticJob = proxyWorker.lintCypherQuery(
+      query,
+      dbSchema,
+      _internalFeatureFlags,
+    );
     const result = await lastSemanticJob;
 
     sendDiagnostics(result);

packages/language-server/src/server.ts

@@ -12,14 +12,21 @@ import {
 
 import { TextDocument } from 'vscode-languageserver-textdocument';
 
-import { syntaxColouringLegend } from '@neo4j-cypher/language-support';
+import {
+  syntaxColouringLegend,
+  _internalFeatureFlags,
+} from '@neo4j-cypher/language-support';
 import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
 import { doAutoCompletion } from './autocompletion';
 import { cleanupWorkers, lintDocument } from './linting';
 import { doSignatureHelp } from './signatureHelp';
 import { applySyntaxColouringForDocument } from './syntaxColouring';
 import { Neo4jSettings } from './types';
 
+if (process.env.CYPHER_25 === 'true') {
+  _internalFeatureFlags.cypher25 = true;
+}
+
 const connection = createConnection(ProposedFeatures.all);
 
 // Create a simple text document manager.

packages/language-support/package.json

@@ -48,7 +48,7 @@
     "vscode-languageserver-types": "^3.17.3"
   },
   "scripts": {
-    "gen-parser": "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

@@ -15,6 +15,7 @@ import CypherParser, {
 import {
   findParent,
   findPreviousNonSpace,
+  resolveCypherVersion,
   rulesDefiningVariables,
 } from '../helpers';
 import {
@@ -27,7 +28,12 @@ import {
 import { getMethodName, ParsedStatement } from '../parserWrapper';
 
 import { _internalFeatureFlags } from '../featureFlags';
-import { CompletionItem, Neo4jFunction, Neo4jProcedure } from '../types';
+import {
+  CompletionItem,
+  CypherVersion,
+  Neo4jFunction,
+  Neo4jProcedure,
+} from '../types';
 
 const uniq = <T>(arr: T[]) => Array.from(new Set(arr));
 
@@ -94,9 +100,12 @@ const reltypeCompletions = (dbSchema: DbSchema) =>
 const procedureReturnCompletions = (
   procedureName: string,
   dbSchema: DbSchema,
+  cypherVersion: CypherVersion,
 ): CompletionItem[] => {
   return (
-    dbSchema?.procedures?.[procedureName]?.returnDescription?.map((x) => {
+    dbSchema.procedures?.[cypherVersion]?.[
+      procedureName
+    ]?.returnDescription?.map((x) => {
       return { label: x.name, kind: CompletionItemKind.Variable };
     }) ?? []
   );
@@ -106,23 +115,25 @@ const functionNameCompletions = (
   candidateRule: CandidateRule,
   tokens: Token[],
   dbSchema: DbSchema,
+  cypherVersion: CypherVersion,
 ): CompletionItem[] =>
   namespacedCompletion(
     candidateRule,
     tokens,
-    dbSchema?.functions ?? {},
+    dbSchema.functions?.[cypherVersion] ?? {},
     'function',
   );
 
 const procedureNameCompletions = (
   candidateRule: CandidateRule,
   tokens: Token[],
   dbSchema: DbSchema,
+  cypherVersion: CypherVersion,
 ): CompletionItem[] =>
   namespacedCompletion(
     candidateRule,
     tokens,
-    dbSchema?.procedures ?? {},
+    dbSchema.procedures?.[cypherVersion] ?? {},
     'procedure',
   );
 
@@ -430,6 +441,10 @@ export function completionCoreCompletion(
   caretToken: Token,
   manualTrigger = false,
 ): CompletionItem[] {
+  const cypherVersion = resolveCypherVersion(
+    parsingResult.cypherVersion,
+    dbSchema,
+  );
   const parser = parsingResult.parser;
   const tokens = parsingResult.tokens;
 
@@ -536,18 +551,30 @@ export function completionCoreCompletion(
             callContext.procedureResultItem_list().map((a) => a.getText()),
           );
           const name = getMethodName(procedureNameCtx);
-          return procedureReturnCompletions(name, dbSchema).filter(
-            (a) => !existingYieldItems.has(a?.label),
-          );
+          return procedureReturnCompletions(
+            name,
+            dbSchema,
+            cypherVersion,
+          ).filter((a) => !existingYieldItems.has(a?.label));
         }
       }
 
       if (ruleNumber === CypherParser.RULE_functionName) {
-        return functionNameCompletions(candidateRule, tokens, dbSchema);
+        return functionNameCompletions(
+          candidateRule,
+          tokens,
+          dbSchema,
+          cypherVersion,
+        );
       }
 
       if (ruleNumber === CypherParser.RULE_procedureName) {
-        return procedureNameCompletions(candidateRule, tokens, dbSchema);
+        return procedureNameCompletions(
+          candidateRule,
+          tokens,
+          dbSchema,
+          cypherVersion,
+        );
       }
 
       if (ruleNumber === CypherParser.RULE_parameter) {
@@ -769,7 +796,7 @@ function completeAliasName({
   ) {
     return [
       ...parameterSuggestions,
-      ...(dbSchema?.aliasNames ?? []).map((aliasName) => ({
+      ...(dbSchema.aliasNames ?? []).map((aliasName) => ({
         label: aliasName,
         kind: CompletionItemKind.Value,
         insertText: backtickDbNameIfNeeded(aliasName),
@@ -834,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,
       })),
@@ -852,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?: Record<string, Neo4jProcedure>;
-  functions?: Record<string, Neo4jFunction>;
+  procedures?: ScopedRegistry<Neo4jProcedure>;
+  functions?: ScopedRegistry<Neo4jFunction>;
   defaultLanguage?: CypherVersion;
 }

packages/language-support/src/featureFlags.ts

@@ -1,5 +1,6 @@
 interface FeatureFlags {
   consoleCommands: boolean;
+  cypher25: boolean;
 }
 
 export const _internalFeatureFlags: FeatureFlags = {
@@ -11,4 +12,5 @@ export const _internalFeatureFlags: FeatureFlags = {
   it's own cache and preference on if console commands are enabled or not.
   */
   consoleCommands: false,
+  cypher25: false,
 };

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);