Refactor and reduce usage of RelPath

Author: bjorn3

build_system/abi_cafe.rs

@@ -1,4 +1,4 @@
-use crate::path::{Dirs, RelPath};
+use crate::path::Dirs;
 use crate::prepare::GitRepo;
 use crate::utils::{spawn_and_wait, CargoProject, Compiler};
 use crate::{build_sysroot, CodegenBackend, SysrootKind};
@@ -20,7 +20,7 @@ pub(crate) fn run(
     rustup_toolchain_name: Option<&str>,
     bootstrap_host_compiler: &Compiler,
 ) {
-    RelPath::DOWNLOAD.ensure_exists(dirs);
+    std::fs::create_dir_all(&dirs.download_dir).unwrap();
     ABI_CAFE_REPO.fetch(dirs);
     ABI_CAFE_REPO.patch(dirs);
 

build_system/bench.rs

@@ -3,7 +3,7 @@ use std::io::Write;
 use std::path::Path;
 use std::process::Command;
 
-use crate::path::{Dirs, RelPath};
+use crate::path::Dirs;
 use crate::prepare::GitRepo;
 use crate::rustc_info::get_file_name;
 use crate::utils::{spawn_and_wait, Compiler};
@@ -39,11 +39,11 @@ fn benchmark_simple_raytracer(dirs: &Dirs, bootstrap_host_compiler: &Compiler) {
     };
 
     eprintln!("[BENCH COMPILE] ebobby/simple-raytracer");
-    let cargo_clif = RelPath::DIST
-        .to_path(dirs)
+    let cargo_clif = dirs
+        .dist_dir
         .join(get_file_name(&bootstrap_host_compiler.rustc, "cargo_clif", "bin").replace('_', "-"));
     let manifest_path = SIMPLE_RAYTRACER_REPO.source_dir().to_path(dirs).join("Cargo.toml");
-    let target_dir = RelPath::BUILD.join("simple_raytracer").to_path(dirs);
+    let target_dir = dirs.build_dir.join("simple_raytracer");
 
     let clean_cmd = format!(
         "RUSTC=rustc cargo clean --manifest-path {manifest_path} --target-dir {target_dir}",
@@ -68,7 +68,7 @@ fn benchmark_simple_raytracer(dirs: &Dirs, bootstrap_host_compiler: &Compiler) {
         target_dir = target_dir.display(),
     );
 
-    let bench_compile_markdown = RelPath::DIST.to_path(dirs).join("bench_compile.md");
+    let bench_compile_markdown = dirs.dist_dir.join("bench_compile.md");
 
     let bench_compile = hyperfine_command(
         1,
@@ -92,7 +92,7 @@ fn benchmark_simple_raytracer(dirs: &Dirs, bootstrap_host_compiler: &Compiler) {
 
     eprintln!("[BENCH RUN] ebobby/simple-raytracer");
 
-    let bench_run_markdown = RelPath::DIST.to_path(dirs).join("bench_run.md");
+    let bench_run_markdown = dirs.dist_dir.join("bench_run.md");
 
     let raytracer_cg_llvm = Path::new(".").join(get_file_name(
         &bootstrap_host_compiler.rustc,
@@ -120,7 +120,7 @@ fn benchmark_simple_raytracer(dirs: &Dirs, bootstrap_host_compiler: &Compiler) {
         ],
         &bench_run_markdown,
     );
-    bench_run.current_dir(RelPath::BUILD.to_path(dirs));
+    bench_run.current_dir(&dirs.build_dir);
     spawn_and_wait(bench_run);
 
     if let Some(gha_step_summary) = gha_step_summary.as_mut() {

build_system/build_backend.rs

@@ -6,7 +6,7 @@ use crate::rustc_info::get_file_name;
 use crate::shared_utils::{rustflags_from_env, rustflags_to_cmd_env};
 use crate::utils::{CargoProject, Compiler, LogGroup};
 
-static CG_CLIF: CargoProject = CargoProject::new(&RelPath::SOURCE, "cg_clif");
+static CG_CLIF: CargoProject = CargoProject::new(&RelPath::source("."), "cg_clif");
 
 pub(crate) fn build_backend(
     dirs: &Dirs,

build_system/build_sysroot.rs

@@ -10,9 +10,9 @@ use crate::utils::{
 };
 use crate::{config, CodegenBackend, SysrootKind};
 
-static DIST_DIR: RelPath = RelPath::DIST;
-static BIN_DIR: RelPath = RelPath::DIST.join("bin");
-static LIB_DIR: RelPath = RelPath::DIST.join("lib");
+static DIST_DIR: RelPath = RelPath::dist(".");
+static BIN_DIR: RelPath = RelPath::dist("bin");
+static LIB_DIR: RelPath = RelPath::dist("lib");
 
 pub(crate) fn build_sysroot(
     dirs: &Dirs,
@@ -26,9 +26,10 @@ pub(crate) fn build_sysroot(
 
     eprintln!("[BUILD] sysroot {:?}", sysroot_kind);
 
-    DIST_DIR.ensure_fresh(dirs);
-    BIN_DIR.ensure_exists(dirs);
-    LIB_DIR.ensure_exists(dirs);
+    remove_dir_if_exists(&dirs.dist_dir);
+    fs::create_dir_all(&dirs.dist_dir).unwrap();
+    fs::create_dir_all(BIN_DIR.to_path(dirs)).unwrap();
+    fs::create_dir_all(LIB_DIR.to_path(dirs)).unwrap();
 
     let is_native = bootstrap_host_compiler.triple == target_triple;
 
@@ -58,7 +59,7 @@ pub(crate) fn build_sysroot(
         let mut build_cargo_wrapper_cmd = Command::new(&bootstrap_host_compiler.rustc);
         let wrapper_path = DIST_DIR.to_path(dirs).join(&wrapper_name);
         build_cargo_wrapper_cmd
-            .arg(RelPath::SCRIPTS.to_path(dirs).join(&format!("{wrapper}.rs")))
+            .arg(dirs.source_dir.join("scripts").join(&format!("{wrapper}.rs")))
             .arg("-o")
             .arg(&wrapper_path)
             .arg("-Cstrip=debuginfo");
@@ -116,10 +117,8 @@ pub(crate) fn build_sysroot(
 
     let mut target_compiler = {
         let dirs: &Dirs = &dirs;
-        let rustc_clif =
-            RelPath::DIST.to_path(&dirs).join(wrapper_base_name.replace("____", "rustc-clif"));
-        let rustdoc_clif =
-            RelPath::DIST.to_path(&dirs).join(wrapper_base_name.replace("____", "rustdoc-clif"));
+        let rustc_clif = dirs.dist_dir.join(wrapper_base_name.replace("____", "rustc-clif"));
+        let rustdoc_clif = dirs.dist_dir.join(wrapper_base_name.replace("____", "rustdoc-clif"));
 
         Compiler {
             cargo: bootstrap_host_compiler.cargo.clone(),
@@ -158,10 +157,10 @@ impl SysrootTarget {
     }
 }
 
-static STDLIB_SRC: RelPath = RelPath::BUILD.join("stdlib");
+static STDLIB_SRC: RelPath = RelPath::build("stdlib");
 static STANDARD_LIBRARY: CargoProject =
-    CargoProject::new(&STDLIB_SRC.join("library/sysroot"), "stdlib_target");
-static RTSTARTUP_SYSROOT: RelPath = RelPath::BUILD.join("rtstartup");
+    CargoProject::new(&RelPath::build("stdlib/library/sysroot"), "stdlib_target");
+static RTSTARTUP_SYSROOT: RelPath = RelPath::build("rtstartup");
 
 fn build_sysroot_for_triple(
     dirs: &Dirs,

build_system/main.rs

@@ -185,12 +185,11 @@ fn main() {
         frozen,
     };
 
-    path::RelPath::BUILD.ensure_exists(&dirs);
+    std::fs::create_dir_all(&dirs.build_dir).unwrap();
 
     {
         // Make sure we always explicitly specify the target dir
-        let target =
-            path::RelPath::BUILD.join("target_dir_should_be_set_explicitly").to_path(&dirs);
+        let target = dirs.build_dir.join("target_dir_should_be_set_explicitly");
         env::set_var("CARGO_TARGET_DIR", &target);
         let _ = std::fs::remove_file(&target);
         std::fs::File::create(target).unwrap();

build_system/path.rs

@@ -33,33 +33,30 @@ impl PathBase {
 }
 
 #[derive(Debug, Copy, Clone)]
-pub(crate) enum RelPath {
-    Base(PathBase),
-    Join(&'static RelPath, &'static str),
+pub(crate) struct RelPath {
+    base: PathBase,
+    suffix: &'static str,
 }
 
 impl RelPath {
-    pub(crate) const SOURCE: RelPath = RelPath::Base(PathBase::Source);
-    pub(crate) const DOWNLOAD: RelPath = RelPath::Base(PathBase::Download);
-    pub(crate) const BUILD: RelPath = RelPath::Base(PathBase::Build);
-    pub(crate) const DIST: RelPath = RelPath::Base(PathBase::Dist);
+    pub(crate) const fn source(suffix: &'static str) -> RelPath {
+        RelPath { base: PathBase::Source, suffix }
+    }
 
-    pub(crate) const SCRIPTS: RelPath = RelPath::SOURCE.join("scripts");
-    pub(crate) const PATCHES: RelPath = RelPath::SOURCE.join("patches");
+    pub(crate) const fn download(suffix: &'static str) -> RelPath {
+        RelPath { base: PathBase::Download, suffix }
+    }
 
-    pub(crate) const fn join(&'static self, suffix: &'static str) -> RelPath {
-        RelPath::Join(self, suffix)
+    pub(crate) const fn build(suffix: &'static str) -> RelPath {
+        RelPath { base: PathBase::Build, suffix }
     }
 
-    pub(crate) fn to_path(&self, dirs: &Dirs) -> PathBuf {
-        match self {
-            RelPath::Base(base) => base.to_path(dirs),
-            RelPath::Join(base, suffix) => base.to_path(dirs).join(suffix),
-        }
+    pub(crate) const fn dist(suffix: &'static str) -> RelPath {
+        RelPath { base: PathBase::Dist, suffix }
     }
 
-    pub(crate) fn ensure_exists(&self, dirs: &Dirs) {
-        fs::create_dir_all(self.to_path(dirs)).unwrap();
+    pub(crate) fn to_path(&self, dirs: &Dirs) -> PathBuf {
+        self.base.to_path(dirs).join(self.suffix)
     }
 
     pub(crate) fn ensure_fresh(&self, dirs: &Dirs) {

build_system/prepare.rs

@@ -8,7 +8,7 @@ use crate::path::{Dirs, RelPath};
 use crate::utils::{copy_dir_recursively, remove_dir_if_exists, spawn_and_wait};
 
 pub(crate) fn prepare(dirs: &Dirs) {
-    RelPath::DOWNLOAD.ensure_exists(dirs);
+    std::fs::create_dir_all(&dirs.download_dir).unwrap();
     crate::tests::RAND_REPO.fetch(dirs);
     crate::tests::REGEX_REPO.fetch(dirs);
 }
@@ -79,13 +79,13 @@ impl GitRepo {
 
     fn download_dir(&self, dirs: &Dirs) -> PathBuf {
         match self.url {
-            GitRepoUrl::Github { user: _, repo } => RelPath::DOWNLOAD.join(repo).to_path(dirs),
+            GitRepoUrl::Github { user: _, repo } => RelPath::download(repo).to_path(dirs),
         }
     }
 
     pub(crate) const fn source_dir(&self) -> RelPath {
         match self.url {
-            GitRepoUrl::Github { user: _, repo } => RelPath::BUILD.join(repo),
+            GitRepoUrl::Github { user: _, repo } => RelPath::build(repo),
         }
     }
 
@@ -117,7 +117,7 @@ impl GitRepo {
         }
 
         let source_lockfile =
-            RelPath::PATCHES.to_path(dirs).join(format!("{}-lock.toml", self.patch_name));
+            dirs.source_dir.join("patches").join(format!("{}-lock.toml", self.patch_name));
         let target_lockfile = download_dir.join("Cargo.lock");
         if source_lockfile.exists() {
             assert!(!target_lockfile.exists());
@@ -178,7 +178,7 @@ fn init_git_repo(repo_dir: &Path) {
 }
 
 fn get_patches(dirs: &Dirs, crate_name: &str) -> Vec<PathBuf> {
-    let mut patches: Vec<_> = fs::read_dir(RelPath::PATCHES.to_path(dirs))
+    let mut patches: Vec<_> = fs::read_dir(dirs.source_dir.join("patches"))
         .unwrap()
         .map(|entry| entry.unwrap().path())
         .filter(|path| path.extension() == Some(OsStr::new("patch")))

build_system/tests.rs

@@ -10,7 +10,7 @@ use crate::shared_utils::rustflags_from_env;
 use crate::utils::{spawn_and_wait, CargoProject, Compiler, LogGroup};
 use crate::{build_sysroot, config, CodegenBackend, SysrootKind};
 
-static BUILD_EXAMPLE_OUT_DIR: RelPath = RelPath::BUILD.join("example");
+static BUILD_EXAMPLE_OUT_DIR: RelPath = RelPath::build("example");
 
 struct TestCase {
     config: &'static str,
@@ -129,11 +129,11 @@ pub(crate) static REGEX_REPO: GitRepo = GitRepo::github(
 
 static REGEX: CargoProject = CargoProject::new(&REGEX_REPO.source_dir(), "regex_target");
 
-static PORTABLE_SIMD_SRC: RelPath = RelPath::BUILD.join("portable-simd");
+static PORTABLE_SIMD_SRC: RelPath = RelPath::build("portable-simd");
 
 static PORTABLE_SIMD: CargoProject = CargoProject::new(&PORTABLE_SIMD_SRC, "portable-simd_target");
 
-static LIBCORE_TESTS_SRC: RelPath = RelPath::BUILD.join("coretests");
+static LIBCORE_TESTS_SRC: RelPath = RelPath::build("coretests");
 
 static LIBCORE_TESTS: CargoProject = CargoProject::new(&LIBCORE_TESTS_SRC, "coretests_target");
 
@@ -162,7 +162,7 @@ const EXTENDED_SYSROOT_SUITE: &[TestCase] = &[
             &LIBCORE_TESTS_SRC.to_path(&runner.dirs),
         );
 
-        let source_lockfile = RelPath::PATCHES.to_path(&runner.dirs).join("coretests-lock.toml");
+        let source_lockfile = runner.dirs.source_dir.join("patches/coretests-lock.toml");
         let target_lockfile = LIBCORE_TESTS_SRC.to_path(&runner.dirs).join("Cargo.lock");
         fs::copy(source_lockfile, target_lockfile).unwrap();
 

build_system/utils.rs

@@ -80,7 +80,7 @@ impl CargoProject {
     }
 
     pub(crate) fn target_dir(&self, dirs: &Dirs) -> PathBuf {
-        RelPath::BUILD.join(self.target).to_path(dirs)
+        dirs.build_dir.join(self.target)
     }
 
     #[must_use]