The binaryPath setting is using to find resctipt binary

Author: An-Tu

server/src/constants.ts

@@ -32,15 +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

@@ -65,6 +65,11 @@ let codeActionsFromDiagnostics: codeActions.filesCodeActions = {};
 // will be properly defined later depending on the mode (stdio/node-rpc)
 let send: (msg: p.Message) => void = (_) => {};
 
+let findBinary = (projectRootPath: p.DocumentUri) =>
+  extensionConfiguration.binaryPath === null
+    ? utils.findNodeBuildOfProjectRoot(projectRootPath)
+    : utils.findBinaryFromConfig(extensionConfiguration.binaryPath);
+
 interface CreateInterfaceRequestParams {
   uri: string;
 }
@@ -235,7 +240,7 @@ 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 (findBinary(projectRootPath) != null) {
         let payload: clientSentBuildAction = {
           title: c.startBuildAction,
           projectRootPath: projectRootPath,
@@ -1059,7 +1064,7 @@ 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 = findBinary(projectRootPath);
       if (found != null) {
         let bsbProcess = utils.runBuildWatcherUsingValidBuildPath(
           found.buildPath,

server/src/utils.ts

@@ -84,20 +84,33 @@ let findBscBinFromConfig = (
 };
 
 // TODO: this doesn't handle file:/// scheme
-export let findNodeBuildOfProjectRoot = (
-  projectRootPath: p.DocumentUri
-): null | { buildPath: p.DocumentUri; isReScript: boolean } => {
-  let rescriptNodePath = path.join(projectRootPath, c.rescriptNodePartialPath);
-  let bsbNodePath = path.join(projectRootPath, c.bsbNodePartialPath);
-
-  if (fs.existsSync(rescriptNodePath)) {
-    return { buildPath: rescriptNodePath, isReScript: true };
-  } else if (fs.existsSync(bsbNodePath)) {
-    return { buildPath: bsbNodePath, isReScript: false };
+let findBinaryBase = ({
+  rescriptPath,
+  bsbPath,
+}: {
+  rescriptPath: p.DocumentUri;
+  bsbPath: p.DocumentUri;
+}): null | { buildPath: p.DocumentUri; isReScript: boolean } => {
+  if (fs.existsSync(rescriptPath)) {
+    return { buildPath: rescriptPath, isReScript: true };
+  } else if (fs.existsSync(bsbPath)) {
+    return { buildPath: bsbPath, isReScript: false };
   }
   return null;
 };
 
+export let findBinaryFromConfig = (pathToBinFromConfig: p.DocumentUri) =>
+  findBinaryBase({
+    rescriptPath: path.join(pathToBinFromConfig, c.rescriptBinName),
+    bsbPath: path.join(pathToBinFromConfig, c.bsbBinName),
+  });
+
+export let findNodeBuildOfProjectRoot = (projectRootPath: p.DocumentUri) =>
+  findBinaryBase({
+    rescriptPath: path.join(projectRootPath, c.rescriptNodePartialPath),
+    bsbPath: path.join(projectRootPath, c.bsbNodePartialPath),
+  });
+
 type execResult =
   | {
       kind: "success";