runDumpCommand

Author: cristianoc

server/src/dumpCommand.ts

@@ -0,0 +1,37 @@
+import { fileURLToPath } from "url";
+import { RequestMessage } from "vscode-languageserver";
+import * as utils from "./utils";
+import * as path from "path";
+import { exec } from "child_process";
+
+export function runDumpCommand(
+	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) {
+    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 +
+      " dump " +
+      filePath +
+      ":" +
+      msg.params.position.line +
+      ":" +
+      msg.params.position.character;
+    exec(command, { cwd: projectRootPath }, function (_error, _stdout, stderr) {
+      let result = JSON.parse(stderr);
+      if (result && result[0]) {
+        onResult(result[0]);
+      } else {
+        onResult(null);
+      }
+    });
+  }
+}

server/src/server.ts

@@ -20,6 +20,8 @@ import * as chokidar from "chokidar";
 import { assert } from "console";
 import { fileURLToPath } from "url";
 import { ChildProcess } from "child_process";
+import { runDumpCommand } 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.
@@ -313,32 +315,50 @@ process.on("message", (msg: m.Message) => {
         process.send!(response);
       }
     } else if (msg.method === p.HoverRequest.method) {
-      let dummyHoverResponse: m.ResponseMessage = {
+      let emptyHoverResponse: m.ResponseMessage = {
         jsonrpc: c.jsonrpcVersion,
         id: msg.id,
         // type result = Hover | null
         // type Hover = {contents: MarkedString | MarkedString[] | MarkupContent, range?: Range}
-        result: { contents: "Time to go for a 20k run!" },
+        result: null,
       };
-
-      process.send!(dummyHoverResponse);
+      runDumpCommand(msg, (result) => {
+        if (result && result.hover) {
+          let hoverResponse: m.ResponseMessage = {
+            ...emptyHoverResponse,
+            result: {
+              contents: result.hover,
+            },
+          };
+          process.send!(hoverResponse);
+        } else {
+          process.send!(emptyHoverResponse);
+        }
+      });
     } else if (msg.method === p.DefinitionRequest.method) {
       // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_definition
-      let dummyDefinitionResponse: m.ResponseMessage = {
+      let emptyDefinitionResponse: m.ResponseMessage = {
         jsonrpc: c.jsonrpcVersion,
         id: msg.id,
         // result should be: Location | Array<Location> | Array<LocationLink> | null
-        result: {
-          uri: msg.params.textDocument.uri,
-          range: {
-            start: { line: 2, character: 4 },
-            end: { line: 2, character: 12 },
-          },
-        },
+        result: null,
         // error: code and message set in case an exception happens during the definition request.
       };
 
-      process.send!(dummyDefinitionResponse);
+      runDumpCommand(msg, (result) => {
+        if (result && result.definition) {
+          let definitionResponse: m.ResponseMessage = {
+            ...emptyDefinitionResponse,
+            result: {
+              uri: result.definition.uri || msg.params.textDocument.uri,
+              range: result.definition.range,
+            },
+          };
+          process.send!(definitionResponse);
+        } else {
+          process.send!(emptyDefinitionResponse);
+        }
+      });
     } 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