Introduce Dirs type to avoid hard coding src and dest locations

Author: bjorn3

build_system/abi_cafe.rs

@@ -2,6 +2,7 @@ use std::path::Path;
 
 use super::build_sysroot;
 use super::config;
+use super::path::Dirs;
 use super::prepare::GitRepo;
 use super::utils::{spawn_and_wait, CargoProject, Compiler};
 use super::SysrootKind;
@@ -14,6 +15,7 @@ static ABI_CAFE: CargoProject = CargoProject::new(&ABI_CAFE_REPO.source_dir(), "
 pub(crate) fn run(
     channel: &str,
     sysroot_kind: SysrootKind,
+    dirs: &Dirs,
     cg_clif_dylib: &Path,
     host_triple: &str,
     target_triple: &str,
@@ -29,19 +31,26 @@ pub(crate) fn run(
     }
 
     eprintln!("Building sysroot for abi-cafe");
-    build_sysroot::build_sysroot(channel, sysroot_kind, cg_clif_dylib, host_triple, target_triple);
+    build_sysroot::build_sysroot(
+        dirs,
+        channel,
+        sysroot_kind,
+        cg_clif_dylib,
+        host_triple,
+        target_triple,
+    );
 
     eprintln!("Running abi-cafe");
 
     let pairs = ["rustc_calls_cgclif", "cgclif_calls_rustc", "cgclif_calls_cc", "cc_calls_cgclif"];
 
-    let mut cmd = ABI_CAFE.run(&Compiler::host());
+    let mut cmd = ABI_CAFE.run(&Compiler::host(), dirs);
     cmd.arg("--");
     cmd.arg("--pairs");
     cmd.args(pairs);
     cmd.arg("--add-rustc-codegen-backend");
     cmd.arg(format!("cgclif:{}", cg_clif_dylib.display()));
-    cmd.current_dir(ABI_CAFE.source_dir());
+    cmd.current_dir(ABI_CAFE.source_dir(dirs));
 
     spawn_and_wait(cmd);
 }

build_system/build_backend.rs

@@ -1,18 +1,19 @@
 use std::env;
 use std::path::PathBuf;
 
-use super::path::RelPath;
+use super::path::{Dirs, RelPath};
 use super::rustc_info::get_file_name;
 use super::utils::{is_ci, CargoProject, Compiler};
 
 static CG_CLIF: CargoProject = CargoProject::new(&RelPath::SOURCE, "cg_clif");
 
 pub(crate) fn build_backend(
+    dirs: &Dirs,
     channel: &str,
     host_triple: &str,
     use_unstable_features: bool,
 ) -> PathBuf {
-    let mut cmd = CG_CLIF.build(&Compiler::host());
+    let mut cmd = CG_CLIF.build(&Compiler::host(), dirs);
 
     cmd.env("CARGO_BUILD_INCREMENTAL", "true"); // Force incr comp even in release mode
 
@@ -44,7 +45,7 @@ pub(crate) fn build_backend(
     super::utils::spawn_and_wait(cmd);
 
     CG_CLIF
-        .target_dir()
+        .target_dir(dirs)
         .join(host_triple)
         .join(channel)
         .join(get_file_name("rustc_codegen_cranelift", "dylib"))

build_system/build_sysroot.rs

@@ -2,7 +2,7 @@ use std::fs;
 use std::path::Path;
 use std::process::{self, Command};
 
-use super::path::RelPath;
+use super::path::{Dirs, RelPath};
 use super::rustc_info::{get_file_name, get_rustc_version, get_wrapper_file_name};
 use super::utils::{spawn_and_wait, try_hard_link, CargoProject, Compiler};
 use super::SysrootKind;
@@ -13,6 +13,7 @@ static LIB_DIR: RelPath = RelPath::DIST.join("lib");
 static RUSTLIB_DIR: RelPath = LIB_DIR.join("rustlib");
 
 pub(crate) fn build_sysroot(
+    dirs: &Dirs,
     channel: &str,
     sysroot_kind: SysrootKind,
     cg_clif_dylib_src: &Path,
@@ -21,9 +22,9 @@ pub(crate) fn build_sysroot(
 ) {
     eprintln!("[BUILD] sysroot {:?}", sysroot_kind);
 
-    DIST_DIR.ensure_fresh();
-    BIN_DIR.ensure_exists();
-    LIB_DIR.ensure_exists();
+    DIST_DIR.ensure_fresh(dirs);
+    BIN_DIR.ensure_exists(dirs);
+    LIB_DIR.ensure_exists(dirs);
 
     // Copy the backend
     let cg_clif_dylib_path = if cfg!(windows) {
@@ -33,7 +34,7 @@ pub(crate) fn build_sysroot(
     } else {
         LIB_DIR
     }
-    .to_path()
+    .to_path(dirs)
     .join(get_file_name("rustc_codegen_cranelift", "dylib"));
     try_hard_link(cg_clif_dylib_src, &cg_clif_dylib_path);
 
@@ -43,17 +44,17 @@ pub(crate) fn build_sysroot(
 
         let mut build_cargo_wrapper_cmd = Command::new("rustc");
         build_cargo_wrapper_cmd
-            .arg(RelPath::SCRIPTS.to_path().join(&format!("{wrapper}.rs")))
+            .arg(RelPath::SCRIPTS.to_path(dirs).join(&format!("{wrapper}.rs")))
             .arg("-o")
-            .arg(DIST_DIR.to_path().join(wrapper_name))
+            .arg(DIST_DIR.to_path(dirs).join(wrapper_name))
             .arg("-g");
         spawn_and_wait(build_cargo_wrapper_cmd);
     }
 
     let default_sysroot = super::rustc_info::get_default_sysroot();
 
-    let host_rustlib_lib = RUSTLIB_DIR.to_path().join(host_triple).join("lib");
-    let target_rustlib_lib = RUSTLIB_DIR.to_path().join(target_triple).join("lib");
+    let host_rustlib_lib = RUSTLIB_DIR.to_path(dirs).join(host_triple).join("lib");
+    let target_rustlib_lib = RUSTLIB_DIR.to_path(dirs).join(target_triple).join("lib");
     fs::create_dir_all(&host_rustlib_lib).unwrap();
     fs::create_dir_all(&target_rustlib_lib).unwrap();
 
@@ -114,7 +115,7 @@ pub(crate) fn build_sysroot(
             }
         }
         SysrootKind::Clif => {
-            build_clif_sysroot_for_triple(channel, host_triple, &cg_clif_dylib_path, None);
+            build_clif_sysroot_for_triple(dirs, channel, host_triple, &cg_clif_dylib_path, None);
 
             if host_triple != target_triple {
                 // When cross-compiling it is often necessary to manually pick the right linker
@@ -123,7 +124,13 @@ pub(crate) fn build_sysroot(
                 } else {
                     None
                 };
-                build_clif_sysroot_for_triple(channel, target_triple, &cg_clif_dylib_path, linker);
+                build_clif_sysroot_for_triple(
+                    dirs,
+                    channel,
+                    target_triple,
+                    &cg_clif_dylib_path,
+                    linker,
+                );
             }
 
             // Copy std for the host to the lib dir. This is necessary for the jit mode to find
@@ -132,7 +139,7 @@ pub(crate) fn build_sysroot(
                 let file = file.unwrap().path();
                 let filename = file.file_name().unwrap().to_str().unwrap();
                 if filename.contains("std-") && !filename.contains(".rlib") {
-                    try_hard_link(&file, LIB_DIR.to_path().join(file.file_name().unwrap()));
+                    try_hard_link(&file, LIB_DIR.to_path(dirs).join(file.file_name().unwrap()));
                 }
             }
         }
@@ -145,12 +152,13 @@ pub(crate) static SYSROOT_SRC: RelPath = RelPath::BUILD_SYSROOT.join("sysroot_sr
 static STANDARD_LIBRARY: CargoProject = CargoProject::new(&RelPath::BUILD_SYSROOT, "build_sysroot");
 
 fn build_clif_sysroot_for_triple(
+    dirs: &Dirs,
     channel: &str,
     triple: &str,
     cg_clif_dylib_path: &Path,
     linker: Option<&str>,
 ) {
-    match fs::read_to_string(SYSROOT_RUSTC_VERSION.to_path()) {
+    match fs::read_to_string(SYSROOT_RUSTC_VERSION.to_path(dirs)) {
         Err(e) => {
             eprintln!("Failed to get rustc version for patched sysroot source: {}", e);
             eprintln!("Hint: Try `./y.rs prepare` to patch the sysroot source");
@@ -168,7 +176,7 @@ fn build_clif_sysroot_for_triple(
         }
     }
 
-    let build_dir = STANDARD_LIBRARY.target_dir().join(triple).join(channel);
+    let build_dir = STANDARD_LIBRARY.target_dir(dirs).join(triple).join(channel);
 
     if !super::config::get_bool("keep_sysroot") {
         // Cleanup the deps dir, but keep build scripts and the incremental cache for faster
@@ -181,7 +189,7 @@ fn build_clif_sysroot_for_triple(
     // Build sysroot
     let mut rustflags = "-Zforce-unstable-if-unmarked -Cpanic=abort".to_string();
     rustflags.push_str(&format!(" -Zcodegen-backend={}", cg_clif_dylib_path.to_str().unwrap()));
-    rustflags.push_str(&format!(" --sysroot={}", DIST_DIR.to_path().to_str().unwrap()));
+    rustflags.push_str(&format!(" --sysroot={}", DIST_DIR.to_path(dirs).to_str().unwrap()));
     if channel == "release" {
         rustflags.push_str(" -Zmir-opt-level=3");
     }
@@ -191,7 +199,7 @@ fn build_clif_sysroot_for_triple(
     }
     let mut compiler = Compiler::with_triple(triple.to_owned());
     compiler.rustflags = rustflags;
-    let mut build_cmd = STANDARD_LIBRARY.build(&compiler);
+    let mut build_cmd = STANDARD_LIBRARY.build(&compiler, dirs);
     if channel == "release" {
         build_cmd.arg("--release");
     }
@@ -210,7 +218,7 @@ fn build_clif_sysroot_for_triple(
         };
         try_hard_link(
             entry.path(),
-            RUSTLIB_DIR.to_path().join(triple).join("lib").join(entry.file_name()),
+            RUSTLIB_DIR.to_path(dirs).join(triple).join("lib").join(entry.file_name()),
         );
     }
 }

build_system/mod.rs

@@ -1,5 +1,4 @@
 use std::env;
-use std::path::PathBuf;
 use std::process;
 
 use self::utils::is_ci;
@@ -17,12 +16,8 @@ mod utils;
 fn usage() {
     eprintln!("Usage:");
     eprintln!("  ./y.rs prepare");
-    eprintln!(
-        "  ./y.rs build [--debug] [--sysroot none|clif|llvm] [--dist-dir DIR] [--no-unstable-features]"
-    );
-    eprintln!(
-        "  ./y.rs test [--debug] [--sysroot none|clif|llvm] [--dist-dir DIR] [--no-unstable-features]"
-    );
+    eprintln!("  ./y.rs build [--debug] [--sysroot none|clif|llvm] [--no-unstable-features]");
+    eprintln!("  ./y.rs test [--debug] [--sysroot none|clif|llvm] [--no-unstable-features]");
 }
 
 macro_rules! arg_error {
@@ -50,13 +45,22 @@ pub fn main() {
     env::set_var("CG_CLIF_DISPLAY_CG_TIME", "1");
     env::set_var("CG_CLIF_DISABLE_INCR_CACHE", "1");
 
-    std::fs::create_dir_all("build").unwrap();
+    let current_dir = std::env::current_dir().unwrap();
+    let dirs = path::Dirs {
+        source_dir: current_dir.clone(),
+        download_dir: current_dir.join("download"),
+        build_dir: current_dir.join("build"),
+        dist_dir: current_dir.join("dist"),
+    };
+
+    path::RelPath::BUILD.ensure_exists(&dirs);
 
     {
         // Make sure we always explicitly specify the target dir
-        let target = "build/target_dir_should_be_set_explicitly";
-        env::set_var("CARGO_TARGET_DIR", target);
-        let _ = std::fs::remove_file(target);
+        let target =
+            path::RelPath::BUILD.join("target_dir_should_be_set_explicitly").to_path(&dirs);
+        env::set_var("CARGO_TARGET_DIR", &target);
+        let _ = std::fs::remove_file(&target);
         std::fs::File::create(target).unwrap();
     }
 
@@ -71,7 +75,7 @@ pub fn main() {
             if args.next().is_some() {
                 arg_error!("./y.rs prepare doesn't expect arguments");
             }
-            prepare::prepare();
+            prepare::prepare(&dirs);
             process::exit(0);
         }
         Some("build") => Command::Build,
@@ -84,17 +88,11 @@ pub fn main() {
         }
     };
 
-    let mut dist_dir = PathBuf::from("dist");
     let mut channel = "release";
     let mut sysroot_kind = SysrootKind::Clif;
     let mut use_unstable_features = true;
     while let Some(arg) = args.next().as_deref() {
         match arg {
-            "--dist-dir" => {
-                dist_dir = PathBuf::from(args.next().unwrap_or_else(|| {
-                    arg_error!("--dist-dir requires argument");
-                }))
-            }
             "--debug" => channel = "debug",
             "--sysroot" => {
                 sysroot_kind = match args.next().as_deref() {
@@ -110,7 +108,6 @@ pub fn main() {
             arg => arg_error!("Unexpected argument {}", arg),
         }
     }
-    dist_dir = std::env::current_dir().unwrap().join(dist_dir);
 
     let host_triple = if let Ok(host_triple) = std::env::var("HOST_TRIPLE") {
         host_triple
@@ -131,15 +128,31 @@ pub fn main() {
         host_triple.clone()
     };
 
-    let cg_clif_dylib = build_backend::build_backend(channel, &host_triple, use_unstable_features);
+    let cg_clif_dylib =
+        build_backend::build_backend(&dirs, channel, &host_triple, use_unstable_features);
     match command {
         Command::Test => {
-            tests::run_tests(channel, sysroot_kind, &cg_clif_dylib, &host_triple, &target_triple);
+            tests::run_tests(
+                &dirs,
+                channel,
+                sysroot_kind,
+                &cg_clif_dylib,
+                &host_triple,
+                &target_triple,
+            );
 
-            abi_cafe::run(channel, sysroot_kind, &cg_clif_dylib, &host_triple, &target_triple);
+            abi_cafe::run(
+                channel,
+                sysroot_kind,
+                &dirs,
+                &cg_clif_dylib,
+                &host_triple,
+                &target_triple,
+            );
         }
         Command::Build => {
             build_sysroot::build_sysroot(
+                &dirs,
                 channel,
                 sysroot_kind,
                 &cg_clif_dylib,