Extract bsc arg collection for different systems. Apply RESCRIPT_RUNTIME to rewatch

Author: nojaf

server/src/bsc-args/bsb.ts

@@ -0,0 +1,59 @@
+import * as path from "path";
+import fs from "fs";
+import { IncrementallyCompiledFileInfo } from "../incrementalCompilation";
+import { buildNinjaPartialPath } from "../constants";
+
+export type BsbCompilerArgs = string[];
+
+export async function getBsbBscArgs(
+  entry: IncrementallyCompiledFileInfo,
+): Promise<BsbCompilerArgs | null> {
+  const buildNinjaPath = path.resolve(
+    entry.project.rootPath,
+    buildNinjaPartialPath,
+  );
+
+  let stat: fs.Stats;
+  try {
+    stat = await fs.promises.stat(buildNinjaPath);
+  } catch {
+    return null;
+  }
+
+  const cache = entry.buildNinja;
+  if (cache && cache.fileMtime >= stat.mtimeMs) {
+    return cache.rawExtracted;
+  }
+
+  const fh = await fs.promises.open(buildNinjaPath, "r");
+  try {
+    let captureNext = false;
+    let haveAst = false;
+    const captured: string[] = [];
+
+    for await (const rawLine of fh.readLines()) {
+      const line = String(rawLine).trim();
+      if (captureNext) {
+        captured.push(line);
+        captureNext = false;
+        if (haveAst && captured.length === 2) break; // got ast + mij
+      }
+      if (line.startsWith("rule astj")) {
+        captureNext = true;
+        haveAst = true;
+      } else if (line.startsWith("rule mij")) {
+        captureNext = true;
+      }
+    }
+
+    if (captured.length !== 2) return null;
+
+    entry.buildNinja = {
+      fileMtime: stat.mtimeMs,
+      rawExtracted: captured,
+    };
+    return captured;
+  } finally {
+    await fh.close();
+  }
+}

server/src/bsc-args/rewatch.ts

@@ -0,0 +1,133 @@
+import * as path from "path";
+import * as utils from "../utils";
+import * as cp from "node:child_process";
+import semver from "semver";
+import {
+  debug,
+  IncrementallyCompiledFileInfo,
+} from "../incrementalCompilation";
+import type { projectFiles } from "../projectFiles";
+import { findRuntime } from "../find-runtime";
+
+export type RewatchCompilerArgs = {
+  compiler_args: Array<string>;
+  parser_args: Array<string>;
+};
+
+export async function getRewatchBscArgs(
+  projectsFiles: Map<string, projectFiles>,
+  entry: IncrementallyCompiledFileInfo,
+): Promise<RewatchCompilerArgs | null> {
+  const rewatchCacheEntry = entry.buildRewatch;
+
+  if (
+    rewatchCacheEntry != null &&
+    rewatchCacheEntry.lastFile === entry.file.sourceFilePath
+  ) {
+    return Promise.resolve(rewatchCacheEntry.compilerArgs);
+  }
+
+  try {
+    const project = projectsFiles.get(entry.project.rootPath);
+    if (project?.rescriptVersion == null) return null;
+    let rewatchPath = path.resolve(
+      entry.project.workspaceRootPath,
+      "node_modules/@rolandpeelen/rewatch/rewatch",
+    );
+    let rescriptRewatchPath = null;
+    if (
+      semver.valid(project.rescriptVersion) &&
+      semver.satisfies(project.rescriptVersion as string, ">11", {
+        includePrerelease: true,
+      })
+    ) {
+      rescriptRewatchPath = await utils.findRewatchBinary(
+        entry.project.workspaceRootPath,
+      );
+    }
+
+    if (
+      semver.valid(project.rescriptVersion) &&
+      semver.satisfies(project.rescriptVersion as string, ">=12.0.0-beta.1", {
+        includePrerelease: true,
+      })
+    ) {
+      rescriptRewatchPath = await utils.findRescriptExeBinary(
+        entry.project.workspaceRootPath,
+      );
+    }
+
+    if (rescriptRewatchPath != null) {
+      rewatchPath = rescriptRewatchPath;
+      if (debug()) {
+        console.log(
+          `Found rewatch binary bundled with v12: ${rescriptRewatchPath}`,
+        );
+      }
+    } else {
+      if (debug()) {
+        console.log("Did not find rewatch binary bundled with v12");
+      }
+    }
+
+    const rewatchArguments = semver.satisfies(
+      project.rescriptVersion,
+      ">=12.0.0-beta.2",
+      { includePrerelease: true },
+    )
+      ? ["compiler-args", entry.file.sourceFilePath]
+      : [
+          "--rescript-version",
+          project.rescriptVersion,
+          "--compiler-args",
+          entry.file.sourceFilePath,
+        ];
+    const bscExe = await utils.findBscExeBinary(
+      entry.project.workspaceRootPath,
+    );
+    const env = {};
+    if (bscExe != null) {
+      (env as any)["RESCRIPT_BSC_EXE"] = bscExe;
+    }
+
+    // TODO: We should check a potential configured value
+    // Users should be able to provide this themselves if they like.
+    const rescriptRuntimes = await findRuntime(entry.project.workspaceRootPath);
+
+    if (debug()) {
+      if (rescriptRuntimes.length === 0) {
+        console.log(
+          `Did not find @rescript/runtime directory for ${entry.project.workspaceRootPath}`,
+        );
+      } else if (rescriptRuntimes.length > 1) {
+        console.warn(
+          `Found multiple @rescript/runtime directories, using the first one as RESCRIPT_RUNTIME: ${rescriptRuntimes.join(", ")}`,
+        );
+      } else {
+        console.log(
+          `Found @rescript/runtime directory: ${rescriptRuntimes.join(", ")}`,
+        );
+      }
+    }
+
+    if (rescriptRuntimes.length > 0) {
+      (env as any)["RESCRIPT_RUNTIME"] = rescriptRuntimes[0];
+    } else {
+      // TODO: if no runtime was found, we should let the user know
+    }
+
+    const compilerArgs = JSON.parse(
+      cp.execFileSync(rewatchPath, rewatchArguments, { env }).toString().trim(),
+    ) as RewatchCompilerArgs;
+
+    entry.buildRewatch = {
+      lastFile: entry.file.sourceFilePath,
+      compilerArgs: compilerArgs,
+    };
+
+    return compilerArgs;
+  } catch (e) {
+    console.error(e);
+    return null;
+  }
+}