ActiveReason -> ActiveSource

smoelius · smoelius · commit 6610d1043b18 · 2025-10-10T18:34:06.000-04:00
diff --git a/src/cli/common.rs b/src/cli/common.rs
@@ -331,7 +331,7 @@ pub(crate) async fn list_toolchains(
     } else {
         let default_toolchain_name = cfg.get_default()?;
         let active_toolchain_name: Option<ToolchainName> =
-            if let Ok(Some((LocalToolchainName::Named(toolchain), _reason))) =
+            if let Ok(Some((LocalToolchainName::Named(toolchain), _source))) =
                 cfg.maybe_ensure_active_toolchain(None).await
             {
                 Some(toolchain)
diff --git a/src/cli/proxy_mode.rs b/src/cli/proxy_mode.rs
@@ -8,7 +8,7 @@ use anyhow::Result;
 use crate::{
     cli::{common::set_globals, job, self_update},
     command::run_command_for_dir,
-    config::ActiveReason,
+    config::ActiveSource,
     process::Process,
     toolchain::ResolvableLocalToolchainName,
 };
@@ -42,9 +42,9 @@ pub async fn main(arg0: &str, current_dir: PathBuf, process: &Process) -> Result
     set_env_source(
         &mut cmd,
         if toolchain_specified {
-            Some(ActiveReason::CommandLine)
-        } else if let Ok(Some((_, reason))) = cfg.active_toolchain() {
-            Some(reason)
+            Some(ActiveSource::CommandLine)
+        } else if let Ok(Some((_, source))) = cfg.active_toolchain() {
+            Some(source)
         } else {
             None
         },
@@ -54,8 +54,8 @@ pub async fn main(arg0: &str, current_dir: PathBuf, process: &Process) -> Result
 
 /// Set the `RUSTUP_TOOLCHAIN_SOURCE` environment variable to indicate how the toolchain was
 /// determined.
-fn set_env_source(cmd: &mut Command, reason: Option<ActiveReason>) {
-    if let Some(reason) = reason {
-        cmd.env("RUSTUP_TOOLCHAIN_SOURCE", reason.to_source());
+fn set_env_source(cmd: &mut Command, source: Option<ActiveSource>) {
+    if let Some(source) = source {
+        cmd.env("RUSTUP_TOOLCHAIN_SOURCE", source.to_string());
     }
 }
diff --git a/src/cli/rustup_mode.rs b/src/cli/rustup_mode.rs
@@ -30,7 +30,7 @@ use crate::{
         topical_doc,
     },
     command, component_for_bin,
-    config::{ActiveReason, Cfg},
+    config::{ActiveSource, Cfg},
     dist::{
         AutoInstallMode, PartialToolchainDesc, Profile, TargetTriple,
         manifest::{Component, ComponentStatus},
@@ -781,10 +781,13 @@ async fn default_(
             }
         };
 
-        if let Some((toolchain, reason)) = cfg.active_toolchain()?
-            && !matches!(reason, ActiveReason::Default)
+        if let Some((toolchain, source)) = cfg.active_toolchain()?
+            && !matches!(source, ActiveSource::Default)
         {
-            info!("note that the toolchain '{toolchain}' is currently in use ({reason})");
+            info!(
+                "note that the toolchain '{toolchain}' is currently in use ({})",
+                source.to_reason()
+            );
         }
     } else {
         let default_toolchain = cfg
@@ -999,9 +1002,9 @@ async fn update(
             exit_code &= self_update::self_update(cfg.process).await?;
         }
     } else if ensure_active_toolchain {
-        let (toolchain, reason) = cfg.ensure_active_toolchain(force_non_host, true).await?;
+        let (toolchain, source) = cfg.ensure_active_toolchain(force_non_host, true).await?;
         info!("the active toolchain `{toolchain}` has been installed");
-        info!("it's active because: {reason}");
+        info!("it's active because: {}", source.to_reason());
     } else {
         exit_code &= common::update_all_channels(cfg, opts.force).await?;
         if self_update {
@@ -1090,16 +1093,16 @@ async fn show(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
     }
 
     let installed_toolchains = cfg.list_toolchains()?;
-    let active_toolchain_and_reason: Option<(ToolchainName, ActiveReason)> =
-        if let Ok(Some((LocalToolchainName::Named(toolchain_name), reason))) =
+    let active_toolchain_and_source: Option<(ToolchainName, ActiveSource)> =
+        if let Ok(Some((LocalToolchainName::Named(toolchain_name), source))) =
             cfg.maybe_ensure_active_toolchain(None).await
         {
-            Some((toolchain_name, reason))
+            Some((toolchain_name, source))
         } else {
             None
         };
 
-    let (active_toolchain_name, _active_reason) = active_toolchain_and_reason
+    let (active_toolchain_name, _active_source) = active_toolchain_and_source
         .as_ref()
         .map(|atar| (&atar.0, &atar.1))
         .unzip();
@@ -1163,15 +1166,15 @@ async fn show(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
 
         print_header::<Error>(&mut t, "active toolchain")?;
 
-        match active_toolchain_and_reason {
-            Some((active_toolchain_name, active_reason)) => {
-                let active_toolchain = Toolchain::with_reason(
+        match active_toolchain_and_source {
+            Some((active_toolchain_name, active_source)) => {
+                let active_toolchain = Toolchain::with_source(
                     cfg,
                     active_toolchain_name.clone().into(),
-                    &active_reason,
+                    &active_source,
                 )?;
                 writeln!(t.lock(), "name: {}", active_toolchain.name())?;
-                writeln!(t.lock(), "active because: {active_reason}")?;
+                writeln!(t.lock(), "active because: {}", active_source.to_reason())?;
                 if verbose {
                     writeln!(t.lock(), "compiler: {}", active_toolchain.rustc_version())?;
                     writeln!(t.lock(), "path: {}", active_toolchain.path().display())?;
@@ -1210,14 +1213,14 @@ async fn show(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
 #[tracing::instrument(level = "trace", skip_all)]
 async fn show_active_toolchain(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
     match cfg.maybe_ensure_active_toolchain(None).await? {
-        Some((toolchain_name, reason)) => {
-            let toolchain = Toolchain::with_reason(cfg, toolchain_name.clone(), &reason)?;
+        Some((toolchain_name, source)) => {
+            let toolchain = Toolchain::with_source(cfg, toolchain_name.clone(), &source)?;
             if verbose {
                 writeln!(
                     cfg.process.stdout().lock(),
                     "{}\nactive because: {}\ncompiler: {}\npath: {}",
                     toolchain.name(),
-                    reason,
+                    source.to_reason(),
                     toolchain.rustc_version(),
                     toolchain.path().display()
                 )?;
@@ -1226,9 +1229,9 @@ async fn show_active_toolchain(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::Ex
                     cfg.process.stdout().lock(),
                     "{} ({})",
                     toolchain.name(),
-                    match reason {
-                        ActiveReason::Default => &"default" as &dyn fmt::Display,
-                        _ => &reason,
+                    match source {
+                        ActiveSource::Default => &"default" as &dyn fmt::Display,
+                        _ => &source.to_reason(),
                     }
                 )?;
             }
diff --git a/src/config.rs b/src/config.rs
@@ -92,38 +92,39 @@ impl<T: Into<String>> From<T> for OverrideFile {
     }
 }
 
-// Represents the reason why the active toolchain is active.
+// Represents the source that determined the current active toolchain.
 #[derive(Debug)]
-pub(crate) enum ActiveReason {
+pub(crate) enum ActiveSource {
     Default,
     Environment,
     CommandLine,
     OverrideDB(PathBuf),
     ToolchainFile(PathBuf),
 }
 
-impl ActiveReason {
-    /// Format `ActiveReason` for setting the `RUSTUP_TOOLCHAIN_SOURCE` environment variable.
-    pub fn to_source(&self) -> &str {
+impl ActiveSource {
+    pub fn to_reason(&self) -> String {
         match self {
+            Self::Default => String::from("it's the default toolchain"),
+            Self::Environment => {
+                String::from("overridden by environment variable RUSTUP_TOOLCHAIN")
+            }
+            Self::CommandLine => String::from("overridden by +toolchain on the command line"),
+            Self::OverrideDB(path) => format!("directory override for '{}'", path.display()),
+            Self::ToolchainFile(path) => format!("overridden by '{}'", path.display()),
+        }
+    }
+}
+
+impl Display for ActiveSource {
+    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",
-        }
-    }
-}
-
-impl Display for ActiveReason {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> {
-        match self {
-            Self::Default => write!(f, "it's the default toolchain"),
-            Self::Environment => write!(f, "overridden by environment variable RUSTUP_TOOLCHAIN"),
-            Self::CommandLine => write!(f, "overridden by +toolchain on the command line"),
-            Self::OverrideDB(path) => write!(f, "directory override for '{}'", path.display()),
-            Self::ToolchainFile(path) => write!(f, "overridden by '{}'", path.display()),
-        }
+        })
     }
 }
 
@@ -517,7 +518,7 @@ impl<'a> Cfg<'a> {
     pub(crate) async fn maybe_ensure_active_toolchain(
         &self,
         force_ensure: Option<bool>,
-    ) -> Result<Option<(LocalToolchainName, ActiveReason)>> {
+    ) -> Result<Option<(LocalToolchainName, ActiveSource)>> {
         let should_ensure = if let Some(force) = force_ensure {
             force
         } else {
@@ -536,39 +537,39 @@ impl<'a> Cfg<'a> {
         }
     }
 
-    pub(crate) fn active_toolchain(&self) -> Result<Option<(LocalToolchainName, ActiveReason)>> {
+    pub(crate) fn active_toolchain(&self) -> Result<Option<(LocalToolchainName, ActiveSource)>> {
         Ok(
-            if let Some((override_config, reason)) = self.find_override_config()? {
-                Some((override_config.into_local_toolchain_name(), reason))
+            if let Some((override_config, source)) = self.find_override_config()? {
+                Some((override_config.into_local_toolchain_name(), source))
             } else {
                 self.get_default()?
-                    .map(|x| (x.into(), ActiveReason::Default))
+                    .map(|x| (x.into(), ActiveSource::Default))
             },
         )
     }
 
-    fn find_override_config(&self) -> Result<Option<(OverrideCfg, ActiveReason)>> {
-        let override_config: Option<(OverrideCfg, ActiveReason)> =
+    fn find_override_config(&self) -> Result<Option<(OverrideCfg, ActiveSource)>> {
+        let override_config: Option<(OverrideCfg, ActiveSource)> =
             // First check +toolchain override from the command line
             if let Some(name) = &self.toolchain_override {
                 let override_config = name.resolve(&self.get_default_host_triple()?)?.into();
-                Some((override_config, ActiveReason::CommandLine))
+                Some((override_config, ActiveSource::CommandLine))
             }
             // Then check the RUSTUP_TOOLCHAIN environment variable
             else if let Some(name) = &self.env_override {
                 // Because path based toolchain files exist, this has to support
                 // custom, distributable, and absolute path toolchains otherwise
                 // rustup's export of a RUSTUP_TOOLCHAIN when running a process will
                 // error when a nested rustup invocation occurs
-                Some((name.clone().into(), ActiveReason::Environment))
+                Some((name.clone().into(), ActiveSource::Environment))
             }
             // Then walk up the directory tree from 'path' looking for either the
             // directory in the override database, or a `rust-toolchain{.toml}` file,
             // in that order.
-            else if let Some((override_cfg, active_reason)) = self.settings_file.with(|s| {
+            else if let Some((override_cfg, active_source)) = self.settings_file.with(|s| {
                     self.find_override_from_dir_walk(&self.current_dir, s)
                 })? {
-                Some((override_cfg, active_reason))
+                Some((override_cfg, active_source))
             }
             // Otherwise, there is no override.
             else {
@@ -582,14 +583,14 @@ impl<'a> Cfg<'a> {
         &self,
         dir: &Path,
         settings: &Settings,
-    ) -> Result<Option<(OverrideCfg, ActiveReason)>> {
+    ) -> Result<Option<(OverrideCfg, ActiveSource)>> {
         let notify = self.notify_handler.as_ref();
         let mut dir = Some(dir);
 
         while let Some(d) = dir {
             // First check the override database
             if let Some(name) = settings.dir_override(d) {
-                let reason = ActiveReason::OverrideDB(d.to_owned());
+                let source = ActiveSource::OverrideDB(d.to_owned());
                 // Note that `rustup override set` fully resolves it's input
                 // before writing to settings.toml, so resolving here may not
                 // be strictly necessary (could instead model as ToolchainName).
@@ -599,7 +600,7 @@ impl<'a> Cfg<'a> {
                 let toolchain_name = ResolvableToolchainName::try_from(name)?
                     .resolve(&get_default_host_triple(settings, self.process))?;
                 let override_cfg = toolchain_name.into();
-                return Ok(Some((override_cfg, reason)));
+                return Ok(Some((override_cfg, source)));
             }
 
             // Then look for 'rust-toolchain' or 'rust-toolchain.toml'
@@ -676,9 +677,9 @@ impl<'a> Cfg<'a> {
                     }
                 }
 
-                let reason = ActiveReason::ToolchainFile(toolchain_file);
+                let source = ActiveSource::ToolchainFile(toolchain_file);
                 let override_cfg = OverrideCfg::from_file(self, override_file)?;
-                return Ok(Some((override_cfg, reason)));
+                return Ok(Some((override_cfg, source)));
             }
 
             dir = d.parent();
@@ -772,8 +773,8 @@ impl<'a> Cfg<'a> {
         &self,
         force_non_host: bool,
         verbose: bool,
-    ) -> Result<(LocalToolchainName, ActiveReason)> {
-        if let Some((override_config, reason)) = self.find_override_config()? {
+    ) -> Result<(LocalToolchainName, ActiveSource)> {
+        if let Some((override_config, source)) = self.find_override_config()? {
             let toolchain = override_config.clone().into_local_toolchain_name();
             if let OverrideCfg::Official {
                 toolchain,
@@ -792,18 +793,18 @@ impl<'a> Cfg<'a> {
                 )
                 .await?;
             } else {
-                Toolchain::with_reason(self, toolchain.clone(), &reason)?;
+                Toolchain::with_source(self, toolchain.clone(), &source)?;
             }
-            Ok((toolchain, reason))
+            Ok((toolchain, source))
         } else if let Some(toolchain) = self.get_default()? {
-            let reason = ActiveReason::Default;
+            let source = ActiveSource::Default;
             if let ToolchainName::Official(desc) = &toolchain {
                 self.ensure_installed(desc, vec![], vec![], None, force_non_host, verbose)
                     .await?;
             } else {
-                Toolchain::with_reason(self, toolchain.clone().into(), &reason)?;
+                Toolchain::with_source(self, toolchain.clone().into(), &source)?;
             }
-            Ok((toolchain.into(), reason))
+            Ok((toolchain.into(), source))
         } else {
             Err(no_toolchain_error(self.process))
         }
diff --git a/src/toolchain.rs b/src/toolchain.rs

Original file line number	Diff line number	Diff line change
`@@ -331,7 +331,7 @@ pub(crate) async fn list_toolchains(`
`331`	`331`	`} else {`
`332`	`332`	`let default_toolchain_name = cfg.get_default()?;`
`333`	`333`	`let active_toolchain_name: Option<ToolchainName> =`
`334`		`- if let Ok(Some((LocalToolchainName::Named(toolchain), _reason))) =`
	`334`	`+ if let Ok(Some((LocalToolchainName::Named(toolchain), _source))) =`
`335`	`335`	`cfg.maybe_ensure_active_toolchain(None).await`
`336`	`336`	`{`
`337`	`337`	`Some(toolchain)`