Console command support (:use, :params, :clear, history)

.vscode/settings.json

@@ -2,7 +2,7 @@
   "typescript.tsc.autoDetect": "off",
   "typescript.preferences.quoteStyle": "single",
   "editor.codeActionsOnSave": {
-    "source.fixAll.eslint": true
+    "source.fixAll.eslint": "explicit"
   },
   "editor.defaultFormatter": "esbenp.prettier-vscode",
   "editor.formatOnSave": true,

packages/language-support/package.json

@@ -47,7 +47,7 @@
     "vscode-languageserver-types": "^3.17.3"
   },
   "scripts": {
-    "gen-parser": "antlr4 -Dlanguage=TypeScript -visitor src/antlr-grammar/CypherParser.g4 src/antlr-grammar/CypherLexer.g4 -o src/generated-parser/ -Xexact-output-dir",
+    "gen-parser": "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/antlr-grammar/CypherCmdLexer.g4

@@ -0,0 +1,9 @@
+lexer grammar CypherCmdLexer;
+
+import CypherLexer;
+
+PARAM : P A R A M S?;
+
+CLEAR: C L E A R;
+
+HISTORY: H I S T O R Y;

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

@@ -0,0 +1,28 @@
+parser grammar CypherCmdParser;
+
+import CypherParser;
+
+options { tokenVocab = CypherCmdLexer; }
+
+statementsOrCommands: statementOrCommand (SEMICOLON statementOrCommand)* SEMICOLON? EOF;
+
+statementOrCommand: (statement | consoleCommand);
+
+consoleCommand: COLON (clearCmd | historyCmd | useCmd | paramsCmd);
+
+paramsCmd: PARAM paramsArgs?;
+
+paramsArgs: (CLEAR | listCompletionRule | map | lambda);
+
+lambda: unescapedSymbolicNameString EQ GT expression;
+
+clearCmd: CLEAR;
+
+historyCmd: HISTORY;
+
+useCmd: useCompletionRule symbolicAliasName?;
+
+// These rules are needed to distinguish cypher <-> commands, for exapmle `USE` and `:use` in autocompletion
+listCompletionRule: LIST; 
+
+useCompletionRule: USE;

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

@@ -28,5 +28,9 @@ export function autocomplete(
     parsingResult = parserWrapper.parse(lastStatement);
   }
 
-  return completionCoreCompletion(parsingResult, dbSchema);
+  return completionCoreCompletion(
+    parsingResult,
+    dbSchema,
+    parserWrapper.enableConsoleCommands,
+  );
 }

packages/language-support/src/autocompletion/completionCoreCompletions.ts

@@ -6,10 +6,10 @@ import {
   CompletionItemKind,
 } from 'vscode-languageserver-types';
 import { DbSchema } from '../dbSchema';
-import CypherLexer from '../generated-parser/CypherLexer';
+import CypherLexer from '../generated-parser/CypherCmdLexer';
 import CypherParser, {
   Expression2Context,
-} from '../generated-parser/CypherParser';
+} from '../generated-parser/CypherCmdParser';
 import { rulesDefiningVariables } from '../helpers';
 import {
   CypherTokenType,
@@ -125,17 +125,27 @@ const namespacedCompletion = (
   }
 };
 
