Adds support for cypher versions in semantic analysis-linting

.changeset/blue-penguins-worry.md

@@ -0,0 +1,6 @@
+---
+'@neo4j-cypher/language-support': patch
+'@neo4j-cypher/schema-poller': patch
+---
+
+Updates semantic error worker to use given cypher version

packages/language-support/src/dbSchema.ts

@@ -11,4 +11,5 @@ export interface DbSchema {
   propertyKeys?: string[];
   procedures?: Record<string, Neo4jProcedure>;
   functions?: Record<string, Neo4jFunction>;
+  defaultLanguage?: string;
 }

packages/language-support/src/parserWrapper.ts

@@ -7,6 +7,7 @@ import { DiagnosticSeverity, Position } from 'vscode-languageserver-types';
 import { _internalFeatureFlags } from './featureFlags';
 import {
   ClauseContext,
+  CypherVersionContext,
   default as CypherParser,
   FunctionNameContext,
   LabelNameContext,
@@ -45,6 +46,7 @@ export interface ParsedStatement {
   collectedVariables: string[];
   collectedFunctions: ParsedFunction[];
   collectedProcedures: ParsedProcedure[];
+  cypherVersion?: string;
 }
 
 export interface ParsingResult {
@@ -174,8 +176,14 @@ export function createParsingResult(query: string): ParsingResult {
       const labelsCollector = new LabelAndRelTypesCollector();
       const variableFinder = new VariableCollector();
       const methodsFinder = new MethodsCollector(tokens);
+      const preparserFinder = new PreparserCollector();
       const errorListener = new SyntaxErrorsListener(tokens);
-      parser._parseListeners = [labelsCollector, variableFinder, methodsFinder];
+      parser._parseListeners = [
+        labelsCollector,
+        variableFinder,
+        methodsFinder,
+        preparserFinder,
+      ];
       parser.addErrorListener(errorListener);
       const ctx = parser.statementsOrCommands();
       // The statement is empty if we cannot find anything that is not EOF or a space
@@ -204,6 +212,7 @@ export function createParsingResult(query: string): ParsingResult {
         collectedVariables: variableFinder.variables,
         collectedFunctions: methodsFinder.functions,
         collectedProcedures: methodsFinder.procedures,
+        cypherVersion: preparserFinder.cypherVersion,
       };
     });
 
@@ -403,6 +412,30 @@ class MethodsCollector extends ParseTreeListener {
   }
 }
 
