The binaryPath option was added to the rescript.settings

Author: An-Tu

package.json

@@ -131,6 +131,11 @@
 					"type": "boolean",
 					"default": false,
 					"description": "Automatically start ReScript's code analysis."
+				},
+				"rescript.settings.binaryPath": {
+					"type": ["string", "null"],
+					"default": null,
+					"description": "Path to the directory where ReScript binaries are. You can use it if you haven't or don't want to use the installed ReScript from node_modules in your project."
 				}
 			}
 		},

server/src/constants.ts

@@ -32,13 +32,19 @@ export let analysisProdPath = path.join(
   "rescript-editor-analysis.exe"
 );
 
+export let rescriptBinName = "rescript";
+
+export let bsbBinName = "bsb";
+
+export let bscBinName = "bsc";
+
 // can't use the native bsb/rescript since we might need the watcher -w flag, which is only in the JS wrapper
 export let rescriptNodePartialPath = path.join(
   "node_modules",
   ".bin",
-  "rescript"
+  rescriptBinName,
 );
-export let bsbNodePartialPath = path.join("node_modules", ".bin", "bsb");
+export let bsbNodePartialPath = path.join("node_modules", ".bin", bsbBinName);
 
 export let bsbLock = ".bsb.lock";
 export let bsconfigPartialPath = "bsconfig.json";

server/src/server.ts

@@ -4,6 +4,7 @@ import * as v from "vscode-languageserver";
 import * as rpc from "vscode-jsonrpc/node";
 import * as path from "path";
 import fs from "fs";
