Warn when installing with a non-default toolchain (#16131)

This PR implements the cargo changes for #11036. The rustup changes were
implemented in rust-lang/rustup#4518.

The PR is currently organized as four commits:

- The first expands the rustup tests to set `RUSTUP_TOOLCHAIN_SOURCE`.
This change is not strictly necessary, but it improves the rustup tests'
fidelity.
- The second moves the `pkg` function to a location where the next
commit can use it.
- The third implements a test to check the fourth commit's fix.
- The fourth warns when `cargo install` is invoked with a non-default
toolchain, as indicated by `RUSTUP_TOOLCHAIN_SOURCE`.

In the third commit, two significant changes were made to
`simulated_rustup_environment`:

- Previously, the constructed proxy would call an always-panicking
executable whenever it was asked to run cargo. Now, the proxy can be
made to run the cargo under test.
- The proxy can now be made to set additional environment variables
(e.g., `RUSTUP_TOOLCHAIN_SOURCE`) before calling the proxied tool.

The PR is currently marked as draft because
rust-lang/rustup#4518 has not yet been released.
Technically, this PR could be merged before then. But testing it with a
fixed rustup would seem to make sense.

Nits are welcome.

cc: @epage

Author: epage

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,12 +14,14 @@ 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;
 use itertools::Itertools;
 use semver::VersionReq;
 use tempfile::Builder as TempFileBuilder;
+use tracing::debug;
 
 struct Transaction {
     bins: Vec<PathBuf>,
@@ -39,6 +41,42 @@ impl Drop for Transaction {
     }
 }
 
+enum RustupToolchainSource {
+    Default,
+    Environment,
+    CommandLine,
+    OverrideDB,
+    ToolchainFile,
+    Other(String),
+}
+
+#[allow(dead_code)]
+impl RustupToolchainSource {
+    fn is_implicit_override(&self) -> Option<bool> {
+        match self {
+            Self::Default => Some(false),
+            Self::Environment => Some(true),
+            Self::CommandLine => Some(false),
+            Self::OverrideDB => Some(true),
+            Self::ToolchainFile => Some(true),
+            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 => "environment variable",
+            Self::CommandLine => "command line",
+            Self::OverrideDB => "rustup directory override",
+            Self::ToolchainFile => "rustup toolchain file",
+            Self::Other(other) => other,
+        })
+    }
+}
+
 struct InstallablePackage<'gctx> {
     gctx: &'gctx GlobalContext,
     opts: ops::CompileOptions,
@@ -309,6 +347,31 @@ 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) = get_rustup_toolchain_source()
+            && source.is_implicit_override().unwrap_or_else(|| {
+                debug!("ignoring unrecognized rustup toolchain source `{source}`");
+                false
+            })
+        {
+            #[expect(clippy::disallowed_methods, reason = "consistency with rustup")]
+            let maybe_toolchain = env::var("RUSTUP_TOOLCHAIN")
+                .ok()
+                .map(|toolchain| format!(" with `{toolchain}`"))
+                .unwrap_or_default();
+            let report = &[Level::WARNING
+                .secondary_title(format!(
+                    "default toolchain implicitly overridden{maybe_toolchain} by {source}"
+                ))
+                .element(Level::HELP.message(format!(
+                    "use `cargo +stable install` if you meant to use the stable toolchain"
+                )))
+                .element(Level::NOTE.message(format!(
+                    "rustup selects the toolchain based on the parent environment and not the \
+                     environment of the package being installed"
+                )))];
+            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();
@@ -604,6 +667,20 @@ impl<'gctx> InstallablePackage<'gctx> {
     }
 }
 
+fn get_rustup_toolchain_source() -> Option<RustupToolchainSource> {
+    #[expect(clippy::disallowed_methods, reason = "consistency with rustup")]
+    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 make_warning_about_missing_features(binaries: &[&Target]) -> String {
     let max_targets_listed = 7;
     let target_features_message = binaries