+class PreparserCollector extends ParseTreeListener {
+  public cypherVersion: string;
+
+  constructor() {
+    super();
+  }
+
+  enterEveryRule() {
+    /* no-op */
+  }
+  visitTerminal() {
+    /* no-op */
+  }
+  visitErrorNode() {
+    /* no-op */
+  }
+
+  exitEveryRule(ctx: unknown) {
+    if (ctx instanceof CypherVersionContext) {
+      this.cypherVersion = ctx.getText();
+    }
+  }
+}
+
 type CypherCmd = { type: 'cypher'; query: string };
 type RuleTokens = {
   start: Token;

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

@@ -51,6 +51,7 @@ function copySettingSeverity(
 export function wrappedSemanticAnalysis(
   query: string,
   dbSchema: DbSchema,
+  parsedVersion: string,
 ): SemanticAnalysisResult {
   try {
     if (JSON.stringify(dbSchema) !== JSON.stringify(previousSchema)) {
@@ -63,7 +64,20 @@ export function wrappedSemanticAnalysis(
       });
     }
 
-    const semanticErrorsResult = analyzeQuery(query, 'cypher 5');
+    const validCypherVersions = ['cypher 5', 'cypher 25'];
+    let cypherVersion = 'cypher 5';
+    const fullParsedVersion = 'cypher ' + parsedVersion;
+    const defaultVersion = dbSchema.defaultLanguage?.toLowerCase();
+
+    if (parsedVersion && validCypherVersions.includes(fullParsedVersion)) {
+      cypherVersion = fullParsedVersion;
+    } else if (
+      dbSchema.defaultLanguage &&
+      validCypherVersions.includes(defaultVersion)
+    ) {
+      cypherVersion = defaultVersion;
+    }
+    const semanticErrorsResult = analyzeQuery(query, cypherVersion);
     const errors: SemanticAnalysisElement[] = semanticErrorsResult.errors;
     const notifications: SemanticAnalysisElement[] =
       semanticErrorsResult.notifications;

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

@@ -292,6 +292,7 @@ export function lintCypherQuery(
         const { notifications, errors } = wrappedSemanticAnalysis(
           cmd.statement,
           dbSchema,
+          current.cypherVersion,
         );
 
         // This contains both the syntax and the semantic errors

packages/language-support/src/tests/syntaxValidation/semanticValidation.test.ts

@@ -3,6 +3,53 @@ import { testData } from '../testData';
 import { getDiagnosticsForQuery } from './helpers';
 
 describe('Semantic validation spec', () => {
+  test('Semantic analysis is dependant on cypher version', () => {
+    const query1 = 'CYPHER  5 MATCH (n)-[r]->(m) SET r += m';
+    const diagnostics1 = getDiagnosticsForQuery({ query: query1 });
+    const query2 = 'CYPHER 25 MATCH (n)-[r]->(m) SET r += m';
+    const diagnostics2 = getDiagnosticsForQuery({ query: query2 });
+    expect(diagnostics1[0].message).not.toEqual(diagnostics2[0].message);
+  });
+
+  test('Semantic analysis defaults to cypher 5 when no default version is given, and no version is given in query', () => {
+    const query1 = 'CYPHER  5 MATCH (n)-[r]->(m) SET r += m';
+    const diagnostics1 = getDiagnosticsForQuery({ query: query1 });
+    const query2 = 'MATCH (n)-[r]->(m) SET r += m';
+    const diagnostics2 = getDiagnosticsForQuery({ query: query2 });
+    expect(diagnostics1[0].message).toEqual(diagnostics2[0].message);
+  });
+
+  //TODO: Maybe this should actually yield a warning
+  test('Semantic analysis defaults to cypher 5 when faulty version is given', () => {
+    const query1 = 'CYPHER  5 MATCH (n)-[r]->(m) SET r += m';
+    const diagnostics1 = getDiagnosticsForQuery({ query: query1 });
+    const query2 = 'CYPHER 800 MATCH (n)-[r]->(m) SET r += m';
+    const diagnostics2 = getDiagnosticsForQuery({ query: query2 });
+    expect(diagnostics1[0].message).toEqual(diagnostics2[0].message);
+  });
+
+  test('Semantic analysis uses default language if no language is defined in query', () => {
+    const query1 = 'MATCH (n)-[r]->(m) SET r += m';
+    const diagnostics1 = getDiagnosticsForQuery({
+      query: query1,
+      dbSchema: { defaultLanguage: 'CYPHER 25' },
+    });
+    const query2 = 'CYPHER 25 MATCH (n)-[r]->(m) SET r += m';
+    const diagnostics2 = getDiagnosticsForQuery({ query: query2 });
+    expect(diagnostics1[0].message).toEqual(diagnostics2[0].message);
+  });
+
+  test('In-query version takes priority for semantic analysis even if defaultLanguage is defined', () => {
+    const query1 = 'CYPHER 5 MATCH (n)-[r]->(m) SET r += m';
+    const diagnostics1 = getDiagnosticsForQuery({
+      query: query1,
+      dbSchema: { defaultLanguage: 'CYPHER 25' },
+    });
+    const query2 = 'CYPHER 25 MATCH (n)-[r]->(m) SET r += m';
+    const diagnostics2 = getDiagnosticsForQuery({ query: query2 });
+    expect(diagnostics1[0].message).not.toEqual(diagnostics2[0].message);
+  });
+
   test('Does not trigger semantic errors when there are syntactic errors', () => {
     const query = 'METCH (n) RETURN m';
 

packages/schema-poller/src/metadataPoller.ts

@@ -105,6 +105,13 @@ export class MetadataPoller {
           this.dbSchema.aliasNames = result.data.databases.flatMap(
             (db) => db.aliases ?? [],
           );
+          const dbs = result.data.databases;
+          const currentDb = dbs.find(
+            (db) => db.name === this.connection.currentDb,
+          );
+          if (currentDb) {
+            this.dbSchema.defaultLanguage = currentDb.defaultLanguage;
+          }
         }
       },
     });

packages/schema-poller/src/queries/databases.ts

@@ -30,6 +30,7 @@ export type Database = {
   writer?: boolean;
   access?: string;
   constituents?: string[];
+  defaultLanguage?: string; // to be introduced
 };
 
 /**