cli: propagate ActiveSource from the top

Author: djc

src/cli/proxy_mode.rs

@@ -25,7 +25,6 @@ pub async fn main(arg0: &str, current_dir: PathBuf, process: &Process) -> Result
         .filter(|arg| arg.starts_with('+'))
         .map(|name| ResolvableLocalToolchainName::try_from(&name.as_ref()[1..]))
         .transpose()?;
-    let toolchain_specified = toolchain.is_some();
 
     // Build command args now while we know whether or not to skip arg 1.
     let cmd_args: Vec<_> = process
@@ -34,21 +33,17 @@ pub async fn main(arg0: &str, current_dir: PathBuf, process: &Process) -> Result
         .collect();
 
     let cfg = Cfg::from_env(current_dir, true, process)?;
-    let toolchain = cfg
+    let (toolchain, source) = cfg
         .local_toolchain(match toolchain {
-            Some(name) => Some(name.resolve(&cfg.get_default_host_triple()?)?),
+            Some(name) => Some((
+                name.resolve(&cfg.get_default_host_triple()?)?,
+                ActiveSource::CommandLine,
+            )),
             None => None,
         })
         .await?;
 
     let mut cmd = toolchain.command(arg0)?;
-    if toolchain_specified {
-        cmd.env(
-            "RUSTUP_TOOLCHAIN_SOURCE",
-            ActiveSource::CommandLine.to_string(),
-        );
-    } else if let Ok(Some((_, source))) = cfg.active_toolchain() {
-        cmd.env("RUSTUP_TOOLCHAIN_SOURCE", source.to_string());
-    }
+    cmd.env("RUSTUP_TOOLCHAIN_SOURCE", source.to_string());
     run_command_for_dir(cmd, arg0, &cmd_args)
 }

src/cli/rustup_mode.rs

