Adds caret to autocompletions

Author: ncordon

packages/language-server/src/autocompletion.ts

@@ -4,8 +4,6 @@ import {
   TextDocuments,
 } from 'vscode-languageserver/node';
 
-import { Range } from 'vscode-languageserver-types';
-
 import { autocomplete } from '@neo4j-cypher/language-support';
 import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
 import { TextDocument } from 'vscode-languageserver-textdocument';
@@ -19,16 +17,12 @@ export function doAutoCompletion(
     if (textDocument === undefined) return [];
 
     const position: Position = textDocumentPosition.position;
-    const range: Range = {
-      // TODO Nacho: We are parsing from the begining of the file.
-      // Do we need to parse from the begining of the current query?
-      start: Position.create(0, 0),
-      end: position,
-    };
+    const offset = textDocument.offsetAt(position);
 
     return autocomplete(
-      textDocument.getText(range),
+      textDocument.getText(),
       neo4j.metadata?.dbSchema ?? {},
+      offset,
     );
   };
 }

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

@@ -1,15 +1,16 @@
 import { CompletionItem } from 'vscode-languageserver-types';
 
 import { DbSchema } from '../dbSchema';
+import { findCaret } from '../helpers';
 import { parserWrapper } from '../parserWrapper';
 import { completionCoreCompletion } from './completionCoreCompletions';
 
 export function autocomplete(
-  textUntilPosition: string,
+  query: string,
   dbSchema: DbSchema,
-  // TODO Add caret index here
+  caretPosition: number = query.length,
 ): CompletionItem[] {
-  const parsingResult = parserWrapper.parse(textUntilPosition);
+  const parsingResult = parserWrapper.parse(query);
   /* We try to locate the latest statement by finding the latest available `;` 
      in the query and take from that point to the end of the query
 
@@ -22,9 +23,10 @@ export function autocomplete(
      If there was no ;, we don't want to reparse, so we return undefined 
      inside findLatestStatement
   */
-  const lastStatement = parsingResult.statementsParsing.at(-1);
-  if (lastStatement !== undefined) {
-    return completionCoreCompletion(lastStatement, dbSchema);
+  const caret = findCaret(parsingResult, caretPosition);
+  if (caret) {
+    const statement = caret.statement;
+    return completionCoreCompletion(statement, dbSchema);
   }
 
   return [];

packages/language-support/src/helpers.ts

@@ -126,7 +126,7 @@ export function findCaret(
 
     while (j < tokens.length && keepLooking) {
       const currentToken = tokens[j];
-      keepLooking = currentToken.start < caretPosition;
+      keepLooking = currentToken.start <= caretPosition;
 
       if (currentToken.channel === 0 && keepLooking) {
         result = { statement: statement, token: currentToken };

packages/language-support/src/parserWrapper.ts

@@ -101,6 +101,7 @@ export function createParsingScaffolding(query: string): ParsingScaffolding {
     stmTokenStreams.map((t) => {
       const tokens = [...t.tokens];
       const parser = new CypherParser(t);
+      parser.removeErrorListeners();
 
       return {
         parser: parser,
@@ -134,7 +135,6 @@ export function createParsingResult(query: string): ParsingResult {
       const variableFinder = new VariableCollector();
       const errorListener = new SyntaxErrorsListener();
       parser._parseListeners = [labelsCollector, variableFinder];
-      parser.removeErrorListeners();
       parser.addErrorListener(errorListener);
       const ctx = parser.statementsOrCommands();
       // The statement is empty if we cannot find anything that is not EOF or a space

packages/language-support/src/signatureHelp.ts

@@ -134,31 +134,43 @@ class SignatureHelper extends CypherCmdParserListener {
 }
 
 export function signatureHelp(
-  fullQuery: string,
+  query: string,
   dbSchema: DbSchema,
-  caretPosition: number,
+  caretPosition: number = query.length,
 ): SignatureHelp {
   let result: SignatureHelp = emptyResult;
-
-  const parserResult = parserWrapper.parse(fullQuery);
-  const caret = findCaret(parserResult, caretPosition);
-
-  if (caret) {
-    const statement = caret.statement;
-
-    const signatureHelper = new SignatureHelper(statement.tokens, caret.token);
-
-    ParseTreeWalker.DEFAULT.walk(signatureHelper, statement.ctx);
-    const method = signatureHelper.result;
-
-    if (method !== undefined) {
-      if (method.methodType === MethodType.function) {
-        result = toSignatureHelp(dbSchema.functionSignatures, method);
-      } else {
-        result = toSignatureHelp(dbSchema.procedureSignatures, method);
+  /* We need the token inmediately before the caret
+  
+      CALL something(
+                     ^
+     because in this case what gives us information on where we are 
+     in the procedure is not the space at the caret, but the opening (                
+  */
+  const prevCaretPosition = caretPosition - 1;
+
+  if (prevCaretPosition > 0) {
+    const parserResult = parserWrapper.parse(query);
+    const caret = findCaret(parserResult, prevCaretPosition);
+
+    if (caret) {
+      const statement = caret.statement;
+
+      const signatureHelper = new SignatureHelper(
+        statement.tokens,
+        caret.token,
+      );
+
+      ParseTreeWalker.DEFAULT.walk(signatureHelper, statement.ctx);
+      const method = signatureHelper.result;
+
+      if (method !== undefined) {
+        if (method.methodType === MethodType.function) {
+          result = toSignatureHelp(dbSchema.functionSignatures, method);
+        } else {
+          result = toSignatureHelp(dbSchema.procedureSignatures, method);
+        }
       }
     }
   }
-
   return result;
 }

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

@@ -4,18 +4,20 @@ import { DbSchema } from '../../dbSchema';
 
 export function testCompletions({
   query,
+  offset = query.length,
   dbSchema = {},
   excluded = [],
   expected = [],
   assertEmpty = false,
 }: {
   query: string;
+  offset?: number;
   dbSchema?: DbSchema;
   excluded?: Partial<CompletionItem>[];
   expected?: CompletionItem[];
   assertEmpty?: boolean;
 }) {
-  const actualCompletionList = autocomplete(query, dbSchema);
+  const actualCompletionList = autocomplete(query, dbSchema, offset);
 
   if (assertEmpty) {
     expect(actualCompletionList).toEqual([]);

packages/language-support/src/tests/benchmarks/benchmark.ts

@@ -107,16 +107,16 @@ suite
     const query = largePokemonquery + periodicIterate + periodicIterateFirstArg;
     parserWrapper.clearCache();
     // This mimics getting the cursor back in the query and retriggering signature help
-    signatureHelp(query, testData.mockSchema, query.length - 1);
-    signatureHelp(query, testData.mockSchema, subQuery.length - 1);
+    signatureHelp(query, testData.mockSchema, query.length);
+    signatureHelp(query, testData.mockSchema, subQuery.length);
   })
   .add('multistatement - autocompletion', function () {
     const query = tictactoe + ';\n' + tictactoe;
     const subQuery = tictactoe;
     parserWrapper.clearCache();
     // This mimics getting the cursor back in the query and retriggering auto-completion
     autocomplete(query, testData.mockSchema);
-    autocomplete(subQuery, testData.mockSchema);
+    autocomplete(query, testData.mockSchema, subQuery.length);
   });
 
 Object.entries(autocompletionQueries).forEach(([name, query]) => {