Rewatch: simplify getting bsc path

Author: cknitt

cli/rescript.js

@@ -3,40 +3,14 @@
 // @ts-check
 
 import * as child_process from "node:child_process";
-import { bsc_exe, rescript_exe } from "./common/bins.js";
+import { rescript_exe } from "./common/bins.js";
 
 const args = process.argv.slice(2);
 
-const firstPositionalArgIndex = args.findIndex(arg => !arg.startsWith("-"));
-
 try {
-  if (firstPositionalArgIndex !== -1) {
-    const subcommand = args[firstPositionalArgIndex];
-    const subcommandWithArgs = args.slice(firstPositionalArgIndex);
-
-    if (
-      subcommand === "build" ||
-      subcommand === "watch" ||
-      subcommand === "clean"
-    ) {
-      child_process.execFileSync(
-        rescript_exe,
-        [...subcommandWithArgs, "--bsc-path", bsc_exe],
-        {
-          stdio: "inherit",
-        },
-      );
-    } else {
-      child_process.execFileSync(rescript_exe, [...args], {
-        stdio: "inherit",
-      });
-    }
-  } else {
-    // no subcommand means build subcommand
-    child_process.execFileSync(rescript_exe, [...args, "--bsc-path", bsc_exe], {
-      stdio: "inherit",
-    });
-  }
+  child_process.execFileSync(rescript_exe, args, {
+    stdio: "inherit",
+  });
 } catch (err) {
   if (err.status !== undefined) {
     process.exit(err.status); // Pass through the exit code

rewatch/src/build.rs

@@ -56,10 +56,7 @@ pub struct CompilerArgs {
     pub parser_args: Vec<String>,
 }
 
-pub fn get_compiler_args(
-    path: &Path,
-    build_dev_deps: bool,
-) -> Result<String> {
+pub fn get_compiler_args(path: &Path, build_dev_deps: bool) -> Result<String> {
     let filename = &helpers::get_abs_path(path);
     let package_root =
         helpers::get_abs_path(&helpers::get_nearest_config(&path).expect("Couldn't find package root"));
@@ -117,16 +114,12 @@ pub fn initialize_build(
     filter: &Option<regex::Regex>,
     show_progress: bool,
     path: &Path,
-    bsc_path: &Option<PathBuf>,
     build_dev_deps: bool,
     snapshot_output: bool,
 ) -> Result<BuildState> {
     let project_root = helpers::get_abs_path(path);
     let workspace_root = helpers::get_workspace_root(&project_root);
-    let bsc_path = match bsc_path {
-        Some(bsc_path) => helpers::get_abs_path(&bsc_path),
-        None => helpers::get_bsc(&project_root, &workspace_root),
-    };
+    let bsc_path = helpers::get_bsc();
     let root_config_name = packages::read_package_name(&project_root)?;
 
     if !snapshot_output && show_progress {
@@ -171,13 +164,7 @@ pub fn initialize_build(
         let _ = stdout().flush();
     }
 
-    let mut build_state = BuildState::new(
-        project_root,
-        root_config_name,
-        packages,
-        workspace_root,
-        bsc_path,
-    );
+    let mut build_state = BuildState::new(project_root, root_config_name, packages, workspace_root, bsc_path);
     packages::parse_packages(&mut build_state);
     let timing_source_files_elapsed = timing_source_files.elapsed();
 
@@ -487,7 +474,6 @@ pub fn build(
     show_progress: bool,
     no_timing: bool,
     create_sourcedirs: bool,
-    bsc_path: Option<PathBuf>,
     build_dev_deps: bool,
     snapshot_output: bool,
 ) -> Result<BuildState> {
@@ -502,7 +488,6 @@ pub fn build(
         filter,
         show_progress,
         path,
-        &bsc_path,
         build_dev_deps,
         snapshot_output,
     )

rewatch/src/build/clean.rs

@@ -331,12 +331,7 @@ pub fn cleanup_after_build(build_state: &BuildState) {
     });
 }
 
-pub fn clean(
-    path: &Path,
-    show_progress: bool,
-    bsc_path: Option<PathBuf>,
-    snapshot_output: bool,
-) -> Result<()> {
+pub fn clean(path: &Path, show_progress: bool, snapshot_output: bool) -> Result<()> {
     let project_root = helpers::get_abs_path(path);
     let workspace_root = helpers::get_workspace_root(&project_root);
     let packages = packages::make(
@@ -349,11 +344,7 @@ pub fn clean(
         true,
     )?;
     let root_config_name = packages::read_package_name(&project_root)?;
-    let bsc_path = match bsc_path {
-        Some(bsc_path) => helpers::get_abs_path(&bsc_path),
-        None => helpers::get_bsc(&project_root, &workspace_root),
-    };
-
+    let bsc_path = helpers::get_bsc();
 
     let timing_clean_compiler_assets = Instant::now();
     if !snapshot_output && show_progress {

rewatch/src/cli.rs

@@ -77,13 +77,6 @@ pub struct DevArg {
     pub dev: bool,
 }
 
-#[derive(Args, Debug, Clone)]
-pub struct BscPathArg {
-    /// Custom path to bsc
-    #[arg(long)]
-    pub bsc_path: Option<String>,
-}
-
 #[derive(Args, Debug, Clone, Copy)]
 pub struct SnapshotOutputArg {
     /// simple output for snapshot testing
@@ -114,9 +107,6 @@ pub struct BuildArgs {
 
     #[command(flatten)]
     pub snapshot_output: SnapshotOutputArg,
-
-    #[command(flatten)]
-    pub bsc_path: BscPathArg,
 }
 
 #[derive(Args, Clone, Debug)]
@@ -138,9 +128,6 @@ pub struct WatchArgs {
 
     #[command(flatten)]
     pub snapshot_output: SnapshotOutputArg,
-
-    #[command(flatten)]
-    pub bsc_path: BscPathArg,
 }
 
 #[derive(Subcommand, Clone, Debug)]
@@ -154,9 +141,6 @@ pub enum Command {
         #[command(flatten)]
         folder: FolderArg,
 
-        #[command(flatten)]
-        bsc_path: BscPathArg,
-
         #[command(flatten)]
         snapshot_output: SnapshotOutputArg,
     },
@@ -231,14 +215,6 @@ impl Deref for DevArg {
     }
 }
 
-impl Deref for BscPathArg {
-    type Target = Option<String>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.bsc_path
-    }
-}
-
 impl Deref for SnapshotOutputArg {
     type Target = bool;
 

rewatch/src/helpers.rs

@@ -180,43 +180,18 @@ pub fn create_path_for_path(path: &Path) {
     fs::DirBuilder::new().recursive(true).create(path).unwrap();
 }
 
-fn get_bin_dir() -> PathBuf {
-    let subfolder = match (std::env::consts::OS, std::env::consts::ARCH) {
-        ("macos", "aarch64") => "darwin-arm64",
-        ("macos", _) => "darwin-x64",
-        ("linux", "aarch64") => "linux-arm64",
-        ("linux", _) => "linux-x64",
-        ("windows", "aarch64") => "win-arm64",
-        ("windows", _) => "win32-x64",
-        _ => panic!("Unsupported architecture"),
-    };
-
-    Path::new("node_modules")
-        .join("@rescript")
-        .join(subfolder)
-        .join("bin")
+pub fn get_rescript_bin_dir() -> PathBuf {
+    let current_exe_path = std::env::current_exe().expect("Could not get current executable path");
+    current_exe_path
+        .parent()
+        .expect("Could not get parent directory of current executable")
+        .to_path_buf()
 }
 
-pub fn get_bsc(root_path: &Path, workspace_root: &Option<PathBuf>) -> PathBuf {
-    let bin_dir = get_bin_dir();
-
-    match (
-        root_path
-            .join(&bin_dir)
-            .join("bsc.exe")
-            .canonicalize()
-            .map(StrippedVerbatimPath::to_stripped_verbatim_path),
-        workspace_root.as_ref().map(|workspace_root| {
-            workspace_root
-                .join(&bin_dir)
-                .join("bsc.exe")
-                .canonicalize()
-                .map(StrippedVerbatimPath::to_stripped_verbatim_path)
-        }),
-    ) {
-        (Ok(path), _) => path,
-        (_, Some(Ok(path))) => path,
-        _ => panic!("Could not find bsc.exe"),
+pub fn get_bsc() -> PathBuf {
+    match std::env::var("RESCRIPT_BSC_EXE") {
+        Ok(val) => PathBuf::from(val),
+        Err(_) => get_rescript_bin_dir().join("bsc.exe"),
     }
 }
 

rewatch/src/lock.rs

@@ -21,7 +21,10 @@ pub enum Error {
 impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let msg = match self {
-            Error::Locked(pid) => format!("A ReScript build is already running. The process ID (PID) is {}", pid),
+            Error::Locked(pid) => format!(
+                "A ReScript build is already running. The process ID (PID) is {}",
+                pid
+            ),
             Error::ParsingLockfile(e) => format!(
                 "Could not parse lockfile: \n {} \n  (try removing it and running the command again)",
                 e

rewatch/src/main.rs

@@ -2,10 +2,7 @@ use anyhow::Result;
 use clap::Parser;
 use log::LevelFilter;
 use regex::Regex;
-use std::{
-    io::Write,
-    path::{Path, PathBuf},
-};
+use std::{io::Write, path::Path};
 
 use rewatch::{build, cli, cmd, lock, watcher};
 
@@ -27,17 +24,8 @@ fn main() -> Result<()> {
     let show_progress = log_level_filter == LevelFilter::Info;
 
     match command.clone() {
-        cli::Command::CompilerArgs {
-            path,
-            dev,
-        } => {
-            println!(
-                "{}",
-                build::get_compiler_args(
-                    Path::new(&path),
-                    *dev
-                )?
-            );
+        cli::Command::CompilerArgs { path, dev } => {
+            println!("{}", build::get_compiler_args(Path::new(&path), *dev)?);
             std::process::exit(0);
         }
         cli::Command::Build(build_args) => {
@@ -54,7 +42,6 @@ fn main() -> Result<()> {
                 show_progress,
                 build_args.no_timing,
                 *build_args.create_sourcedirs,
-                build_args.bsc_path.as_ref().map(PathBuf::from),
                 *build_args.dev,
                 *build_args.snapshot_output,
             ) {
@@ -84,25 +71,18 @@ fn main() -> Result<()> {
                 (*watch_args.after_build).clone(),
                 *watch_args.create_sourcedirs,
                 *watch_args.dev,
-                (*watch_args.bsc_path).clone(),
                 *watch_args.snapshot_output,
             );
 
             Ok(())
         }
         cli::Command::Clean {
             folder,
-            bsc_path,
             snapshot_output,
         } => {
             let _lock = get_lock(&folder);
 
-            build::clean::clean(
-                Path::new(&folder as &str),
-                show_progress,
-                bsc_path.as_ref().map(PathBuf::from),
-                *snapshot_output,
-            )
+            build::clean::clean(Path::new(&folder as &str), show_progress, *snapshot_output)
         }
         cli::Command::Legacy { legacy_args } => {
             let code = build::pass_through_legacy(legacy_args);

rewatch/src/watcher.rs

@@ -5,13 +5,13 @@ use crate::cmd;
 use crate::helpers;
 use crate::helpers::StrippedVerbatimPath;
 use crate::helpers::emojis::*;
+use crate::lock::LOCKFILE;
 use crate::queue::FifoQueue;
 use crate::queue::*;
 use futures_timer::Delay;
 use notify::event::ModifyKind;
 use notify::{Config, Error, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
-use crate::lock::LOCKFILE;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
@@ -63,19 +63,11 @@ async fn async_watch(
     after_build: Option<String>,
     create_sourcedirs: bool,
     build_dev_deps: bool,
-    bsc_path: Option<PathBuf>,
     snapshot_output: bool,
 ) -> notify::Result<()> {
-    let mut build_state = build::initialize_build(
-        None,
-        filter,
-        show_progress,
-        path,
-        &bsc_path,
-        build_dev_deps,
-        snapshot_output,
-    )
-    .expect("Can't initialize build");
+    let mut build_state =
+        build::initialize_build(None, filter, show_progress, path, build_dev_deps, snapshot_output)
+            .expect("Can't initialize build");
     let mut needs_compile_type = CompileType::Incremental;
     // create a mutex to capture if ctrl-c was pressed
     let ctrlc_pressed = Arc::new(Mutex::new(false));
@@ -259,7 +251,6 @@ async fn async_watch(
                     filter,
                     show_progress,
                     path,
-                    &bsc_path,
                     build_dev_deps,
                     snapshot_output,
                 )
@@ -308,7 +299,6 @@ pub fn start(
     after_build: Option<String>,
     create_sourcedirs: bool,
     build_dev_deps: bool,
-    bsc_path: Option<String>,
     snapshot_output: bool,
 ) {
     futures::executor::block_on(async {
@@ -323,7 +313,6 @@ pub fn start(
             .expect("Could not start watcher");
 
         let path = Path::new(folder);
-        let bsc_path_buf = bsc_path.map(PathBuf::from);
 
         if let Err(e) = async_watch(
             consumer,
@@ -333,7 +322,6 @@ pub fn start(
             after_build,
             create_sourcedirs,
             build_dev_deps,
-            bsc_path_buf,
             snapshot_output,
         )
         .await