adding auto-completion for :auto (#667)

Co-authored-by: Isak <isak.nilsson@neo4j.com>

Author: nnecla

.changeset/fancy-bushes-travel.md

@@ -0,0 +1,5 @@
+---
+'@neo4j-cypher/language-support': patch
+---
+
+adding auto-completion for :auto

packages/language-support/src/antlr-grammar/CypherCmdLexer.g4

@@ -24,4 +24,6 @@ PLAY: P L A Y;
 
 ACCESSMODE: A C C E S S '-' M O D E;
 
-HELP: H E L P;
+HELP: H E L P;
+
+AUTO: A U T O;

packages/language-support/src/antlr-grammar/CypherCmdParser.g4

@@ -22,6 +22,7 @@ consoleCommand: COLON (
     | playCmd
     | accessModeCmd
     | helpCmd
+    | autoCmd
 );
 
 paramsCmd: PARAM paramsArgs?;
@@ -58,7 +59,9 @@ accessModeCmd: ACCESSMODE accessModeArgs?;
 
 helpCmd: HELP;
 
-// These rules are needed to distinguish cypher <-> commands, for exapmle `USE` and `:use` in autocompletion
+autoCmd: AUTO statement;
+
+// These rules are needed to distinguish cypher <-> commands, for example `USE` and `:use` in autocompletion
 listCompletionRule: LIST; 
 
 useCompletionRule: USE;

packages/language-support/src/cypherLanguageService.ts

@@ -574,7 +574,8 @@ export type ParsedCommandNoPosition =
   | { type: 'style'; operation?: 'reset' }
   | { type: 'play'; guide?: string }
   | { type: 'access-mode'; operation?: string }
-  | { type: 'help' };
+  | { type: 'help' }
+  | { type: 'auto'; statement?: string };
 
 export type ParsedCommand = ParsedCommandNoPosition & RuleTokens;
 
@@ -777,6 +778,21 @@ function parseToCommand(
         return { type: 'help', start, stop };
       }
 
+      const autoCmd = consoleCmd.autoCmd();
+      if (autoCmd) {
+        const autoStmt = autoCmd.statement();
+        if (autoStmt && autoStmt.start && autoStmt.stop) {
+          //we want autoStmt.start so we skip :auto when calling semantic analysis
+          //but regular stop, so we include trailing error nodes not parsed as statement
+          const statement = inputstream.getText(
+            autoStmt.start.start,
+            stop.stop,
+          );
+          return { type: 'auto', statement, start: autoStmt.start, stop };
+        }
+        return { type: 'auto', start, stop };
+      }
+
       return { type: 'parse-error', start, stop };
     }
     const stopToken = stop ?? tokens.at(-1);

packages/language-support/src/lexerSymbols.ts