-function getTokenCandidates(
+function getTokenCompletions(
   candidates: CandidatesCollection,
   ignoredTokens: Set<number>,
-) {
+): CompletionItem[] {
   const tokenEntries = candidates.tokens.entries();
 
-  const tokenCandidates = Array.from(tokenEntries).flatMap((value) => {
+  const completions = Array.from(tokenEntries).flatMap((value) => {
     const [tokenNumber, followUpList] = value;
 
     if (!ignoredTokens.has(tokenNumber)) {
-      const firstToken = tokenNames[tokenNumber];
+      const isConsoleCommand =
+        lexerSymbols[tokenNumber] === CypherTokenType.consoleCommand;
+
+      const kind = isConsoleCommand
+        ? CompletionItemKind.Event
+        : CompletionItemKind.Keyword;
+
+      const firstToken = isConsoleCommand
+        ? tokenNames[tokenNumber].toLowerCase()
+        : tokenNames[tokenNumber];
+
       const followUpIndexes = followUpList.indexes;
       const firstIgnoredToken = followUpIndexes.findIndex((t) =>
         ignoredTokens.has(t),
@@ -151,21 +161,28 @@ function getTokenCandidates(
       if (firstToken === undefined) {
         return [];
       } else if (followUpString === '') {
-        return [firstToken];
+        return [{ label: firstToken, kind }];
       } else {
-        const followUp = firstToken + ' ' + followUpString;
+        const followUp =
+          firstToken +
+          ' ' +
+          (isConsoleCommand ? followUpString.toLowerCase() : followUpString);
+
         if (followUpList.optional) {
-          return [firstToken, followUp];
+          return [
+            { label: firstToken, kind },
+            { label: followUp, kind },
+          ];
         }
 
-        return [followUp];
+        return [{ label: followUp, kind }];
       }
     } else {
       return [];
     }
   });
 
-  return tokenCandidates;
+  return completions;
 }
 
 const parameterCompletions = (
@@ -265,6 +282,7 @@ function calculateNamespacePrefix(
 export function completionCoreCompletion(
   parsingResult: EnrichedParsingResult,
   dbSchema: DbSchema,
+  enableConsoleCommands: boolean,
 ): CompletionItem[] {
   const parser = parsingResult.parser;
   const tokens = parsingResult.tokens;
@@ -306,6 +324,15 @@ export function completionCoreCompletion(
     CypherParser.RULE_propertyKeyName,
     CypherParser.RULE_variable,
 
+    // Either enable the helper rules for lexer clashes,
+    // or collect all console commands like below with symbolicNameString
+    ...(enableConsoleCommands
+      ? [
+          CypherParser.RULE_useCompletionRule,
+          CypherParser.RULE_listCompletionRule,
+        ]
+      : [CypherParser.RULE_consoleCommand]),
+
     // Because of the overlap of keywords and identifiers in cypher
     // We will suggest keywords when users type identifiers as well
     // To avoid this we want custom completion for identifiers
@@ -317,7 +344,11 @@ export function completionCoreCompletion(
   // Keep only keywords as suggestions
   const ignoredTokens = new Set<number>(
     Object.entries(lexerSymbols)
-      .filter(([, type]) => type !== CypherTokenType.keyword)
+      .filter(
+        ([, type]) =>
+          type !== CypherTokenType.keyword &&
+          type !== CypherTokenType.consoleCommand,
+      )
       .map(([token]) => Number(token)),
   );
 
@@ -427,17 +458,24 @@ export function completionCoreCompletion(
           ];
         }
       }
+
+      // These are simple tokens that get completed as the wrong kind, due to a lexer conlfict
+      if (ruleNumber === CypherParser.RULE_useCompletionRule) {
+        return [{ label: 'use', kind: CompletionItemKind.Event }];
+      }
+
+      if (ruleNumber === CypherParser.RULE_listCompletionRule) {
+        return [{ label: 'list', kind: CompletionItemKind.Event }];
+      }
+
       return [];
     },
   );
 
-  const tokenCandidates = getTokenCandidates(candidates, ignoredTokens);
-  const tokenCompletions: CompletionItem[] = tokenCandidates.map((t) => ({
-    label: t,
-    kind: CompletionItemKind.Keyword,
-  }));
-
-  return [...ruleCompletions, ...tokenCompletions];
+  return [
+    ...ruleCompletions,
+    ...getTokenCompletions(candidates, ignoredTokens),
+  ];
 }
 
 type CompletionHelperArgs = {

packages/language-support/src/helpers.ts

@@ -5,15 +5,15 @@ import antlrDefaultExport, {
   ParserRuleContext,
   Token,
 } from 'antlr4';
-import CypherLexer from './generated-parser/CypherLexer';
+import CypherLexer from './generated-parser/CypherCmdLexer';
 import CypherParser, {
   NodePatternContext,
   RelationshipPatternContext,
-  StatementsContext,
-} from './generated-parser/CypherParser';
+  StatementsOrCommandsContext,
+} from './generated-parser/CypherCmdParser';
 import { ParsingResult } from './parserWrapper';
 
-export function findStopNode(root: StatementsContext) {
+export function findStopNode(root: StatementsOrCommandsContext) {
   let children = root.children;
   let current: ParserRuleContext = root;
 

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

@@ -5,6 +5,7 @@ import {
   AnyExpressionContext,
   ArrowLineContext,
   BooleanLiteralContext,
+  ConsoleCommandContext,
   FunctionNameContext,
   KeywordLiteralContext,
   LabelNameContext,
@@ -14,6 +15,7 @@ import {
   NoneExpressionContext,
   NumberLiteralContext,
   ParameterContext,
+  ParamsArgsContext,
   ProcedureNameContext,
   ProcedureResultItemContext,
   PropertyKeyNameContext,
@@ -23,14 +25,15 @@ import {
   StringsLiteralContext,
   StringTokenContext,
   SymbolicNameStringContext,
+  UseCompletionRuleContext,
   VariableContext,
-} from '../../generated-parser/CypherParser';
+} from '../../generated-parser/CypherCmdParser';
 
 import {
   SemanticTokensLegend,
   SemanticTokenTypes,
 } from 'vscode-languageserver-types';
-import CypherParserListener from '../../generated-parser/CypherParserListener';
+import CypherParserListener from '../../generated-parser/CypherCmdParserListener';
 import { CypherTokenType } from '../../lexerSymbols';
 import { parserWrapper } from '../../parserWrapper';
 import {
@@ -74,6 +77,7 @@ export function mapCypherToSemanticTokenIndex(
     [CypherTokenType.label]: SemanticTokenTypes.type,
     [CypherTokenType.variable]: SemanticTokenTypes.variable,
     [CypherTokenType.symbolicName]: SemanticTokenTypes.variable,
+    [CypherTokenType.consoleCommand]: SemanticTokenTypes.macro,
   };
 
   const semanticTokenType = tokenMappings[cypherTokenType];
@@ -229,6 +233,43 @@ class SyntaxHighlighter extends CypherParserListener {
   exitSymbolicNameString = (ctx: SymbolicNameStringContext) => {
     this.addToken(ctx.start, CypherTokenType.symbolicName, ctx.getText());
   };
+
+  // Fix coloring of colon in console commands (operator -> consoleCommand)
+  exitConsoleCommand = (ctx: ConsoleCommandContext) => {
+    const colon = ctx.COLON();
+    this.addToken(
+      colon.symbol,
+      CypherTokenType.consoleCommand,
+      colon.getText(),
+    );
+  };
+
+  // console commands that clash with cypher keywords
+  exitUseCompletionRule = (ctx: UseCompletionRuleContext) => {
+    const use = ctx.USE();
+
+    this.addToken(use.symbol, CypherTokenType.consoleCommand, use.getText());
+  };
+
+  exitParamsArgs = (ctx: ParamsArgsContext) => {
+    const clear = ctx.CLEAR();
+    if (clear) {
+      this.addToken(
+        clear.symbol,
+        CypherTokenType.consoleCommand,
+        clear.getText(),
+      );
+    }
+
+    const list = ctx.listCompletionRule()?.LIST();
+    if (list) {
+      this.addToken(
+        list.symbol,
+        CypherTokenType.consoleCommand,
+        list.getText(),
+      );
+    }
+  };
 }
 
 function colourLexerTokens(tokens: Token[]) {

packages/language-support/src/highlighting/syntaxColouring/syntaxColouringHelpers.ts

@@ -2,7 +2,7 @@ import { SemanticTokenTypes } from 'vscode-languageserver-types';
 
 import { Token } from 'antlr4';
 
-import CypherLexer from '../../generated-parser/CypherLexer';
+import CypherLexer from '../../generated-parser/CypherCmdLexer';
 
 import { CypherTokenType, lexerSymbols } from '../../lexerSymbols';
 

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

@@ -2,8 +2,8 @@ import { Token } from 'antlr4';
 import type { ParserRuleContext } from 'antlr4-c3';
 import { CodeCompletionCore } from 'antlr4-c3';
 import { distance } from 'fastest-levenshtein';
-import CypherLexer from '../../generated-parser/CypherLexer';
-import CypherParser from '../../generated-parser/CypherParser';
+import CypherLexer from '../../generated-parser/CypherCmdLexer';
+import CypherParser from '../../generated-parser/CypherCmdParser';
 import { keywordNames, tokenNames } from '../../lexerSymbols';
 
 /*
@@ -64,6 +64,12 @@ export function completionCoreErrormessage(
   const tokenCandidates = Array.from(tokenEntries).flatMap(([tokenNumber]) => {
     const tokenName = tokenNames[tokenNumber];
 
+    // We don't want to suggest the ":" of console cmds as it's not helpful even
+    // when console cmds are available
+    if (caretIndex === 0 && tokenNumber === CypherLexer.COLON) {
+      return [];
+    }
+
     switch (tokenNumber) {
       case CypherLexer.DECIMAL_DOUBLE:
         humanReadableRulename.push('a decimal double');