Add support for autocompletion command.

Author: cristianoc

server/src/dumpCommand.ts

@@ -3,29 +3,44 @@ import { RequestMessage } from "vscode-languageserver";
 import * as utils from "./utils";
 import * as path from "path";
 import { exec } from "child_process";
+import * as tmp from "tmp";
+import fs from "fs";
+
+let findExecutable = (uri: string) => {
+  let filePath = fileURLToPath(uri);
+  let projectRootPath = utils.findProjectRootOfFile(filePath);
+  if (projectRootPath == null) {
+    return null;
+  } else {
+    // Currently assumes the dump command is "bin.exe" at the project root.
+    let binaryPath = path.join(projectRootPath, "bin.exe");
+    if (fs.existsSync(binaryPath)) {
+      return { binaryPath, filePath, cwd: projectRootPath };
+    } else {
+      return null;
+    }
+  }
+};
 
 export function runDumpCommand(
-	msg: RequestMessage,
+  msg: RequestMessage,
   onResult: (
     result: { hover?: string; definition?: { uri?: string; range: any } } | null
   ) => void
 ) {
-  let filePath = fileURLToPath(msg.params.textDocument.uri);
-  let projectRootPath = utils.findProjectRootOfFile(filePath);
-  if (projectRootPath == null) {
+  let executable = findExecutable(msg.params.textDocument.uri);
+  if (executable == null) {
     onResult(null);
   } else {
-	// Currently assumes the dump command is "bin.exe" at the project root.
-    let commandPath = path.join(projectRootPath, "bin.exe");
     let command =
-      commandPath +
+      executable.binaryPath +
       " dump " +
-      filePath +
+      executable.filePath +
       ":" +
       msg.params.position.line +
       ":" +
       msg.params.position.character;
-    exec(command, { cwd: projectRootPath }, function (_error, _stdout, stderr) {
+    exec(command, { cwd: executable.cwd }, function (_error, _stdout, stderr) {
       let result = JSON.parse(stderr);
       if (result && result[0]) {
         onResult(result[0]);
@@ -35,3 +50,39 @@ export function runDumpCommand(
     });
   }
 }
+
+export function runCompletionCommand(
+  msg: RequestMessage,
+  code: string,
+  onResult: (result: [{ label: string }] | null) => void
+) {
+  let executable = findExecutable(msg.params.textDocument.uri);
+  if (executable == null) {
+    onResult(null);
+  } else {
+    let tmpobj = tmp.fileSync();
+    let tmpname = tmpobj.name;
+    fs.writeFileSync(tmpname, code, { encoding: "utf-8" });
+
+    let command =
+      executable.binaryPath +
+      " complete " +
+      executable.filePath +
+      ":" +
+      msg.params.position.line +
+      ":" +
+      msg.params.position.character +
+      " " +
+      tmpname;
+
+    exec(command, { cwd: executable.cwd }, function (_error, _stdout, stderr) {
+      tmpobj.removeCallback();
+      let result = JSON.parse(stderr);
+      if (result && result[0]) {
+        onResult(result);
+      } else {
+        onResult(null);
+      }
+    });
+  }
+}

server/src/server.ts

@@ -20,8 +20,7 @@ import * as chokidar from "chokidar";
 import { assert } from "console";
 import { fileURLToPath } from "url";
 import { ChildProcess } from "child_process";
-import { runDumpCommand } from "./dumpCommand";
-
+import { runDumpCommand, runCompletionCommand } from "./dumpCommand";
 
 // https://microsoft.github.io/language-server-protocol/specification#initialize
 // According to the spec, there could be requests before the 'initialize' request. Link in comment tells how to handle them.
@@ -272,6 +271,7 @@ process.on("message", (msg: m.Message) => {
           documentFormattingProvider: true,
           hoverProvider: true,
           definitionProvider: true,
+          completionProvider: { triggerCharacters: ["."] },
         },
       };
       let response: m.ResponseMessage = {
@@ -359,6 +359,24 @@ process.on("message", (msg: m.Message) => {
           process.send!(emptyDefinitionResponse);
         }
       });
+    } else if (msg.method === p.CompletionRequest.method) {
+      let emptyCompletionResponse: m.ResponseMessage = {
+        jsonrpc: c.jsonrpcVersion,
+        id: msg.id,
+        result: null,
+      };
+      let code = getOpenedFileContent(msg.params.textDocument.uri);
+      runCompletionCommand(msg, code, (result) => {
+        if (result) {
+          let definitionResponse: m.ResponseMessage = {
+            ...emptyCompletionResponse,
+            result: result,
+          };
+          process.send!(definitionResponse);
+        } else {
+          process.send!(emptyCompletionResponse);
+        }
+      });
     } else if (msg.method === p.DocumentFormattingRequest.method) {
       // technically, a formatting failure should reply with the error. Sadly
       // the LSP alert box for these error replies sucks (e.g. doesn't actually