@@ -425,6 +425,7 @@ export const lexerConsoleCmds = [
   CypherLexer.PLAY,
   CypherLexer.ACCESSMODE,
   CypherLexer.HELP,
+  CypherLexer.AUTO,
 ];
 
 function toTokentypeObject(arr: number[], tokenType: CypherTokenType) {

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

@@ -69,6 +69,8 @@ export function completionCoreErrormessage(
 
   // If we can complete only a statement, we don't want to suggest that
   // We want to be using the database errors stack instead
+  // Exception: inside console commands (e.g. :auto) we do want to report
+  // statement-level errors since there's no database error stack for those
   if (
     ruleCandidates.length === 1 &&
     ruleCandidates[0] === CypherParser.RULE_statement

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

@@ -347,7 +347,10 @@ export function lintCypherQuery(
     const statements = resolvedParsingResult.statementsParsing;
     const result = statements.map((current) => {
       const cmd = current.command;
-      if (cmd.type === 'cypher' && cmd.statement.length > 0) {
+      if (
+        (cmd.type === 'cypher' || cmd.type === 'auto') &&
+        cmd.statement.length > 0
+      ) {
         if (current.cypherVersionError)
           return { diagnostics: [current.cypherVersionError], symbolTable: [] };
 

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

@@ -5,6 +5,10 @@ import {
 import { testData } from './testData.js';
 import { highlightSyntax } from '../syntaxHighlighting/syntaxHighlighting.js';
 import { autocomplete } from '../autocompletion/autocompletion.js';
+import {
+  getDiagnosticsForQuery,
+  getSymbolTablesForQuery,
+} from './syntaxValidation/helpers.js';
 
 function expectParsedCommands(
   query: string,
@@ -224,12 +228,28 @@ describe('sanity checks', () => {
         tokenType: 'consoleCommand',
       },
     ]);
+
+    expect(highlightSyntax(':auto')).toEqual([
+      {
+        length: 1,
+        position: { line: 0, startCharacter: 0, startOffset: 0 },
+        token: ':',
+        tokenType: 'consoleCommand',
+      },
+      {
+        length: 4,
+        position: { line: 0, startCharacter: 1, startOffset: 1 },
+        token: 'auto',
+        tokenType: 'consoleCommand',
+      },
+    ]);
   });
 
   test('completes basic console cmds on :', () => {
     expect(autocomplete(':', {})).toEqual([
       { kind: 23, label: 'server' },
       { kind: 23, label: 'use' },
+      { kind: 23, label: 'auto' },
       { kind: 23, label: 'help' },
       { kind: 23, label: 'access-mode' },
       { kind: 23, label: 'play' },
@@ -277,7 +297,7 @@ describe('sanity checks', () => {
   test('handles misspelled or non-existing command', () => {
     expectErrorMessage(
       ':foo',
-      'Expected any of help, access-mode, play, style, sysinfo, welcome, disconnect, connect, param, history, clear, server or use',
+      'Expected any of auto, help, access-mode, play, style, sysinfo, welcome, disconnect, connect, param, history, clear, server or use',
     );
 
     expectErrorMessage(':clea', 'Unexpected token. Did you mean clear?');
@@ -785,6 +805,149 @@ describe('server', () => {
   });
 });
 
+describe('auto', () => {
+  test('parses without arg', () => {
+    expectParsedCommands(':auto', [{ type: 'auto', statement: '' }]);
+  });
+
+  test('parses with valid statement', () => {
+    expectParsedCommands(':auto RETURN 1', [
+      { type: 'auto', statement: 'RETURN 1' },
+    ]);
+  });
+
+  test('gives errors on invalid statement', () => {
+    const linting = getDiagnosticsForQuery({
+      query: ':auto asdf',
+      consoleCommandsEnabled: true,
+    });
+    expect(linting).toEqual([
+      {
+        offsets: {
+          end: 10,
+          start: 6,
+        },
+        message:
+          "Invalid input 'asdf': expected 'ALTER', 'ORDER BY', 'CALL', 'USING PERIODIC COMMIT', 'CREATE', 'LOAD CSV', 'START DATABASE', 'STOP DATABASE', 'DEALLOCATE', 'DELETE', 'DENY', 'DETACH', 'DROP', 'DRYRUN', 'FINISH', 'FOREACH', 'GRANT', 'INSERT', 'LIMIT', 'MATCH', 'MERGE', 'NODETACH', 'OFFSET', 'OPTIONAL', 'REALLOCATE', 'REMOVE', 'RENAME', 'RETURN', 'REVOKE', 'ENABLE SERVER', 'SET', 'SHOW', 'SKIP', 'TERMINATE', 'UNWIND', 'USE' or 'WITH'",
+        range: {
+          end: {
+            character: 10,
+            line: 0,
+          },
+          start: {
+            character: 6,
+            line: 0,
+          },
+        },
+        severity: 1,
+      },
+    ]);
+  });
+
+  test('gives errors on trailing garbage after valid statement', () => {
+    const linting = getDiagnosticsForQuery({
+      query: ':auto RETURN 1 asdf',
+      consoleCommandsEnabled: true,
+    });
+    expect(linting).toEqual([
+      {
+        offsets: {
+          end: 19,
+          start: 15,
+        },
+        message:
+          "Invalid input 'asdf': expected an expression, ',', 'AS', 'ORDER BY', 'CALL', 'CREATE', 'LOAD CSV', 'DELETE', 'DETACH', 'FINISH', 'FOREACH', 'INSERT', 'LIMIT', 'MATCH', 'MERGE', 'NODETACH', 'OFFSET', 'OPTIONAL', 'REMOVE', 'RETURN', 'SET', 'SKIP', 'UNION', 'UNWIND', 'USE', 'WITH' or <EOF>",
+        range: {
+          end: {
+            character: 19,
+            line: 0,
+          },
+          start: {
+            character: 15,
+            line: 0,
+          },
+        },
+        severity: 1,
+      },
+    ]);
+  });
+
+  test('provides symbol tables with correct positions', () => {
+    const symbolTables = getSymbolTablesForQuery({
+      query: ':auto MATCH (n) RETURN n',
+      consoleCommandsEnabled: true,
+    });
+    expect(symbolTables).toEqual([
+      [
+        {
+          variable: 'n',
+          definitionPosition: 13,
+          types: ['Node'],
+          references: [13, 23],
+          labels: {
+            condition: 'and',
+            children: [],
+          },
+        },
+      ],
+    ]);
+  });
+
+  test('provides semantic errors', () => {
+    const linting = getDiagnosticsForQuery({
+      query: ':auto RETURN n',
+      consoleCommandsEnabled: true,
+    });
+    expect(linting).toEqual([
+      {
+        offsets: {
+          end: 14,
+          start: 13,
+        },
+        message: 'Variable `n` not defined',
+        range: {
+          end: {
+            character: 14,
+            line: 0,
+          },
+          start: {
+            character: 13,
+            line: 0,
+          },
+        },
+        severity: 1,
+      },
+    ]);
+  });
+
+  test('handles multiple statements', () => {
+    const linting = getDiagnosticsForQuery({
+      query: ':auto RETURN n; MATCH (n) RETURN n',
+      consoleCommandsEnabled: true,
+    });
+    expect(linting).toEqual([
+      {
+        offsets: {
+          end: 14,
+          start: 13,
+        },
+        message: 'Variable `n` not defined',
+        range: {
+          end: {
+            character: 14,
+            line: 0,
+          },
+          start: {
+            character: 13,
+            line: 0,
+          },
+        },
+        severity: 1,
+      },
+    ]);
+  });
+});
+
 describe('command parser also handles cypher', () => {
   test('parses cypher', () => {
     expectParsedCommands('MATCH (n) RETURN n', [