Implement cargo changes for 11036

smoelius · smoelius · commit 21578477d388 · 2025-10-18T05:28:46.000-04: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};
@@ -39,6 +39,41 @@ impl Drop for Transaction {
     }
 }
 
+enum RustupToolchainSource {
+    Default,
+    Environment,
+    CommandLine,
+    OverrideDB,
+    ToolchainFile,
+}
+
+impl RustupToolchainSource {
+    fn get() -> Option<Self> {
+        env::var("RUSTUP_TOOLCHAIN_SOURCE")
+            .ok()
+            .and_then(|val| match val.as_str() {
+                "default" => Some(Self::Default),
+                "env" => Some(Self::Environment),
+                "cli" => Some(Self::CommandLine),
+                "path-override" => Some(Self::OverrideDB),
+                "toolchain-file" => Some(Self::ToolchainFile),
+                _ => 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",
+        })
+    }
+}
+
 struct InstallablePackage<'gctx> {
     gctx: &'gctx GlobalContext,
     opts: ops::CompileOptions,
@@ -316,6 +351,23 @@ 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) = RustupToolchainSource::get()
+            && !matches!(
+                source,
+                RustupToolchainSource::Default | RustupToolchainSource::CommandLine
+            )
+        {
+            let maybe_toolchain = env::var("RUSTUP_TOOLCHAIN")
+                .ok()
+                .map(|toolchain| format!(" `{toolchain}`"))
+                .unwrap_or_default();
+            self.gctx.shell().warn(format!(
+                "\
+using non-default toolchain{maybe_toolchain} overridden by {source}
+Use `cargo +stable install` if you meant to use the stable toolchain."
+            ))?;
+        }
+
         let dst = self.root.join("bin").into_path_unlocked();
 
         let mut td_opt = None;
diff --git a/tests/testsuite/rustup.rs b/tests/testsuite/rustup.rs
@@ -8,8 +8,9 @@ use std::path::{Path, PathBuf};
 
 use crate::prelude::*;
 use crate::utils::cargo_process;
