Logic for finding binary: use shared logic between client and server.

Author: cristianoc

client/src/commands.ts

@@ -13,14 +13,12 @@ export { pasteAsRescriptJson } from "./commands/paste_as_rescript_json";
 export { pasteAsRescriptJsx } from "./commands/paste_as_rescript_jsx";
 
 export const codeAnalysisWithReanalyze = (
-  targetDir: string | null,
   diagnosticsCollection: DiagnosticCollection,
   diagnosticsResultCodeActions: DiagnosticsResultCodeActionsMap,
   outputChannel: OutputChannel,
   codeAnalysisRunningStatusBarItem: StatusBarItem,
 ) => {
   runCodeAnalysisWithReanalyze(
-    targetDir,
     diagnosticsCollection,
     diagnosticsResultCodeActions,
     outputChannel,

client/src/commands/code_analysis.ts

@@ -15,11 +15,12 @@ import {
   OutputChannel,
   StatusBarItem,
 } from "vscode";
+import { getBinaryPath, NormalizedPath, normalizePath } from "../utils";
 import {
-  findProjectRootOfFileInDir,
-  getBinaryPath,
-  NormalizedPath,
-} from "../utils";
+  findBinary,
+  findBinary as findSharedBinary,
+} from "../../../shared/src/findBinary";
+import { findProjectRootOfFile } from "../../../shared/src/projectRoots";
 
 export let statusBarItem = {
   setToStopText: (codeAnalysisRunningStatusBarItem: StatusBarItem) => {
@@ -203,58 +204,41 @@ let resultsToDiagnostics = (
   };
 };
 
-export const runCodeAnalysisWithReanalyze = (
-  targetDir: string | null,
+export const runCodeAnalysisWithReanalyze = async (
   diagnosticsCollection: DiagnosticCollection,
   diagnosticsResultCodeActions: DiagnosticsResultCodeActionsMap,
   outputChannel: OutputChannel,
   codeAnalysisRunningStatusBarItem: StatusBarItem,
 ) => {
   let currentDocument = window.activeTextEditor.document;
-  let cwd = targetDir ?? path.dirname(currentDocument.uri.fsPath);
 
-  // Resolve the project root from `cwd` (which is the workspace root when code analysis is started),
-  // rather than from the currently-open file (which may be in a subpackage).
-  let projectRootPath: NormalizedPath | null = findProjectRootOfFileInDir(
-    path.join(cwd, "bsconfig.json"),
+  let projectRootPath: NormalizedPath | null = normalizePath(
+    findProjectRootOfFile(currentDocument.uri.fsPath),
   );
-  if (projectRootPath == null) {
-    projectRootPath = findProjectRootOfFileInDir(currentDocument.uri.fsPath);
-  }
-
-  // Try v12+ path first: @rescript/{platform}-{arch}/bin/rescript-tools.exe
-  // Then fall back to legacy paths via getBinaryPath
-  let binaryPath: string | null = null;
-  if (projectRootPath != null) {
-    const v12Path = path.join(
-      projectRootPath,
-      "node_modules",
-      "@rescript",
-      `${process.platform}-${process.arch}`,
-      "bin",
-      "rescript-tools.exe",
-    );
-    if (fs.existsSync(v12Path)) {
-      binaryPath = v12Path;
-    }
-  }
+  let binaryPath: string | null = await findBinary({
+    projectRootPath,
+    binary: "rescript-tools.exe",
+  });
   if (binaryPath == null) {
-    binaryPath =
-      getBinaryPath("rescript-tools.exe", projectRootPath) ??
-      getBinaryPath("rescript-editor-analysis.exe", projectRootPath);
+    binaryPath = await findBinary({
+      projectRootPath,
+      binary: "rescript-editor-analysis.exe",
+    });
   }
 
   if (binaryPath === null) {
     window.showErrorMessage("Binary executable not found.");
     return;
   }
 
+  // Strip everything after the outermost node_modules segment to get the project root.
+  let cwd =
+    binaryPath.match(/^(.*?)[\\/]+node_modules([\\/]+|$)/)?.[1] ?? binaryPath;
+
   statusBarItem.setToRunningText(codeAnalysisRunningStatusBarItem);
 
   let opts = ["reanalyze", "-json"];
-  let p = cp.spawn(binaryPath, opts, {
-    cwd,
-  });
+  let p = cp.spawn(binaryPath, opts, { cwd });
 
   if (p.stdout == null) {
     statusBarItem.setToFailed(codeAnalysisRunningStatusBarItem);

client/src/extension.ts

@@ -155,7 +155,6 @@ export function activate(context: ExtensionContext) {
             client.onNotification("rescript/compilationFinished", () => {
               if (inCodeAnalysisState.active === true) {
                 customCommands.codeAnalysisWithReanalyze(
-                  inCodeAnalysisState.activatedFromDirectory,
                   diagnosticsCollection,
                   diagnosticsResultCodeActions,
                   outputChannel,
@@ -308,8 +307,7 @@ export function activate(context: ExtensionContext) {
 
   let inCodeAnalysisState: {
     active: boolean;
-    activatedFromDirectory: string | null;
-  } = { active: false, activatedFromDirectory: null };
+  } = { active: false };
 
   // This code actions provider yields the code actions potentially extracted
   // from the code analysis to the editor.
@@ -442,19 +440,12 @@ export function activate(context: ExtensionContext) {
 
     inCodeAnalysisState.active = true;
 
-    // Run reanalyze from the workspace root (so monorepos consistently analyze the root project),
-    // instead of from whatever file happened to be active when analysis was started.
-    const wsFolder = workspace.getWorkspaceFolder(currentDocument.uri);
-    inCodeAnalysisState.activatedFromDirectory =
-      wsFolder?.uri.fsPath ?? path.dirname(currentDocument.uri.fsPath);
-
     codeAnalysisRunningStatusBarItem.command =
       "rescript-vscode.stop_code_analysis";
     codeAnalysisRunningStatusBarItem.show();
     statusBarItem.setToStopText(codeAnalysisRunningStatusBarItem);
 
     customCommands.codeAnalysisWithReanalyze(
-      inCodeAnalysisState.activatedFromDirectory,
       diagnosticsCollection,
       diagnosticsResultCodeActions,
       outputChannel,
@@ -464,7 +455,6 @@ export function activate(context: ExtensionContext) {
 
   commands.registerCommand("rescript-vscode.stop_code_analysis", () => {
     inCodeAnalysisState.active = false;
-    inCodeAnalysisState.activatedFromDirectory = null;
 
     diagnosticsCollection.clear();
     diagnosticsResultCodeActions.clear();

client/src/utils.ts

@@ -2,6 +2,11 @@ import * as path from "path";
 import * as fs from "fs";
 import * as os from "os";
 import { DocumentUri } from "vscode-languageclient";
+import { findBinary, type BinaryName } from "../../shared/src/findBinary";
+import {
+  findProjectRootOfFileInDir as findProjectRootOfFileInDirShared,
+  normalizePath as normalizePathShared,
+} from "../../shared/src/projectRoots";
 
 /*
  * Much of the code in here is duplicated from the server code.
@@ -27,7 +32,7 @@ export type NormalizedPath = string & { __brand: "NormalizedPath" };
  */
 export function normalizePath(filePath: string | null): NormalizedPath | null {
   // `path.normalize` ensures we can assume string is now NormalizedPath
-  return filePath != null ? (path.normalize(filePath) as NormalizedPath) : null;
+  return normalizePathShared(filePath) as NormalizedPath | null;
 }
 
 type binaryName = "rescript-editor-analysis.exe" | "rescript-tools.exe";
@@ -83,25 +88,7 @@ export const createFileInTempDir = (prefix = "", extension = "") => {
 export let findProjectRootOfFileInDir = (
   source: string,
 ): NormalizedPath | null => {
-  const normalizedSource = normalizePath(source);
-  if (normalizedSource == null) {
-    return null;
-  }
-  const dir = normalizePath(path.dirname(normalizedSource));
-  if (dir == null) {
-    return null;
-  }
-  if (
-    fs.existsSync(path.join(dir, "rescript.json")) ||
-    fs.existsSync(path.join(dir, "bsconfig.json"))
-  ) {
-    return dir;
-  } else {
-    if (dir === normalizedSource) {
-      // reached top
-      return null;
-    } else {
-      return findProjectRootOfFileInDir(dir);
-    }
-  }
+  return normalizePath(findProjectRootOfFileInDirShared(source));
 };
+
+export { findBinary, BinaryName };

client/tsconfig.json

@@ -4,9 +4,9 @@
     "target": "es2019",
     "lib": ["ES2019"],
     "outDir": "out",
-    "rootDir": "src",
+    "rootDirs": ["src", "../shared/src"],
     "sourceMap": true
   },
-  "include": ["src"],
+  "include": ["src", "../shared/src"],
   "exclude": ["node_modules"]
 }

server/src/server.ts

@@ -118,28 +118,16 @@ let findRescriptBinary = async (
 ): Promise<utils.NormalizedPath | null> => {
   if (
     config.extensionConfiguration.binaryPath != null &&
-    (fs.existsSync(
-      path.join(config.extensionConfiguration.binaryPath, "rescript.exe"),
-    ) ||
-      fs.existsSync(
-        path.join(config.extensionConfiguration.binaryPath, "rescript"),
-      ))
+    fs.existsSync(
+      path.join(config.extensionConfiguration.binaryPath, "rescript"),
+    )
   ) {
     return utils.normalizePath(
-      fs.existsSync(
-        path.join(config.extensionConfiguration.binaryPath, "rescript.exe"),
-      )
-        ? path.join(config.extensionConfiguration.binaryPath, "rescript.exe")
-        : path.join(config.extensionConfiguration.binaryPath, "rescript"),
+      path.join(config.extensionConfiguration.binaryPath, "rescript"),
     );
   }
 
-  // Prefer the native rescript.exe (v12+) for spawning `build -w`.
-  // Fall back to the legacy/JS wrapper `rescript` path if needed.
-  return (
-    (await utils.findRescriptExeBinary(projectRootPath)) ??
-    (await utils.findRescriptBinary(projectRootPath))
-  );
+  return utils.findRescriptBinary(projectRootPath);
 };
 
 let createInterfaceRequest = new v.RequestType<

server/src/utils.ts

@@ -12,6 +12,11 @@ import * as os from "os";
 import semver from "semver";
 import { fileURLToPath, pathToFileURL } from "url";
 
+import {
+  findBinary as findSharedBinary,
+  type BinaryName,
+} from "../../shared/src/findBinary";
+import { findProjectRootOfFileInDir as findProjectRootOfFileInDirShared } from "../../shared/src/projectRoots";
 import * as codeActions from "./codeActions";
 import * as c from "./constants";
 import * as lookup from "./lookup";
@@ -85,23 +90,7 @@ export let createFileInTempDir = (extension = ""): NormalizedPath => {
 function findProjectRootOfFileInDir(
   source: NormalizedPath,
 ): NormalizedPath | null {
-  const dir = normalizePath(path.dirname(source));
-  if (dir == null) {
-    return null;
-  }
-  if (
-    fs.existsSync(path.join(dir, c.rescriptJsonPartialPath)) ||
-    fs.existsSync(path.join(dir, c.bsconfigPartialPath))
-  ) {
-    return dir;
-  } else {
-    if (dir === source) {
-      // reached top
-      return null;
-    } else {
-      return findProjectRootOfFileInDir(dir);
-    }
-  }
+  return normalizePath(findProjectRootOfFileInDirShared(source));
 }
 
 /**
@@ -216,98 +205,14 @@ export let getProjectFile = (
 // We won't know which version is in the project root until we read and parse `{project_root}/node_modules/rescript/package.json`
 let findBinary = async (
   projectRootPath: NormalizedPath | null,
-  binary:
-    | "bsc.exe"
-    | "rescript-editor-analysis.exe"
-    | "rescript"
-    | "rewatch.exe"
-    | "rescript.exe",
+  binary: BinaryName,
 ): Promise<NormalizedPath | null> => {
-  if (config.extensionConfiguration.platformPath != null) {
-    const result = path.join(
-      config.extensionConfiguration.platformPath,
-      binary,
-    );
-    return normalizePath(result);
-  }
-
-  if (projectRootPath !== null) {
-    try {
-      const compilerInfo = path.resolve(
-        projectRootPath,
-        c.compilerInfoPartialPath,
-      );
-      const contents = await fsAsync.readFile(compilerInfo, "utf8");
-      const compileInfo = JSON.parse(contents);
-      if (compileInfo && compileInfo.bsc_path) {
-        const bsc_path = compileInfo.bsc_path;
-        if (binary === "bsc.exe") {
-          return normalizePath(bsc_path);
-        } else {
-          const binary_path = path.join(path.dirname(bsc_path), binary);
-          return normalizePath(binary_path);
-        }
-      }
-    } catch {}
-  }
-
-  const rescriptDir = lookup.findFilePathFromProjectRoot(
+  const result = await findSharedBinary({
     projectRootPath,
-    path.join("node_modules", "rescript"),
-  );
-  if (rescriptDir == null) {
-    return null;
-  }
-
-  let rescriptVersion = null;
-  let rescriptJSWrapperPath = null;
-  try {
-    const rescriptPackageJSONPath = path.join(rescriptDir, "package.json");
-    const rescriptPackageJSON = JSON.parse(
-      await fsAsync.readFile(rescriptPackageJSONPath, "utf-8"),
-    );
-    rescriptVersion = rescriptPackageJSON.version;
-    rescriptJSWrapperPath = rescriptPackageJSON.bin.rescript;
-  } catch (error) {
-    return null;
-  }
-
-  let binaryPath: string | null = null;
-  if (binary == "rescript") {
-    // Can't use the native bsb/rescript since we might need the watcher -w
-    // flag, which is only in the JS wrapper
-    binaryPath = path.join(rescriptDir, rescriptJSWrapperPath);
-  } else if (semver.gte(rescriptVersion, "12.0.0-alpha.13")) {
-    // TODO: export `binPaths` from `rescript` package so that we don't need to
-    // copy the logic for figuring out `target`.
-    const target = `${process.platform}-${process.arch}`;
-    // Use realpathSync to resolve symlinks, which is necessary for package
-    // managers like Deno and pnpm that use symlinked node_modules structures.
-    const targetPackagePath = path.join(
-      fs.realpathSync(rescriptDir),
-      "..",
-      `@rescript/${target}/bin.js`,
-    );
-    const { binPaths } = await import(targetPackagePath);
-
-    if (binary == "bsc.exe") {
-      binaryPath = binPaths.bsc_exe;
-    } else if (binary == "rescript-editor-analysis.exe") {
-      binaryPath = binPaths.rescript_editor_analysis_exe;
-    } else if (binary == "rewatch.exe") {
-      binaryPath = binPaths.rewatch_exe;
-    } else if (binary == "rescript.exe") {
-      binaryPath = binPaths.rescript_exe;
-    }
-  } else {
-    binaryPath = path.join(rescriptDir, c.platformDir, binary);
-  }
-
-  if (binaryPath != null && fs.existsSync(binaryPath)) {
-    return normalizePath(binaryPath);
-  } else {
-    return null;
-  }
+    binary,
+    platformPath: config.extensionConfiguration.platformPath ?? null,
+  });
+  return normalizePath(result);
 };
 
 export let findRescriptBinary = (projectRootPath: NormalizedPath | null) =>