Rename ActiveReason to ActiveSource

smoelius · djc · commit 2705e87c32a1 · 2025-10-16T10:09:40.000Z
diff --git a/src/cli/common.rs b/src/cli/common.rs
@@ -279,7 +279,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/rustup_mode.rs b/src/cli/rustup_mode.rs
@@ -32,7 +32,7 @@ use crate::{
         topical_doc,
     },
     command, component_for_bin,
-    config::{ActiveReason, Cfg},
+    config::{ActiveSource, Cfg},
     dist::{
         AutoInstallMode, PartialToolchainDesc, Profile, TargetTriple,
         download::DownloadCfg,
@@ -781,10 +781,10 @@ 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})");
         }
     } else {
         let default_toolchain = cfg
@@ -1002,9 +1002,9 @@ async fn update(
             exit_code &= self_update::self_update(&dl_cfg).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}");
     } else {
         exit_code &= common::update_all_channels(cfg, opts.force).await?;
         if self_update {
@@ -1099,16 +1099,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();
@@ -1172,15 +1172,15 @@ async fn show(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
 
         print_header(&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}")?;
                 if verbose {
                     writeln!(t.lock(), "compiler: {}", active_toolchain.rustc_version())?;
                     writeln!(t.lock(), "path: {}", active_toolchain.path().display())?;
@@ -1214,14 +1214,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,
                     toolchain.rustc_version(),
                     toolchain.path().display()
                 )?;
@@ -1230,9 +1230,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,
                     }
                 )?;
             }
diff --git a/src/config.rs b/src/config.rs
@@ -87,17 +87,17 @@ 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 Display for ActiveReason {
+impl Display for ActiveSource {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> {
         match self {
             Self::Default => write!(f, "it's the default toolchain"),
@@ -486,7 +486,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 {
@@ -505,39 +505,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 {
@@ -551,13 +551,13 @@ impl<'a> Cfg<'a> {
         &self,
         dir: &Path,
         settings: &Settings,
-    ) -> Result<Option<(OverrideCfg, ActiveReason)>> {
+    ) -> Result<Option<(OverrideCfg, ActiveSource)>> {
         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).
@@ -567,7 +567,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'
@@ -651,9 +651,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();
@@ -747,8 +747,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,
@@ -767,18 +767,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
@@ -21,7 +21,7 @@ use wait_timeout::ChildExt;
 
 use crate::{
     RustupError,
-    config::{ActiveReason, Cfg, InstalledPath},
+    config::{ActiveSource, Cfg, InstalledPath},
     dist::{
         PartialToolchainDesc, TargetTriple,
         component::{Component, Components},
@@ -73,11 +73,11 @@ impl<'a> Toolchain<'a> {
     }
 
     /// Calls Toolchain::new(), but augments the error message with more context
-    /// from the ActiveReason if the toolchain isn't installed.
-    pub(crate) fn with_reason(
+    /// from the ActiveSource if the toolchain isn't installed.
+    pub(crate) fn with_source(
         cfg: &'a Cfg<'a>,
         name: LocalToolchainName,
-        reason: &ActiveReason,
+        source: &ActiveSource,
     ) -> anyhow::Result<Self> {
         match Self::new(cfg, name.clone()) {
             Err(RustupError::ToolchainNotInstalled { .. }) => (),
@@ -86,28 +86,28 @@ impl<'a> Toolchain<'a> {
             }
         }
 
-        let reason_err = match reason {
-            ActiveReason::Environment => {
+        let source_err = match source {
+            ActiveSource::Environment => {
                 "the RUSTUP_TOOLCHAIN environment variable specifies an uninstalled toolchain"
                     .to_string()
             }
-            ActiveReason::CommandLine => {
+            ActiveSource::CommandLine => {
                 "the +toolchain on the command line specifies an uninstalled toolchain".to_string()
             }
-            ActiveReason::OverrideDB(path) => format!(
+            ActiveSource::OverrideDB(path) => format!(
                 "the directory override for '{}' specifies an uninstalled toolchain",
                 utils::canonicalize_path(path).display(),
             ),
-            ActiveReason::ToolchainFile(path) => format!(
+            ActiveSource::ToolchainFile(path) => format!(
                 "the toolchain file at '{}' specifies an uninstalled toolchain",
                 utils::canonicalize_path(path).display(),
             ),
-            ActiveReason::Default => {
+            ActiveSource::Default => {
                 "the default toolchain does not describe an installed toolchain".to_string()
             }
         };
 
-        Err(anyhow!(reason_err).context(format!("override toolchain '{name}' is not installed")))
+        Err(anyhow!(source_err).context(format!("override toolchain '{name}' is not installed")))
     }
 
     pub(crate) fn new(cfg: &'a Cfg<'a>, name: LocalToolchainName) -> Result<Self, RustupError> {

Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ pub(crate) async fn list_toolchains(`
`279`	`279`	`} else {`
`280`	`280`	`let default_toolchain_name = cfg.get_default()?;`
`281`	`281`	`let active_toolchain_name: Option<ToolchainName> =`
`282`		`- if let Ok(Some((LocalToolchainName::Named(toolchain), _reason))) =`
	`282`	`+ if let Ok(Some((LocalToolchainName::Named(toolchain), _source))) =`
`283`	`283`	`cfg.maybe_ensure_active_toolchain(None).await`
`284`	`284`	`{`
`285`	`285`	`Some(toolchain)`