-use cargo_test_support::paths::{home, root};
-use cargo_test_support::{process, project, str};
+use cargo_test_support::install::assert_has_installed_exe;
+use cargo_test_support::paths::{cargo_home, home, root};
+use cargo_test_support::{execs, process, project, str};
 
 /// Helper to generate an executable.
 fn make_exe(dest: &Path, name: &str, contents: &str, env: &[(&str, PathBuf)]) -> PathBuf {
@@ -99,7 +100,13 @@ fn real_rustc_wrapper(bin_dir: &Path, message: &str) -> PathBuf {
 /// Creates a simulation of a rustup environment with `~/.cargo/bin` and
 /// `~/.rustup` directories populated with some executables that simulate
 /// rustup.
-fn simulated_rustup_environment() -> RustupEnvironment {
+///
+/// Arguments
+///
+/// - `proxy_calls_cargo`: if true, the cargo proxy calls the cargo under test;
+///    otherwise, the cargo proxy calls an executable that panics immediately
+/// - `env_setup`: environment variable setup the proxy should perform
+fn simulated_rustup_environment(proxy_calls_cargo: bool, env_setup: &str) -> RustupEnvironment {
     // Set up ~/.rustup/toolchains/test-toolchain/bin with a custom rustc and cargo.
     let rustup_home = home().join(".rustup");
     let toolchain_bin = rustup_home
@@ -108,42 +115,58 @@ fn simulated_rustup_environment() -> RustupEnvironment {
         .join("bin");
     toolchain_bin.mkdir_p();
     let rustc_toolchain_exe = real_rustc_wrapper(&toolchain_bin, "real rustc running");
-    let cargo_toolchain_exe = make_exe(
-        &toolchain_bin,
-        "cargo",
-        r#"panic!("cargo toolchain should not be called");"#,
-        &[],
-    );
+    let cargo_toolchain_exe = if proxy_calls_cargo {
+        crate::utils::cargo_exe()
+    } else {
+        make_exe(
+            &toolchain_bin,
+            "cargo",
+            r#"panic!("cargo toolchain should not be called");"#,
+            &[],
+        )
+    };
 
     // Set up ~/.cargo/bin with a typical set of rustup proxies.
     let cargo_bin = home().join(".cargo").join("bin");
     cargo_bin.mkdir_p();
 
-    let rustc_proxy = make_exe(
+    let proxy = make_exe(
         &cargo_bin,
         "rustc",
         &format!(
             r#"
-                match std::env::args().next().unwrap().as_ref() {{
-                    "rustc" => {{}}
-                    arg => panic!("proxy only supports rustc, got {{arg:?}}"),
-                }}
-                eprintln!("rustc proxy running");
-                let r = std::process::Command::new(env!("CARGO_RUSTUP_TEST_rustc_toolchain_exe"))
+                let file_stem = std::path::PathBuf::from(std::env::args().next().unwrap())
+                    .file_stem()
+                    .map(ToOwned::to_owned)
+                    .unwrap();
+                let program = match file_stem.to_str().unwrap() {{
+                    "cargo" => env!("CARGO_RUSTUP_TEST_cargo_toolchain_exe"),
+                    "rustc" => env!("CARGO_RUSTUP_TEST_rustc_toolchain_exe"),
+                    arg => panic!("proxy only supports cargo and rustc, got {{arg:?}}"),
+                }};
+                eprintln!("`{{program}}` proxy running");
+                let r = std::process::Command::new(program)
                     .args(std::env::args_os().skip(1))
+                    {env_setup}
                     .status();
                 std::process::exit(r.unwrap().code().unwrap_or(2));
             "#
         ),
-        &[("CARGO_RUSTUP_TEST_rustc_toolchain_exe", rustc_toolchain_exe)],
+        &[
+            ("CARGO_RUSTUP_TEST_rustc_toolchain_exe", rustc_toolchain_exe),
+            (
+                "CARGO_RUSTUP_TEST_cargo_toolchain_exe",
+                cargo_toolchain_exe.clone(),
+            ),
+        ],
     );
     fs::hard_link(
-        &rustc_proxy,
+        &proxy,
         cargo_bin.join("cargo").with_extension(EXE_EXTENSION),
     )
     .unwrap();
     fs::hard_link(
-        &rustc_proxy,
+        &proxy,
         cargo_bin.join("rustup").with_extension(EXE_EXTENSION),
     )
     .unwrap();
@@ -162,7 +185,7 @@ fn typical_rustup() {
         cargo_bin,
         rustup_home,
         cargo_toolchain_exe,
-    } = simulated_rustup_environment();
+    } = simulated_rustup_environment(false, "");
 
     // Set up a project and run a normal cargo build.
     let p = project().file("src/lib.rs", "").build();
@@ -212,7 +235,7 @@ fn custom_calls_other_cargo() {
         cargo_bin,
         rustup_home,
         cargo_toolchain_exe: _,
-    } = simulated_rustup_environment();
+    } = simulated_rustup_environment(false, "");
 
     // Create a directory with a custom toolchain (outside of the rustup universe).
     let custom_bin = root().join("custom-bin");
@@ -271,3 +294,42 @@ custom toolchain rustc running
 "#]])
         .run();
 }
+
+/// Performs a `cargo install` with a non-default toolchain in a simulated
+/// rustup environment. The purpose is to verify the warning that is emitted.
+#[cargo_test]
+fn cargo_install_with_non_default_toolchain() {
+    let RustupEnvironment {
+        cargo_bin,
+        rustup_home: _,
+        cargo_toolchain_exe: _,
+    } = simulated_rustup_environment(
+        true,
+        ".env(\"RUSTUP_TOOLCHAIN_SOURCE\", \"env\")
+         .env(\"RUSTUP_TOOLCHAIN\", \"test-toolchain\")",
+    );
+
+    crate::utils::pkg("foo", "0.0.1");
+
+    let mut p = process(cargo_bin.join("cargo"));
+    p.arg_line("install foo");
+    execs()
+        .with_process_builder(p)
+        .with_stderr_data(str![[r#"
+`[..]/cargo` 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
+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
+[INSTALLED] package `foo v0.0.1` (executable `foo`)
+[WARNING] be sure to add `[ROOT]/home/.cargo/bin` to your PATH to be able to run the installed binaries
+
+"#]])
+        .run();
+    assert_has_installed_exe(cargo_home(), "foo");
+}
