Implement 11036 cargo changes

smoelius · smoelius · commit a106b1d9e2be · 2026-01-10T07:55:56.000-05:00
diff --git a/src/cargo/ops/cargo_install.rs b/src/cargo/ops/cargo_install.rs
@@ -1,7 +1,7 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
-use std::{env, fs};
+use std::{env, fmt, fs};
 
 use crate::core::compiler::{CompileKind, DefaultExecutor, Executor, UnitOutput};
 use crate::core::{Dependency, Edition, Package, PackageId, SourceId, Target, Workspace};
@@ -14,6 +14,7 @@ use crate::util::errors::CargoResult;
 use crate::util::{Filesystem, GlobalContext, Rustc};
 use crate::{drop_println, ops};
 
+use annotate_snippets::Level;
 use anyhow::{Context as _, bail};
 use cargo_util::paths;
 use cargo_util_schemas::core::PartialVersion;
@@ -39,6 +40,42 @@ impl Drop for Transaction {
     }
 }
 
+enum RustupToolchainSource {
+    Default,
+    Environment,
+    CommandLine,
+    OverrideDB,
+    ToolchainFile,
+    Other(String),
+}
+
+#[allow(dead_code)]
+impl RustupToolchainSource {
+    fn is_default_or_cli_override(&self) -> Option<bool> {
+        match self {
+            Self::Default => Some(true),
+            Self::Environment => Some(false),
+            Self::CommandLine => Some(true),
+            Self::OverrideDB => Some(false),
+            Self::ToolchainFile => Some(false),
+            Self::Other(_) => None,
+        }
+    }
+}
+
+impl fmt::Display for RustupToolchainSource {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Self::Default => "default",
+            Self::Environment => "env",
+            Self::CommandLine => "cli",
+            Self::OverrideDB => "path-override",
+            Self::ToolchainFile => "toolchain-file",
+            Self::Other(other) => other,
+        })
+    }
+}
+
 struct InstallablePackage<'gctx> {
     gctx: &'gctx GlobalContext,
     opts: ops::CompileOptions,
@@ -316,6 +353,27 @@ impl<'gctx> InstallablePackage<'gctx> {
     fn install_one(mut self, dry_run: bool) -> CargoResult<bool> {
         self.gctx.shell().status("Installing", &self.pkg)?;
 
+        if let Some(source) = self.get_rustup_toolchain_source()
+            && source.is_default_or_cli_override() != Some(true)
+        {
+            #[expect(
+                clippy::disallowed_methods,
+                reason = "config should not set `RUSTUP` environment variables"
+            )]
+            let maybe_toolchain = env::var("RUSTUP_TOOLCHAIN")
+                .ok()
+                .map(|toolchain| format!(" `{toolchain}`"))
+                .unwrap_or_default();
+            let report = &[Level::WARNING
+                .secondary_title(format!(
+                    "using non-default toolchain{maybe_toolchain} overridden by {source}"
+                ))
+                .element(Level::HELP.message(format!(
+                    "use `cargo +stable install` if you meant to use the stable toolchain."
+                )))];
+            self.gctx.shell().print_report(report, false)?;
+        }
+
         // Normalize to absolute path for consistency throughout.
         // See: https://github.com/rust-lang/cargo/issues/16023
         let dst = self.root.join("bin").into_path_unlocked();
@@ -593,6 +651,23 @@ impl<'gctx> InstallablePackage<'gctx> {
         }
     }
 
