Adds errors for non-declared procedures

.changeset/chatty-plants-greet.md

@@ -0,0 +1,5 @@
+---
+'@neo4j-cypher/language-support': patch
+---
+
+Adds errors for undeclared procedures / functions

packages/language-support/src/parserWrapper.ts

@@ -12,6 +12,7 @@ import {
   LabelNameContext,
   LabelNameIsContext,
   LabelOrRelTypeContext,
+  ProcedureNameContext,
   StatementOrCommandContext,
   StatementsOrCommandsContext,
   SymbolicNameStringContext,
@@ -39,11 +40,12 @@ export interface ParsedStatement {
   // A statement needs to be parsed with the .statements() rule because
   // it's the one that tries to parse until the EOF
   ctx: StatementsOrCommandsContext;
-  diagnostics: SyntaxDiagnostic[];
+  syntaxErrors: SyntaxDiagnostic[];
   stopNode: ParserRuleContext;
   collectedLabelOrRelTypes: LabelOrRelType[];
   collectedVariables: string[];
   collectedFunctions: ParsedFunction[];
+  collectedProcedures: ParsedProcedure[];
 }
 
 export interface ParsingResult {
@@ -97,7 +99,7 @@ export type LabelOrRelType = {
 };
 
 export type ParsedFunction = {
-  parsedName: string;
+  name: string;
   rawText: string;
   line: number;
   column: number;
@@ -106,6 +108,7 @@ export type ParsedFunction = {
     end: number;
   };
 };
+export type ParsedProcedure = ParsedFunction;
 
 export function createParsingScaffolding(query: string): ParsingScaffolding {
   const inputStream = CharStreams.fromString(query);
@@ -171,37 +174,34 @@ export function createParsingResult(query: string): ParsingResult {
       const { parser, tokens } = statementScaffolding;
       const labelsCollector = new LabelAndRelTypesCollector();
       const variableFinder = new VariableCollector();
-      const functionFinder = new FunctionCollector(tokens);
+      const methodsFinder = new MethodsCollector(tokens);
       const errorListener = new SyntaxErrorsListener(tokens);
-      parser._parseListeners = [
-        labelsCollector,
-        variableFinder,
-        functionFinder,
-      ];
+      parser._parseListeners = [labelsCollector, variableFinder, methodsFinder];
       parser.addErrorListener(errorListener);
       const ctx = parser.statementsOrCommands();
       // The statement is empty if we cannot find anything that is not EOF or a space
       const isEmptyStatement =
         tokens.find(
           (t) => t.text !== '<EOF>' && t.type !== CypherLexer.SPACE,
         ) === undefined;
-      const diagnostics = isEmptyStatement ? [] : errorListener.errors;
+      const syntaxErrors = isEmptyStatement ? [] : errorListener.errors;
       const collectedCommand = parseToCommand(ctx, isEmptyStatement);
 
       if (!_internalFeatureFlags.consoleCommands) {
-        diagnostics.push(...errorOnNonCypherCommands(collectedCommand));
+        syntaxErrors.push(...errorOnNonCypherCommands(collectedCommand));
       }
 
       return {
         command: collectedCommand,
         parser: parser,
         tokens: tokens,
-        diagnostics: diagnostics,
+        syntaxErrors: syntaxErrors,
         ctx: ctx,
         stopNode: findStopNode(ctx),
         collectedLabelOrRelTypes: labelsCollector.labelOrRelTypes,
         collectedVariables: variableFinder.variables,
-        collectedFunctions: functionFinder.functions,
+        collectedFunctions: methodsFinder.functions,
+        collectedProcedures: methodsFinder.procedures,
       };
     });
 
@@ -310,8 +310,9 @@ class VariableCollector implements ParseTreeListener {
   }
 }
 
-// This listener collects all functions
-class FunctionCollector extends ParseTreeListener {
+// This listener collects all functions and procedures
+class MethodsCollector extends ParseTreeListener {
+  public procedures: ParsedProcedure[] = [];
   public functions: ParsedFunction[] = [];
   private tokens: Token[];
 
@@ -331,8 +332,11 @@ class FunctionCollector extends ParseTreeListener {
   }
 
   exitEveryRule(ctx: unknown) {
-    if (ctx instanceof FunctionNameContext) {
-      const functionName = this.getNormalizedFunctionName(ctx);
+    if (
+      ctx instanceof FunctionNameContext ||
+      ctx instanceof ProcedureNameContext
+    ) {
+      const methodName = this.getMethodName(ctx);
 
       const startTokenIndex = ctx.start.tokenIndex;
       const stopTokenIndex = ctx.stop.tokenIndex;
@@ -344,33 +348,41 @@ class FunctionCollector extends ParseTreeListener {
         })
         .join('');
 
-      this.functions.push({
-        parsedName: functionName,
+      const result = {
+        name: methodName,
         rawText: rawText,
         line: ctx.start.line,
         column: ctx.start.column,
         offsets: {
           start: ctx.start.start,
           end: ctx.stop.stop + 1,
         },
-      });
+      };
+
+      if (ctx instanceof FunctionNameContext) {
+        this.functions.push(result);
+      } else {
+        this.procedures.push(result);
+      }
     }
   }
 
-  private getNormalizedFunctionName(ctx: FunctionNameContext): string {
+  private getMethodName(
+    ctx: ProcedureNameContext | FunctionNameContext,
+  ): string {
     const namespaces = ctx.namespace().symbolicNameString_list();
-    const functionName = ctx.symbolicNameString();
+    const methodName = ctx.symbolicNameString();
 
-    const normalizedName = [...namespaces, functionName]
+    const normalizedName = [...namespaces, methodName]
       .map((symbolicName) => {
-        return this.getFunctionNamespaceString(symbolicName);
+        return this.getNamespaceString(symbolicName);
       })
       .join('.');
 
     return normalizedName;
   }
 
-  private getFunctionNamespaceString(ctx: SymbolicNameStringContext): string {
+  private getNamespaceString(ctx: SymbolicNameStringContext): string {
     const text = ctx.getText();
     const isEscaped = Boolean(ctx.escapedSymbolicNameString());
     const hasDot = text.includes('.');

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

@@ -34,12 +34,10 @@ export function wrappedSemanticAnalysis(
   try {
     let semanticErrorsResult = undefined;
 
-    if (dbSchema.functions && dbSchema.procedures) {
-      updateSignatureResolver({
-        procedures: Object.values(dbSchema.procedures),
-        functions: Object.values(dbSchema.functions),
-      });
-    }
+    updateSignatureResolver({
+      procedures: Object.values(dbSchema.procedures ?? {}),
+      functions: Object.values(dbSchema.functions ?? {}),
+    });
     semanticAnalysis([query], (a) => {
       semanticErrorsResult = a;
     });

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

@@ -6,10 +6,11 @@ import {
   LabelOrRelType,
   LabelType,
   ParsedFunction,
+  ParsedProcedure,
   ParsedStatement,
   parserWrapper,
 } from '../parserWrapper';
-import { Neo4jFunction } from '../types';
+import { Neo4jFunction, Neo4jProcedure } from '../types';
 import {
   SemanticAnalysisElement,
   wrappedSemanticAnalysis,
@@ -63,7 +64,7 @@ function detectNonDeclaredFunction(
   parsedFunction: ParsedFunction,
   functionsSchema: Record<string, Neo4jFunction>,
 ): SyntaxDiagnostic | undefined {
-  const lowercaseFunctionName = parsedFunction.parsedName.toLowerCase();
+  const lowercaseFunctionName = parsedFunction.name.toLowerCase();
   const caseInsensitiveFunctionInDatabase =
     functionsSchema[lowercaseFunctionName];
 
@@ -76,14 +77,26 @@ function detectNonDeclaredFunction(
   }
 
   const functionExistsWithExactName = Boolean(
-    functionsSchema[parsedFunction.parsedName],
+    functionsSchema[parsedFunction.name],
   );
   if (!functionExistsWithExactName) {
-    return generateFunctionNotFoundWarning(parsedFunction);
+    return generateFunctionNotFoundError(parsedFunction);
   }
 }
 
-function generateFunctionNotFoundWarning(
+function detectNonDeclaredProcedure(
+  parsedProcedure: ParsedProcedure,
+  proceduresSchema: Record<string, Neo4jProcedure>,
+): SyntaxDiagnostic | undefined {
+  const procedureName = parsedProcedure.name;
+  const procedureExists = Boolean(proceduresSchema[procedureName]);
+
+  if (!procedureExists) {
+    return generateProcedureNotFoundError(parsedProcedure);
+  }
+}
+
+function generateFunctionNotFoundError(
   parsedFunction: ParsedFunction,
 ): SyntaxDiagnostic {
   const rawText = parsedFunction.rawText;
@@ -96,17 +109,43 @@ function generateFunctionNotFoundWarning(
       ? startColumn + rawText.length
       : nameChunks.at(-1)?.length ?? 0;
 
-  const warning: SyntaxDiagnostic = {
-    severity: DiagnosticSeverity.Warning,
+  const error: SyntaxDiagnostic = {
+    severity: DiagnosticSeverity.Error,
     range: {
       start: Position.create(lineIndex, startColumn),
       end: Position.create(lineIndex + linesOffset, endColumn),
     },
     offsets: parsedFunction.offsets,
-    message: `Function ${parsedFunction.parsedName} is not present in the database. Make sure you didn't misspell it or that it is available when you run this statement in your application`,
+    message: `Function ${parsedFunction.name} is not present in the database. Make sure you didn't misspell it or that it is available when you run this statement in your application`,
   };
 
-  return warning;
+  return error;
+}
+
+function generateProcedureNotFoundError(
+  parsedProcedure: ParsedProcedure,
+): SyntaxDiagnostic {
+  const rawText = parsedProcedure.rawText;
+  const nameChunks = rawText.split('\n');
+  const linesOffset = nameChunks.length - 1;
+  const lineIndex = parsedProcedure.line - 1;
+  const startColumn = parsedProcedure.column;
+  const endColumn =
+    linesOffset == 0
+      ? startColumn + rawText.length
+      : nameChunks.at(-1)?.length ?? 0;
+
+  const error: SyntaxDiagnostic = {
+    severity: DiagnosticSeverity.Error,
+    range: {
+      start: Position.create(lineIndex, startColumn),
+      end: Position.create(lineIndex + linesOffset, endColumn),
+    },
+    offsets: parsedProcedure.offsets,
+    message: `Procedure ${parsedProcedure.name} is not present in the database. Make sure you didn't misspell it or that it is available when you run this statement in your application`,
+  };
+
+  return error;
 }
 
 function warnOnUndeclaredLabels(
@@ -226,12 +265,13 @@ export function lintCypherQuery(
   dbSchema: DbSchema,
 ): SyntaxDiagnostic[] {
   const syntaxErrors = validateSyntax(query, dbSchema);
-  if (syntaxErrors.length > 0) {
+  // If there are any syntactic errors in the query, do not run the semantic validation
+  if (syntaxErrors.find((d) => d.severity === DiagnosticSeverity.Error)) {
     return syntaxErrors;
   }
 
   const semanticErrors = validateSemantics(query, dbSchema);
-  return semanticErrors;
+  return syntaxErrors.concat(semanticErrors);
 }
 
 export function validateSyntax(
@@ -243,13 +283,9 @@ export function validateSyntax(
   }
   const statements = parserWrapper.parse(query);
   const result = statements.statementsParsing.flatMap((statement) => {
-    const diagnostics = statement.diagnostics;
+    const syntaxErrors = statement.syntaxErrors;
     const labelWarnings = warnOnUndeclaredLabels(statement, dbSchema);
-    const functionWarnings = warnOnUndeclaredFunctions(statement, dbSchema);
-
-    return diagnostics
-      .concat(labelWarnings, functionWarnings)
-      .sort(sortByPositionAndMessage);
+    return syntaxErrors.concat(labelWarnings).sort(sortByPositionAndMessage);
   });
 
   return result;
@@ -266,20 +302,28 @@ export function validateSemantics(
     const cachedParse = parserWrapper.parse(query);
     const statements = cachedParse.statementsParsing;
     const semanticErrors = statements.flatMap((current) => {
-      if (current.diagnostics.length === 0) {
+      if (current.syntaxErrors.length === 0) {
         const cmd = current.command;
         if (cmd.type === 'cypher' && cmd.statement.length > 0) {
+          const functionErrors = errorOnUndeclaredFunctions(current, dbSchema);
+          const procedureErrors = errorOnUndeclaredProcedures(
+            current,
+            dbSchema,
+          );
+
           const { notifications, errors } = wrappedSemanticAnalysis(
             cmd.statement,
             dbSchema,
           );
 
           const elements = notifications.concat(errors);
-          const result = fixSemanticAnalysisPositions({
+          const semanticDiagnostics = fixSemanticAnalysisPositions({
             semanticElements: elements,
             parseResult: current,
-          }).sort(sortByPositionAndMessage);
-          return result;
+          });
+          return semanticDiagnostics
+            .concat(functionErrors, procedureErrors)
+            .sort(sortByPositionAndMessage);
         }
       }
       return [];
@@ -291,7 +335,7 @@ export function validateSemantics(
   return [];
 }
 
-function warnOnUndeclaredFunctions(
+function errorOnUndeclaredFunctions(
   parsingResult: ParsedStatement,
   dbSchema: DbSchema,
 ): SyntaxDiagnostic[] {
@@ -312,3 +356,25 @@ function warnOnUndeclaredFunctions(
 
   return warnings;
 }
+
+function errorOnUndeclaredProcedures(
+  parsingResult: ParsedStatement,
+  dbSchema: DbSchema,
+): SyntaxDiagnostic[] {
+  const errors: SyntaxDiagnostic[] = [];
+
+  if (dbSchema.procedures) {
+    const proceduresInQuery = parsingResult.collectedProcedures;
+
+    proceduresInQuery.forEach((parsedProcedure) => {
+      const error = detectNonDeclaredProcedure(
+        parsedProcedure,
+        dbSchema.procedures,
+      );
+
+      if (error) errors.push(error);
+    });
+  }
+
+  return errors;
+}