+import os from "os";
 // TODO: check DidChangeWatchedFilesNotification.
 import {
   DidOpenTextDocumentNotification,
@@ -24,9 +25,11 @@ import { filesDiagnostics } from "./utils";
 
 interface extensionConfiguration {
   askToStartBuild: boolean;
+  binaryPath: string | null;
 }
 let extensionConfiguration: extensionConfiguration = {
   askToStartBuild: true,
+  binaryPath: null,
 };
 let pullConfigurationPeriodically: NodeJS.Timeout | null = null;
 
@@ -232,7 +235,12 @@ let openedFile = (fileUri: string, fileContent: string) => {
       // TODO: sometime stale .bsb.lock dangling. bsb -w knows .bsb.lock is
       // stale. Use that logic
       // TODO: close watcher when lang-server shuts down
-      if (utils.findNodeBuildOfProjectRoot(projectRootPath) != null) {
+      if (
+        utils.findNodeBuildOfProjectRoot(
+          projectRootPath,
+          extensionConfiguration.binaryPath
+        ) != null
+      ) {
         let payload: clientSentBuildAction = {
           title: c.startBuildAction,
           projectRootPath: projectRootPath,
@@ -254,7 +262,19 @@ let openedFile = (fileUri: string, fileContent: string) => {
         // handle in the isResponseMessage check in the message handling way
         // below
       } else {
-        // we should send something to say that we can't find bsb.exe. But right now we'll silently not do anything
+        let binaryPath = extensionConfiguration.binaryPath === null
+          ? path.join(projectRootPath, "node_modules", ".bin")
+          : extensionConfiguration.binaryPath;
+
+        let request: p.NotificationMessage = {
+          jsonrpc: c.jsonrpcVersion,
+          method: "window/showMessage",
+          params: {
+            type: p.MessageType.Error,
+            message: `Can't find ReScript binary on path ${binaryPath}`,
+          },
+        };
+        send(request);
       }
     }
 
@@ -593,7 +613,11 @@ function format(msg: p.RequestMessage): Array<p.Message> {
   } else {
     // code will always be defined here, even though technically it can be undefined
     let code = getOpenedFileContent(params.textDocument.uri);
-    let formattedResult = utils.formatCode(filePath, code);
+    let formattedResult = utils.formatCode(
+      extensionConfiguration.binaryPath,
+      filePath,
+      code
+    );
     if (formattedResult.kind === "success") {
       let max = code.length;
       let result: p.TextEdit[] = [
@@ -933,6 +957,17 @@ function onMessage(msg: p.Message) {
 
       if (initialConfiguration != null) {
         extensionConfiguration = initialConfiguration;
+        if (
+          extensionConfiguration.binaryPath !== null &&
+          extensionConfiguration.binaryPath[0] === "~"
+        ) {
+          // What should happen if the path contains the home directory symbol?
+          // This situation is handled below, but maybe it isn't the best option.
+          extensionConfiguration.binaryPath = path.join(
+            os.homedir(),
+            extensionConfiguration.binaryPath.slice(1)
+          );
+        }
       }
 
       send(response);
@@ -1041,7 +1076,10 @@ function onMessage(msg: p.Message) {
       // TODO: close watcher when lang-server shuts down. However, by Node's
       // default, these subprocesses are automatically killed when this
       // language-server process exits
-      let found = utils.findNodeBuildOfProjectRoot(projectRootPath);
+      let found = utils.findNodeBuildOfProjectRoot(
+        projectRootPath,
+        extensionConfiguration.binaryPath
+      );
       if (found != null) {
         let bsbProcess = utils.runBuildWatcherUsingValidBuildPath(
           found.buildPath,

server/src/utils.ts

@@ -70,12 +70,32 @@ export let findBscNativeOfFile = (
   }
 };
 
+let findBscBinFromConfig = (
+  pathToBinFromConfig: p.DocumentUri | null
+): null | p.DocumentUri => {
+  if (pathToBinFromConfig === null) {
+    return null;
+  }
+  let bscPath = path.join(pathToBinFromConfig, c.bscBinName);
+  if (fs.existsSync(bscPath)) {
+    return bscPath;
+  }
+  return null;
+};
+
 // TODO: this doesn't handle file:/// scheme
 export let findNodeBuildOfProjectRoot = (
-  projectRootPath: p.DocumentUri
+  projectRootPath: p.DocumentUri,
+  pathToBinFromConfig: p.DocumentUri | null
 ): null | { buildPath: p.DocumentUri; isReScript: boolean } => {
-  let rescriptNodePath = path.join(projectRootPath, c.rescriptNodePartialPath);
-  let bsbNodePath = path.join(projectRootPath, c.bsbNodePartialPath);
+  let rescriptNodePath =
+    pathToBinFromConfig === null
+      ? path.join(projectRootPath, c.rescriptNodePartialPath)
+      : path.join(pathToBinFromConfig, c.rescriptBinName);
+  let bsbNodePath =
+    pathToBinFromConfig === null
+      ? path.join(projectRootPath, c.bsbNodePartialPath)
+      : path.join(pathToBinFromConfig, c.bsbBinName);
 
   if (fs.existsSync(rescriptNodePath)) {
     return { buildPath: rescriptNodePath, isReScript: true };
@@ -94,21 +114,29 @@ type execResult =
       kind: "error";
       error: string;
     };
-export let formatCode = (filePath: string, code: string): execResult => {
+export let formatCode = (
+  pathToBinFromConfig: p.DocumentUri | null,
+  filePath: string,
+  code: string
+): execResult => {
   let extension = path.extname(filePath);
   let formatTempFileFullPath = createFileInTempDir(extension);
   fs.writeFileSync(formatTempFileFullPath, code, {
     encoding: "utf-8",
   });
   try {
+    // Try to find the bsc bin from the binaryPath setting from the configuration.
+    let bscPath = findBscBinFromConfig(pathToBinFromConfig);
+
     // See comment on findBscNativeDirOfFile for why we need
     // to recursively search for bsc.exe upward
-    let bscNativePath = findBscNativeOfFile(filePath);
+    bscPath = bscPath == null ? findBscNativeOfFile(filePath) : bscPath;
 
-    // Default to using the project formatter. If not, use the one we ship with
-    // the analysis binary in the extension itself.
-    if (bscNativePath != null) {
-      let result = childProcess.execFileSync(bscNativePath, [
+    // Default to using the formatter from the binaryPath setting from the configuration
+    // or the project formatter.
+    // If not, use the one we ship with the analysis binary in the extension itself.
+    if (bscPath != null) {
+      let result = childProcess.execFileSync(bscPath, [
         "-color",
         "never",
         "-format",