Makes it compile

Author: ncordon

packages/language-server/src/linting.ts

@@ -1,8 +1,4 @@
-import {
-  findEndPosition,
-  parserWrapper,
-  validateSyntax,
-} from '@neo4j-cypher/language-support';
+import { validateSyntax } from '@neo4j-cypher/language-support';
 import debounce from 'lodash.debounce';
 import { join } from 'path';
 import { Diagnostic, TextDocumentChangeEvent } from 'vscode-languageserver';
@@ -42,9 +38,7 @@ async function rawLintDocument(
       lastSemanticJob = proxyWorker.validateSemantics(query);
       const result = await lastSemanticJob;
 
-      sendDiagnostics(
-        result.map((el) => findEndPosition(el, parserWrapper.parsingResult)),
-      );
+      sendDiagnostics(result);
     } catch (err) {
       if (!(err instanceof workerpool.Promise.CancellationError)) {
         console.error(err);

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

@@ -82,7 +82,7 @@ function warnOnUndeclaredLabels(
   return warnings;
 }
 
-export function findEndPosition(
+function findEndPosition(
   e: SemanticAnalysisElement,
   parsingResult: StatementParsing,
 ): SyntaxDiagnostic {
@@ -147,49 +147,56 @@ export function sortByPosition(a: SyntaxDiagnostic, b: SyntaxDiagnostic) {
 
 // TODO Does this need to be exported
 export function lintCypherQuery(
-  wholeFileText: string,
+  query: string,
   dbSchema: DbSchema,
 ): SyntaxDiagnostic[] {
-  const cachedParse = parserWrapper.parse(wholeFileText);
-  const statements = cachedParse.statementsParsing;
-
-  const result = statements.flatMap((statementParsing) => {
-    const syntaxErrors = validateSyntax(statementParsing, dbSchema);
-
-    if (syntaxErrors.length > 0) {
-      return syntaxErrors;
-    }
-
-    // TODO
-    return validateSemantics(statementParsing.statement)
-      .map((el) => findEndPosition(el, statementParsing))
-      .sort(sortByPosition);
-  });
+  const syntaxErrors = validateSyntax(query, dbSchema);
+  if (syntaxErrors.length > 0) {
+    return syntaxErrors;
+  }
 
-  return result;
+  const semanticErrors = validateSemantics(query);
+  return semanticErrors;
 }
 
 // TODO Does this need to be exported
 export function validateSyntax(
-  statementParsing: StatementParsing,
+  query: string,
   dbSchema: DbSchema,
 ): SyntaxDiagnostic[] {
-  if (statementParsing.statement.length === 0) {
+  if (query.length === 0) {
     return [];
   }
-  const diagnostics = statementParsing.diagnostics;
-  const labelWarnings = warnOnUndeclaredLabels(statementParsing, dbSchema);
-  return diagnostics.concat(labelWarnings).sort(sortByPosition);
+  const statements = parserWrapper.parse(query);
+  const result = statements.statementsParsing.flatMap((statement) => {
+    const diagnostics = statement.diagnostics;
+    const labelWarnings = warnOnUndeclaredLabels(statement, dbSchema);
+    return diagnostics.concat(labelWarnings).sort(sortByPosition);
+  });
+
+  return result;
 }
 
 /**
  * Assumes the provided query has no parse errors
  */
-export function validateSemantics(query: string): SemanticAnalysisElement[] {
+export function validateSemantics(query: string): SyntaxDiagnostic[] {
   if (query.length > 0) {
-    const { notifications, errors } = wrappedSemanticAnalysis(query);
+    const cachedParse = parserWrapper.parse(query);
+    const statements = cachedParse.statementsParsing;
+    const semanticErrors = statements.flatMap((current) => {
+      const { notifications, errors } = wrappedSemanticAnalysis(
+        current.statement,
+      );
+
+      const elements = notifications.concat(errors);
+      const result = elements
+        .map((el) => findEndPosition(el, current))
+        .sort(sortByPosition);
+      return result;
+    });
 
-    return notifications.concat(errors);
+    return semanticErrors;
   }
 
   return [];

packages/language-support/src/index.ts

@@ -9,7 +9,6 @@ export {
 } from './highlighting/syntaxColouring/syntaxColouring';
 export type { ParsedCypherToken } from './highlighting/syntaxColouring/syntaxColouringHelpers';
 export {
-  findEndPosition,
   lintCypherQuery,
   validateSemantics,
   validateSyntax,

packages/react-codemirror-playground/src/tree-util.ts

@@ -6,12 +6,13 @@ interface SimpleTree {
 import {
   antlrUtils,
   CypherParser,
-  parse,
   ParserRuleContext,
+  parserWrapper,
 } from '@neo4j-cypher/language-support';
 
 export function getDebugTree(cypher: string): SimpleTree {
-  const statements = parse(cypher);
+  const statements = parserWrapper.parse(cypher).statementsParsing;
+
   function walk(node: ParserRuleContext): SimpleTree {
     const name = antlrUtils.tree.Trees.getNodeText(
       node,
@@ -25,5 +26,11 @@ export function getDebugTree(cypher: string): SimpleTree {
     };
   }
 
-  return walk(statements);
+  const children = statements.map((statement) => walk(statement.ctx));
+
+  return {
+    // TODO Is this correct?
+    name: 'root',
+    children: children,
+  };
 }

packages/react-codemirror/src/e2e_tests/syntax-validation.spec.tsx

@@ -16,6 +16,7 @@ test('Prop lint set to false disables syntax validation', async ({
   });
 });
 
+// TODO Should this be unskipped
 test.skip('Can turn linting back on', async ({ page, mount }) => {
   const editorPage = new CypherEditorPage(page);
   const query = 'METCH (n) RETURN n';

packages/react-codemirror/src/lang-cypher/syntax-validation.ts

@@ -1,10 +1,6 @@
 import { Diagnostic, linter } from '@codemirror/lint';
 import { Extension } from '@codemirror/state';
-import {
-  findEndPosition,
-  parserWrapper,
-  validateSyntax,
-} from '@neo4j-cypher/language-support';
+import { parserWrapper, validateSyntax } from '@neo4j-cypher/language-support';
 import { DiagnosticSeverity } from 'vscode-languageserver-types';
 import workerpool from 'workerpool';
 import type { CypherConfig } from './lang-cypher';
@@ -59,7 +55,13 @@ export const semanticAnalysisLinter: (config: CypherConfig) => Extension = (
 
     // we want to avoid the ANTLR4 reparse in the worker thread, this should hit our main thread cache
     const parse = parserWrapper.parse(query);
-    if (parse.diagnostics.length !== 0) {
+    const statements = parse.statementsParsing;
+
+    const anySyntacticError =
+      statements.filter((statement) => statement.diagnostics.length !== 0)
+        .length > 0;
+
+    if (anySyntacticError) {
       return [];
     }
 
@@ -72,9 +74,7 @@ export const semanticAnalysisLinter: (config: CypherConfig) => Extension = (
       lastSemanticJob = proxyWorker.validateSemantics(query);
       const result = await lastSemanticJob;
 
-      return result.map((el) => {
-        const diagnostic = findEndPosition(el, parse);
-
+      return result.map((diagnostic) => {
         return {
           from: diagnostic.offsets.start,
           to: diagnostic.offsets.end,