@@ -1036,9 +1036,12 @@ async fn which(
     binary: &str,
     toolchain: Option<ResolvableToolchainName>,
 ) -> Result<ExitCode> {
-    let toolchain = cfg
+    let (toolchain, _) = cfg
         .local_toolchain(match toolchain {
-            Some(name) => Some(name.resolve(&cfg.get_default_host_triple()?)?.into()),
+            Some(name) => Some((
+                name.resolve(&cfg.get_default_host_triple()?)?.into(),
+                ActiveSource::CommandLine, // From --toolchain option
+            )),
             None => None,
         })
         .await?;
@@ -1251,6 +1254,8 @@ async fn target_list(
     installed_only: bool,
     quiet: bool,
 ) -> Result<ExitCode> {
+    let toolchain = toolchain.map(|desc| (desc, ActiveSource::CommandLine));
+
     // If a toolchain is Distributable, we can assume it has a manifest and thus print all possible targets and the installed ones.
     // However, if it is a custom toolchain, we can only print the installed targets.
     // NB: this decision is made based on the absence of a manifest in custom toolchains.
@@ -1268,7 +1273,7 @@ async fn target_list(
             cfg.process,
         )
     } else {
-        let toolchain = cfg.toolchain_from_partial(toolchain).await?;
+        let toolchain = cfg.toolchain_from_partial(toolchain).await?.0;
         common::list_items(
             toolchain.installed_targets()?.iter().map(|s| (s, true)),
             installed_only,
@@ -1288,9 +1293,13 @@ async fn target_add(
     // isn't a feature yet.
     // list_components *and* add_component would both be inappropriate for
     // custom toolchains.
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
-    let components = distributable.components()?;
+    let distributable = DistributableToolchain::from_partial(
+        toolchain.map(|desc| (desc, ActiveSource::CommandLine)),
+        cfg,
+    )
+    .await?;
 
+    let components = distributable.components()?;
     if targets.contains(&"all".to_string()) {
         if targets.len() != 1 {
             return Err(anyhow!(
@@ -1332,7 +1341,11 @@ async fn target_remove(
     targets: Vec<String>,
     toolchain: Option<PartialToolchainDesc>,
 ) -> Result<ExitCode> {
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
+    let distributable = DistributableToolchain::from_partial(
+        toolchain.map(|desc| (desc, ActiveSource::CommandLine)),
+        cfg,
+    )
+    .await?;
 
     for target in targets {
         let target = TargetTriple::new(target);
@@ -1369,6 +1382,8 @@ async fn component_list(
     installed_only: bool,
     quiet: bool,
 ) -> Result<ExitCode> {
+    let toolchain = toolchain.map(|desc| (desc, ActiveSource::CommandLine));
+
     // downcasting required because the toolchain files can name any toolchain
     if let Ok(distributable) = DistributableToolchain::from_partial(toolchain.clone(), cfg).await {
         common::list_items(
@@ -1381,7 +1396,7 @@ async fn component_list(
             cfg.process,
         )
     } else {
-        let toolchain = cfg.toolchain_from_partial(toolchain).await?;
+        let toolchain = cfg.toolchain_from_partial(toolchain).await?.0;
         common::list_items(
             toolchain
                 .installed_components()?
@@ -1400,9 +1415,13 @@ async fn component_add(
     toolchain: Option<PartialToolchainDesc>,
     target: Option<String>,
 ) -> Result<ExitCode> {
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
-    let target = get_target(target, &distributable);
+    let distributable = DistributableToolchain::from_partial(
+        toolchain.map(|desc| (desc, ActiveSource::CommandLine)),
+        cfg,
+    )
+    .await?;
 
+    let target = get_target(target, &distributable);
     for component in &components {
         let new_component = Component::try_new(component, &distributable, target.as_ref())?;
         distributable.add_component(new_component).await?;
@@ -1426,6 +1445,7 @@ async fn component_remove(
     toolchain: Option<PartialToolchainDesc>,
     target: Option<String>,
 ) -> Result<ExitCode> {
+    let toolchain = toolchain.map(|desc| (desc, ActiveSource::CommandLine));
     let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
     let target = get_target(target, &distributable);
 
@@ -1707,7 +1727,8 @@ async fn doc(
     mut topic: Option<&str>,
     doc_page: &DocPage,
 ) -> Result<ExitCode> {
-    let toolchain = cfg.toolchain_from_partial(toolchain).await?;
+    let toolchain = toolchain.map(|desc| (desc, ActiveSource::CommandLine));
+    let toolchain = cfg.toolchain_from_partial(toolchain).await?.0;
 
     if let Ok(distributable) = DistributableToolchain::try_from(&toolchain)
         && let [_] = distributable
@@ -1772,7 +1793,8 @@ async fn man(
     command: &str,
     toolchain: Option<PartialToolchainDesc>,
 ) -> Result<ExitCode> {
-    let toolchain = cfg.toolchain_from_partial(toolchain).await?;
+    let toolchain = toolchain.map(|desc| (desc, ActiveSource::CommandLine));
+    let toolchain = cfg.toolchain_from_partial(toolchain).await?.0;
     let path = toolchain.man_path();
     utils::assert_is_directory(&path)?;
 

src/config.rs

@@ -88,7 +88,7 @@ impl<T: Into<String>> From<T> for OverrideFile {
 }
 
 // Represents the source that determined the current active toolchain.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub(crate) enum ActiveSource {
     Default,
     Environment,
@@ -477,13 +477,16 @@ impl<'a> Cfg<'a> {
 
     pub(crate) async fn toolchain_from_partial(
         &self,
-        toolchain: Option<PartialToolchainDesc>,
-    ) -> Result<Toolchain<'_>> {
+        toolchain: Option<(PartialToolchainDesc, ActiveSource)>,
+    ) -> Result<(Toolchain<'_>, ActiveSource)> {
         let toolchain = toolchain
-            .map(|desc| {
-                anyhow::Ok(LocalToolchainName::Named(ToolchainName::Official(
-                    desc.resolve(&self.get_default_host_triple()?)?,
-                )))
+            .map(|(desc, source)| {
+                anyhow::Ok((
+                    LocalToolchainName::Named(ToolchainName::Official(
+                        desc.resolve(&self.get_default_host_triple()?)?,
+                    )),
+                    source,
+                ))
             })
             .transpose()?;
         self.local_toolchain(toolchain).await
@@ -700,20 +703,22 @@ impl<'a> Cfg<'a> {
 
     pub(crate) async fn local_toolchain(
         &self,
-        name: Option<LocalToolchainName>,
-    ) -> Result<Toolchain<'_>> {
+        name: Option<(LocalToolchainName, ActiveSource)>,
+    ) -> Result<(Toolchain<'_>, ActiveSource)> {
         match name {
-            Some(tc) => {
+            Some((tc, source)) => {
                 let install_if_missing = self.should_auto_install()?;
-                Toolchain::from_local(tc, install_if_missing, self).await
+                Ok((
+                    Toolchain::from_local(tc, install_if_missing, self).await?,
+                    source,
+                ))
             }
             None => {
-                let tc = self
+                let (tc, source) = self
                     .maybe_ensure_active_toolchain(None)
                     .await?
-                    .ok_or_else(|| no_toolchain_error(self.process))?
-                    .0;
-                Ok(Toolchain::new(self, tc)?)
+                    .ok_or_else(|| no_toolchain_error(self.process))?;
+                Ok((Toolchain::new(self, tc)?, source))
             }
         }
     }

src/toolchain/distributable.rs

@@ -9,7 +9,7 @@ use platforms::Platform;
 
 use crate::{
     RustupError, component_for_bin,
-    config::Cfg,
+    config::{ActiveSource, Cfg},
     dist::{
         DistOptions, PartialToolchainDesc, Profile, ToolchainDesc,
         config::Config,
@@ -35,11 +35,11 @@ pub(crate) struct DistributableToolchain<'a> {
 
 impl<'a> DistributableToolchain<'a> {
     pub(crate) async fn from_partial(
-        toolchain: Option<PartialToolchainDesc>,
+        toolchain: Option<(PartialToolchainDesc, ActiveSource)>,
         cfg: &'a Cfg<'a>,
     ) -> anyhow::Result<Self> {
         Ok(Self::try_from(
-            &cfg.toolchain_from_partial(toolchain).await?,
+            &cfg.toolchain_from_partial(toolchain).await?.0,
         )?)
     }