+    fn get_rustup_toolchain_source(&self) -> Option<RustupToolchainSource> {
+        #[expect(
+            clippy::disallowed_methods,
+            reason = "config should not set `RUSTUP` environment variables"
+        )]
+        let source = std::env::var("RUSTUP_TOOLCHAIN_SOURCE").ok()?;
+        let source = match source.as_str() {
+            "default" => RustupToolchainSource::Default,
+            "env" => RustupToolchainSource::Environment,
+            "cli" => RustupToolchainSource::CommandLine,
+            "path-override" => RustupToolchainSource::OverrideDB,
+            "toolchain-file" => RustupToolchainSource::ToolchainFile,
+            other => RustupToolchainSource::Other(other.to_owned()),
+        };
+        Some(source)
+    }
+
     fn check_yanked_install(&self) -> CargoResult<()> {
         if self.ws.ignore_lock() || !self.ws.root().join("Cargo.lock").exists() {
             return Ok(());
diff --git a/tests/testsuite/rustup.rs b/tests/testsuite/rustup.rs
@@ -59,20 +59,27 @@ fn real_rustc_wrapper(bin_dir: &Path, message: &str) -> PathBuf {
     // The toolchain rustc needs to call the real rustc. In order to do that,
     // it needs to restore or clear the RUSTUP environment variables so that
     // if rustup is installed, it will call the correct rustc.
+    let rustup_toolchain_source_setup = match std::env::var_os("RUSTUP_TOOLCHAIN_SOURCE") {
+        Some(t) => format!(
+            ".env(\"RUSTUP_TOOLCHAIN_SOURCE\", \"{}\")",
+            t.into_string().unwrap()
+        ),
+        None => String::new(),
+    };
     let rustup_toolchain_setup = match std::env::var_os("RUSTUP_TOOLCHAIN") {
         Some(t) => format!(
             ".env(\"RUSTUP_TOOLCHAIN\", \"{}\")",
             t.into_string().unwrap()
         ),
-        None => format!(".env_remove(\"RUSTUP_TOOLCHAIN\")"),
+        None => String::new(),
     };
     let mut env = vec![("CARGO_RUSTUP_TEST_real_rustc", real_rustc)];
     let rustup_home_setup = match std::env::var_os("RUSTUP_HOME") {
         Some(h) => {
             env.push(("CARGO_RUSTUP_TEST_RUSTUP_HOME", h.into()));
             format!(".env(\"RUSTUP_HOME\", env!(\"CARGO_RUSTUP_TEST_RUSTUP_HOME\"))")
         }
-        None => format!(".env_remove(\"RUSTUP_HOME\")"),
+        None => String::new(),
     };
     make_exe(
         bin_dir,
@@ -82,6 +89,7 @@ fn real_rustc_wrapper(bin_dir: &Path, message: &str) -> PathBuf {
                 eprintln!("{message}");
                 let r = std::process::Command::new(env!("CARGO_RUSTUP_TEST_real_rustc"))
                     .args(std::env::args_os().skip(1))
+                    {rustup_toolchain_source_setup}
                     {rustup_toolchain_setup}
                     {rustup_home_setup}
                     .status();
@@ -322,58 +330,157 @@ custom toolchain rustc running
 /// rustup environment. The purpose is to verify the warning that is emitted.
 #[cargo_test]
 fn cargo_install_with_toolchain_source_unset() {
-    cargo_install_with_toolchain_source(None, &warning_with_optional_rust_toolchain_source(None));
+    cargo_install_with_toolchain_source(
+        None,
+        str![[r#"
+[..]/cargo[EXE]` proxy running
+[UPDATING] `dummy-registry` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)
+[INSTALLING] foo v0.0.1
+[COMPILING] foo v0.0.1
+[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s
+[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]
+[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)
+[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries
+
+"#]],
+    );
 }
 
 #[cargo_test]
 fn cargo_install_with_toolchain_source_default() {
     cargo_install_with_toolchain_source(
         Some("default"),
-        &warning_with_optional_rust_toolchain_source(None),
+        str![[r#"
+[..]/cargo[EXE]` proxy running
+[UPDATING] `dummy-registry` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)
+[INSTALLING] foo v0.0.1
+[COMPILING] foo v0.0.1
+[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s
+[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]
+[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)
+[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries
+
+"#]],
     );
 }
 
 #[cargo_test]
 fn cargo_install_with_toolchain_source_cli() {
     cargo_install_with_toolchain_source(
         Some("cli"),
-        &warning_with_optional_rust_toolchain_source(None),
+        str![[r#"
+[..]/cargo[EXE]` proxy running
+[UPDATING] `dummy-registry` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)
+[INSTALLING] foo v0.0.1
+[COMPILING] foo v0.0.1
+[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s
+[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]
+[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)
+[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries
+
+"#]],
     );
 }
 
 #[cargo_test]
 fn cargo_install_with_toolchain_source_env() {
     cargo_install_with_toolchain_source(
         Some("env"),
-        &warning_with_optional_rust_toolchain_source(None),
+        str![[r#"
+[..]/cargo[EXE]` proxy running
+[UPDATING] `dummy-registry` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)
+[INSTALLING] foo v0.0.1
+[WARNING] using non-default toolchain `test-toolchain` overridden by env
+  |
+  = [HELP] use `cargo +stable install` if you meant to use the stable toolchain.
+[COMPILING] foo v0.0.1
+[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s
+[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]
+[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)
+[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries
+
+"#]],
     );
 }
 
 #[cargo_test]
 fn cargo_install_with_toolchain_source_path_override() {
     cargo_install_with_toolchain_source(
         Some("path-override"),
-        &warning_with_optional_rust_toolchain_source(None),
+        str![[r#"
+[..]/cargo[EXE]` proxy running
+[UPDATING] `dummy-registry` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)
+[INSTALLING] foo v0.0.1
+[WARNING] using non-default toolchain `test-toolchain` overridden by path-override
+  |
+  = [HELP] use `cargo +stable install` if you meant to use the stable toolchain.
+[COMPILING] foo v0.0.1
+[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s
+[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]
+[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)
+[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries
+
+"#]],
     );
 }
 
 #[cargo_test]
 fn cargo_install_with_toolchain_source_toolchain_file() {
     cargo_install_with_toolchain_source(
         Some("toolchain-file"),
-        &warning_with_optional_rust_toolchain_source(None),
+        str![[r#"
+[..]/cargo[EXE]` proxy running
+[UPDATING] `dummy-registry` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)
+[INSTALLING] foo v0.0.1
+[WARNING] using non-default toolchain `test-toolchain` overridden by toolchain-file
+  |
+  = [HELP] use `cargo +stable install` if you meant to use the stable toolchain.
+[COMPILING] foo v0.0.1
+[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s
+[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]
+[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)
+[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries
+
+"#]],
     );
 }
 
 #[cargo_test]
 fn cargo_install_with_toolchain_source_unrecognized() {
     cargo_install_with_toolchain_source(
         Some("unrecognized"),
-        &warning_with_optional_rust_toolchain_source(None),
+        str![[r#"
+[..]/cargo[EXE]` proxy running
+[UPDATING] `dummy-registry` index
+[DOWNLOADING] crates ...
+[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)
+[INSTALLING] foo v0.0.1
+[WARNING] using non-default toolchain `test-toolchain` overridden by unrecognized
+  |
+  = [HELP] use `cargo +stable install` if you meant to use the stable toolchain.
+[COMPILING] foo v0.0.1
+[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s
+[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]
+[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)
+[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries
+
+"#]],
     );
 }
 
-fn cargo_install_with_toolchain_source(source: Option<&str>, stderr: &str) {
+fn cargo_install_with_toolchain_source(source: Option<&str>, stderr: impl snapbox::IntoData) {
     let mut builder = RustupEnvironmentBuilder::new();
     builder.call_cargo_under_test();
     builder.env("RUSTUP_TOOLCHAIN", "test-toolchain");
@@ -398,30 +505,3 @@ fn cargo_install_with_toolchain_source(source: Option<&str>, stderr: &str) {
         .run();
     assert_has_installed_exe(cargo_home(), "foo");
 }
-
-fn warning_with_optional_rust_toolchain_source(source: Option<&str>) -> String {
-    let maybe_warning = if let Some(source) = source {
-        format!(
-            r#"[WARNING] using non-default toolchain `test-toolchain` overridden by {}
-  |
-  = [HELP] use `cargo +stable install` if you meant to use the stable toolchain.
-"#,
-            source
-        )
-    } else {
-        String::new()
-    };
-    format!(
-        r#"`[..]/cargo[EXE]` proxy running
-[UPDATING] `dummy-registry` index
-[DOWNLOADING] crates ...
-[DOWNLOADED] foo v0.0.1 (registry `dummy-registry`)
-[INSTALLING] foo v0.0.1
-{maybe_warning}[COMPILING] foo v0.0.1
-[FINISHED] `release` profile [optimized] target(s) in [ELAPSED]s
-[INSTALLING] [ROOT]/home/.cargo/bin/foo[EXE]
-[INSTALLED] package `foo v0.0.1` (executable `foo[EXE]`)
-[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries
-"#
-    )
-}
