feat(cargo-codspeed): handle rustflags from .cargo/config.toml

Author: GuillaumeLagrange

Cargo.lock

@@ -20,3 +20,4 @@ itertools = "0.14.0"
 serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0.138"
 tempfile = "3.7.0"
+semver = "1.0"

Cargo.toml

@@ -26,6 +26,7 @@ itertools = { workspace = true }
 anstyle = "1.0.8"
 serde = { workspace = true }
 serde_json = { workspace = true }
+semver = { workspace = true }
 codspeed = { path = "../codspeed", version = "=3.0.2" }
 
 [dev-dependencies]

crates/cargo-codspeed/Cargo.toml

@@ -5,6 +5,7 @@ use crate::{
     prelude::*,
 };
 use cargo_metadata::{camino::Utf8PathBuf, Message, Metadata, TargetKind};
+use semver::Version;
 use std::process::{exit, Command, Stdio};
 
 struct BuildOptions<'a> {
@@ -105,15 +106,23 @@ impl BuildOptions<'_> {
         Ok(built_benches)
     }
 
-    /// Generates a subcommand to build the benchmarks by invoking cargo and forwarding the filters
-    /// This command explicitly ignores the `self.benches`: all benches are built
-    fn build_command(&self, measurement_mode: MeasurementMode) -> Command {
-        let mut cargo = Command::new("cargo");
-        cargo.args(["build", "--benches"]);
+    /// Adds debug flags and codspeed compilation
+    ///
+    /// If the user has set `RUSTFLAGS`, it will append the flags to it.
+    /// Else, and if the cargo version allows it, it will set the cargo config through
+    /// `--config 'build.rustflags=[ ... ]'`
+    ///
+    /// # Why we do this
+    /// As tracked in [https://github.com/rust-lang/cargo/issues/5376], setting `RUSTFLAGS`
+    /// completely overrides rustflags from rust config
+    /// We use the cargo built-in config mechanism to set the flags if the user has not set
+    /// `RUSTFLAGS`.
+    fn add_rust_flags(&self, cargo: &mut Command, measurement_mode: MeasurementMode) {
+        let mut flags = Vec::new();
 
-        let mut rust_flags = std::env::var("RUSTFLAGS").unwrap_or_else(|_| "".into());
         // Add debug info (equivalent to -g)
-        rust_flags.push_str(" -C debuginfo=2");
+        flags.push("-C".to_string());
+        flags.push("debuginfo=2".to_string());
 
         // Prevent debug info stripping
         // https://doc.rust-lang.org/cargo/reference/profiles.html#release
@@ -122,13 +131,70 @@ impl BuildOptions<'_> {
         // In practice, if we set debug info through RUSTFLAGS, cargo still strips them, most
         // likely because debug = false in the release profile.
         // We also need to disable stripping through rust flags.
-        rust_flags.push_str(" -C strip=none");
+        flags.push("-C".to_string());
+        flags.push("strip=none".to_string());
 
         // Add the codspeed cfg flag if instrumentation mode is enabled
         if measurement_mode == MeasurementMode::Instrumentation {
-            rust_flags.push_str(" --cfg codspeed");
+            flags.push("--cfg".to_string());
+            flags.push("codspeed".to_string());
+        }
+
+        match std::env::var("RUSTFLAGS") {
+            std::result::Result::Ok(existing_rustflags) => {
+                // If RUSTFLAGS is set, append our flags to it
+                let mut combined_flags = existing_rustflags;
+                for flag in flags {
+                    combined_flags.push(' ');
+                    combined_flags.push_str(&flag);
+                }
+                cargo.env("RUSTFLAGS", combined_flags);
+            }
+            std::result::Result::Err(_) => {
+                // Check if cargo version supports --config (Cargo 1.63+, 2022-08-11)
+                if Self::cargo_supports_config_from_cli() {
+                    // Use --config to set rustflags
+                    let config_value = format!(
+                        "build.rustflags=[{}]",
+                        flags.into_iter().map(|f| format!("\"{f}\"")).join(",")
+                    );
+                    cargo.arg("--config").arg(config_value);
+                } else {
+                    // Fallback to RUSTFLAGS for older cargo versions
+                    let rustflags = flags.join(" ");
+                    cargo.env("RUSTFLAGS", rustflags);
+                }
+            }
+        }
+    }
+
+    /// Check if cargo version supports --config flag (Cargo 1.63+)
+    /// [https://doc.rust-lang.org/nightly/cargo/CHANGELOG.html#cargo-163-2022-08-11]
+    fn cargo_supports_config_from_cli() -> bool {
+        let output = Command::new("cargo").arg("--version").output();
+
+        if let std::result::Result::Ok(output) = output {
+            if let std::result::Result::Ok(version_str) = String::from_utf8(output.stdout) {
+                // Parse version string like "cargo 1.70.0 (7fe40dc9c 2023-04-27)"
+                if let Some(version_part) = version_str.split_whitespace().nth(1) {
+                    if let std::result::Result::Ok(version) = Version::parse(version_part) {
+                        // Cargo 1.63.0 introduced --config support
+                        return version >= Version::new(1, 63, 0);
+                    }
+                }
+            }
         }
-        cargo.env("RUSTFLAGS", rust_flags);
+
+        false
+    }
+
+    /// Generates a subcommand to build the benchmarks by invoking cargo and forwarding the filters
+    /// This command explicitly ignores the `self.benches`: all benches are built
+    fn build_command(&self, measurement_mode: MeasurementMode) -> Command {
+        let mut cargo = Command::new("cargo");
+        cargo.args(["build", "--benches"]);
+
+        self.add_rust_flags(&mut cargo, measurement_mode);
 
         if let Some(features) = self.features {
             cargo.arg("--features").arg(features.join(","));