Allow to specify the channel for the rustc command

Author: GuillaumeGomez

Readme.md

@@ -146,7 +146,13 @@ If you compiled cg_gccjit in debug mode (aka you didn't pass `--release` to `./y
 If you want to run `rustc` directly, you can do so with:
 
 ```bash
-$ ./y.sh rustc my_crate.rs
+$ ./y.sh rustc --release -- my_crate.rs
+```
+
+All arguments after `--` are sent the underlying `rustc` binary. If you want to compile in "debug" mode, remove the `--release` argument:
+
+```bash
+$ ./y.sh rustc -- my_crate.rs
 ```
 
 You can do the same manually (although we don't recommend it):

build_system/src/build.rs

@@ -227,7 +227,7 @@ fn build_codegen(args: &mut BuildArg) -> Result<(), String> {
     }
     run_command_with_output_and_env(&command, None, Some(&env))?;
 
-    args.config_info.setup(&mut env, false)?;
+    args.config_info.setup(&mut env, false, true)?;
 
     // We voluntarily ignore the error.
     let _ = fs::remove_dir_all("target/out");

build_system/src/config.rs

@@ -314,6 +314,7 @@ impl ConfigInfo {
         &mut self,
         env: &mut HashMap<String, String>,
         use_system_gcc: bool,
+        generate_out_dir: bool,
     ) -> Result<(), String> {
         env.insert("CARGO_INCREMENTAL".to_string(), "0".to_string());
 
@@ -444,12 +445,12 @@ impl ConfigInfo {
 
         self.rustc_command = vec![rustc];
         self.rustc_command.extend_from_slice(&rustflags);
-        self.rustc_command.extend_from_slice(&[
-            "-L".to_string(),
-            format!("crate={}", self.cargo_target_dir),
-            "--out-dir".to_string(),
-            self.cargo_target_dir.clone(),
-        ]);
+        self.rustc_command
+            .extend_from_slice(&["-L".to_string(), format!("crate={}", self.cargo_target_dir)]);
+        if generate_out_dir {
+            self.rustc_command
+                .extend_from_slice(&["--out-dir".to_string(), self.cargo_target_dir.clone()]);
+        }
 
         if !env.contains_key("RUSTC_LOG") {
             env.insert("RUSTC_LOG".to_string(), "warn".to_string());

build_system/src/rust_tools.rs

@@ -7,19 +7,34 @@ use std::path::PathBuf;
 use crate::config::ConfigInfo;
 use crate::utils::{get_toolchain, rustc_toolchain_version_info, rustc_version_info};
 
-fn args(command: &str) -> Result<Option<Vec<String>>, String> {
+fn args(
+    command: &str,
+    expect_dash_dash: bool,
+) -> Result<Option<(ConfigInfo, Vec<String>)>, String> {
     // We skip the binary and the "cargo"/"rustc" option.
     if let Some("--help") = std::env::args().nth(2).as_deref() {
         usage(command);
         return Ok(None);
     }
-    let args = std::env::args().skip(2).collect::<Vec<_>>();
+    let mut config = ConfigInfo::default();
+    let mut args = std::env::args().skip(2);
+    if expect_dash_dash {
+        while let Some(arg) = args.next() {
+            if arg == "--" {
+                break;
+            }
+            if let Ok(false) = config.parse_argument(&arg, &mut args) {
+                return Err(format!("Unknown config option {arg:?}"));
+            }
+        }
+    }
+    let args = args.collect::<Vec<_>>();
     if args.is_empty() {
         return Err(format!(
-            "Expected at least one argument for `{command}` subcommand, found none"
+            "Expected at least one argument for `{command}` subcommand (after `--`), found none"
         ));
     }
-    Ok(Some(args))
+    Ok(Some((config, args)))
 }
 
 fn usage(command: &str) {
@@ -41,8 +56,8 @@ struct RustcTools {
 }
 
 impl RustcTools {
-    fn new(command: &str) -> Result<Option<Self>, String> {
-        let Some(args) = args(command)? else { return Ok(None) };
+    fn new(command: &str, expect_dash_dash: bool) -> Result<Option<Self>, String> {
+        let Some((mut config, args)) = args(command, expect_dash_dash)? else { return Ok(None) };
 
         // We first need to go to the original location to ensure that the config setup will go as
         // expected.
@@ -71,8 +86,7 @@ impl RustcTools {
         })?;
 
         let mut env: HashMap<String, String> = std::env::vars().collect();
-        let mut config = ConfigInfo::default();
-        config.setup(&mut env, false)?;
+        config.setup(&mut env, false, false)?;
         let toolchain = get_toolchain()?;
 
         let toolchain_version = rustc_toolchain_version_info(&toolchain)?;
@@ -115,7 +129,7 @@ fn exec(input: &[&dyn AsRef<OsStr>], env: &HashMap<String, String>) -> Result<()
 }
 
 pub fn run_cargo() -> Result<(), String> {
-    let Some(mut tools) = RustcTools::new("cargo")? else { return Ok(()) };
+    let Some(mut tools) = RustcTools::new("cargo", false)? else { return Ok(()) };
     let rustflags = tools.env.get("RUSTFLAGS").cloned().unwrap_or_default();
     tools.env.insert("RUSTDOCFLAGS".to_string(), rustflags);
     let mut command: Vec<&dyn AsRef<OsStr>> = vec![&"cargo", &tools.toolchain];
@@ -126,7 +140,7 @@ pub fn run_cargo() -> Result<(), String> {
 }
 
 pub fn run_rustc() -> Result<(), String> {
-    let Some(tools) = RustcTools::new("rustc")? else { return Ok(()) };
+    let Some(tools) = RustcTools::new("rustc", true)? else { return Ok(()) };
     let mut command = tools.config.rustc_command_vec();
     for arg in &tools.args {
         command.push(arg);

build_system/src/test.rs

@@ -1358,7 +1358,7 @@ pub fn run() -> Result<(), String> {
         return Ok(());
     }
 
-    args.config_info.setup(&mut env, args.use_system_gcc)?;
+    args.config_info.setup(&mut env, args.use_system_gcc, true)?;
 
     if args.runners.is_empty() {
         run_all(&env, &args)?;