feat(test): Make CARGO_BIN_EXE_ available at runtime

This also makes artifact deps available for consistency purposes.

I originally proposed this for when moving Cargo off of Cargo's own
internals but went with a different solution.

Re-visiting this because `assert_cmd` has 2300+ dependents and it seems
like making `assert_cmd::cargo_bin` work would be a better use of time
than migrating all of those users to `assert_cmd::cargo_bin!`.
For example, within the top 130 dependents (100,000 downloads or more),
I found 66 that used `assert_cmd::cargo_bin`
(rust-lang/rust#149852).

> The reason to make `CARGO_BIN_EXE` set only at build-time was to
> address the concern of manually running the test executable.
> It's not
> too common for tests to look at any runtime environment variables
> (that I know of), so it usually just works (like running
> `gdb target/debug/.../test-xxx`).
> The concern was that if it were set at
> runtime it would move more down the path where directly running the test
> executable doesn't "just work".

See https://rust-lang.zulipchat.com/#narrow/channel/246057-t-cargo/topic/cargo_bin_exe.20and.20tests/near/513638220

However,
- This is user opt-in
- Users can run with `-vv` to see the env variables that are set
- Users can run `CARGO_TARGET_..._RUNNER=gdb`
- We can notify the `cargo nextest`, the main third-party test runner,
  about this.  It should be easy to support as they have their own
  version of this, see https://nexte.st/docs/configuration/env-vars/?h=nextest_bin_exe#environment-variables-nextest-sets

Author: epage

src/cargo/core/compiler/build_runner/mod.rs

@@ -316,17 +316,17 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
             if unit.mode == CompileMode::Test {
                 self.compilation
                     .tests
-                    .push(self.unit_output(unit, &output.path));
+                    .push(self.unit_output(unit, &output.path)?);
             } else if unit.target.is_executable() {
                 self.compilation
                     .binaries
-                    .push(self.unit_output(unit, bindst));
+                    .push(self.unit_output(unit, bindst)?);
             } else if unit.target.is_cdylib()
                 && !self.compilation.cdylibs.iter().any(|uo| uo.unit == *unit)
             {
                 self.compilation
                     .cdylibs
-                    .push(self.unit_output(unit, bindst));
+                    .push(self.unit_output(unit, bindst)?);
             }
         }
         Ok(())
@@ -554,13 +554,15 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
 
     /// Returns a [`UnitOutput`] which represents some information about the
     /// output of a unit.
-    pub fn unit_output(&self, unit: &Unit, path: &Path) -> UnitOutput {
+    pub fn unit_output(&self, unit: &Unit, path: &Path) -> CargoResult<UnitOutput> {
         let script_metas = self.find_build_script_metadatas(unit);
-        UnitOutput {
+        let env = artifact::get_env(&self, unit, self.unit_deps(unit))?;
+        Ok(UnitOutput {
             unit: unit.clone(),
             path: path.to_path_buf(),
             script_metas,
-        }
+            env,
+        })
     }
 
     /// Check if any output file name collision happens.

src/cargo/core/compiler/compilation.rs

@@ -62,6 +62,9 @@ pub struct UnitOutput {
     ///
     /// This is used for indexing [`Compilation::extra_env`].
     pub script_metas: Option<Vec<UnitHash>>,
+
+    /// Environment variables to set in the unit's process.
+    pub env: HashMap<String, OsString>,
 }
 
 /// A structure returning the result of a compilation.

src/cargo/ops/cargo_run.rs

@@ -97,6 +97,7 @@ pub fn run(
         unit,
         path,
         script_metas,
+        env: _env,
     } = &compile.binaries[0];
     let exe = match path.strip_prefix(gctx.cwd()) {
         Ok(path) if path.file_name() == Some(path.as_os_str()) => Path::new(".").join(path),

src/cargo/ops/cargo_test.rs

@@ -8,6 +8,7 @@ use crate::util::errors::CargoResult;
 use crate::util::{CliError, CliResult, GlobalContext, add_path_args};
 use anyhow::format_err;
 use cargo_util::{ProcessBuilder, ProcessError};
+use std::collections::HashMap;
 use std::ffi::OsString;
 use std::fmt::Write;
 use std::path::{Path, PathBuf};
@@ -126,6 +127,7 @@ fn run_unit_tests(
         unit,
         path,
         script_metas,
+        env,
     } in compilation.tests.iter()
     {
         let (exe_display, mut cmd) = cmd_builds(
@@ -134,6 +136,7 @@ fn run_unit_tests(
             unit,
             path,
             script_metas.as_ref(),
+            env,
             test_args,
             compilation,
             "unittests",
@@ -287,6 +290,7 @@ fn display_no_run_information(
         unit,
         path,
         script_metas,
+        env,
     } in compilation.tests.iter()
     {
         let (exe_display, cmd) = cmd_builds(
@@ -295,6 +299,7 @@ fn display_no_run_information(
             unit,
             path,
             script_metas.as_ref(),
+            env,
             test_args,
             compilation,
             exec_type,
@@ -319,6 +324,7 @@ fn cmd_builds(
     unit: &Unit,
     path: &PathBuf,
     script_metas: Option<&Vec<UnitHash>>,
+    env: &HashMap<String, OsString>,
     test_args: &[&str],
     compilation: &Compilation<'_>,
     exec_type: &str,
@@ -348,6 +354,9 @@ fn cmd_builds(
     if unit.target.harness() && gctx.shell().verbosity() == Verbosity::Quiet {
         cmd.arg("--quiet");
     }
+    for (key, val) in env.iter() {
+        cmd.env(key, val);
+    }
 
     Ok((exe_display, cmd))
 }

tests/testsuite/test.rs

@@ -5216,9 +5216,9 @@ fn bin_env_for_test() {
                 assert_eq!(env!("CARGO_BIN_EXE_foo"), "<FOO_PATH>");
                 assert_eq!(env!("CARGO_BIN_EXE_with-dash"), "<WITH_DASH_PATH>");
                 assert_eq!(env!("CARGO_BIN_EXE_grüßen"), "<GRÜSSEN_PATH>");
-                assert_eq!(std::env::var("CARGO_BIN_EXE_foo").ok(), None);
-                assert_eq!(std::env::var("CARGO_BIN_EXE_with-dash").ok(), None);
-                assert_eq!(std::env::var("CARGO_BIN_EXE_grüßen").ok(), None);
+                assert_eq!(std::env::var("CARGO_BIN_EXE_foo").ok().as_deref(), Some("<FOO_PATH>"));
+                assert_eq!(std::env::var("CARGO_BIN_EXE_with-dash").ok().as_deref(), Some("<WITH_DASH_PATH>"));
+                assert_eq!(std::env::var("CARGO_BIN_EXE_grüßen").ok().as_deref(), Some("<GRÜSSEN_PATH>"));
             }
         "#
         .replace("<FOO_PATH>", &bin_path("foo"))