fix(errors)!: improve error messages for RustupError::ToolchainNotInstalled

src/cli/common.rs

@@ -418,7 +418,7 @@ pub(crate) async fn list_toolchains(
         let default_toolchain_name = cfg.get_default()?;
         let active_toolchain_name: Option<ToolchainName> =
             if let Ok(Some((LocalToolchainName::Named(toolchain), _reason))) =
-                cfg.find_active_toolchain(None).await
+                cfg.maybe_ensure_active_toolchain(None).await
             {
                 Some(toolchain)
             } else {

src/cli/rustup_mode.rs

@@ -763,7 +763,7 @@ async fn default_(
             }
         };
 
-        if let Some((toolchain, reason)) = cfg.find_active_toolchain(None).await? {
+        if let Some((toolchain, reason)) = cfg.active_toolchain()? {
             if !matches!(reason, ActiveReason::Default) {
                 info!("note that the toolchain '{toolchain}' is currently in use ({reason})");
             }
@@ -899,9 +899,7 @@ async fn update(
             exit_code &= common::self_update(|| Ok(()), cfg.process).await?;
         }
     } else if ensure_active_toolchain {
-        let (toolchain, reason) = cfg
-            .find_or_install_active_toolchain(force_non_host, true)
-            .await?;
+        let (toolchain, reason) = cfg.ensure_active_toolchain(force_non_host, true).await?;
         info!("the active toolchain `{toolchain}` has been installed");
         info!("it's active because: {reason}");
     } else {
@@ -974,7 +972,7 @@ 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))) =
-            cfg.find_active_toolchain(None).await
+            cfg.maybe_ensure_active_toolchain(None).await
         {
             Some((toolchain_name, reason))
         } else {
@@ -1094,7 +1092,7 @@ 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.find_active_toolchain(None).await? {
+    match cfg.maybe_ensure_active_toolchain(None).await? {
         Some((toolchain_name, reason)) => {
             let toolchain = Toolchain::with_reason(cfg, toolchain_name.clone(), &reason)?;
             if verbose {
@@ -1332,7 +1330,7 @@ async fn toolchain_link(
 async fn toolchain_remove(cfg: &mut Cfg<'_>, opts: UninstallOpts) -> Result<utils::ExitCode> {
     let default_toolchain = cfg.get_default().ok().flatten();
     let active_toolchain = cfg
-        .find_active_toolchain(Some(false))
+        .maybe_ensure_active_toolchain(Some(false))
         .await
         .ok()
         .flatten()

src/config.rs

@@ -522,65 +522,37 @@ impl<'a> Cfg<'a> {
         self.local_toolchain(toolchain).await
     }
 
-    pub(crate) async fn find_active_toolchain(
+    pub(crate) async fn maybe_ensure_active_toolchain(
         &self,
-        force_install_active: Option<bool>,
+        force_ensure: Option<bool>,
     ) -> Result<Option<(LocalToolchainName, ActiveReason)>> {
-        let (components, targets, profile, toolchain, reason) = match self.find_override_config()? {
-            Some((
-                OverrideCfg::Official {
-                    components,
-                    targets,
-                    profile,
-                    toolchain,
-                },
-                reason,
-            )) => (components, targets, profile, toolchain, reason),
-            Some((override_config, reason)) => {
-                return Ok(Some((override_config.into_local_toolchain_name(), reason)));
-            }
-            None => {
-                return Ok(self
-                    .get_default()?
-                    .map(|x| (x.into(), ActiveReason::Default)));
-            }
-        };
-
-        let should_install_active = if let Some(force) = force_install_active {
+        let should_ensure = if let Some(force) = force_ensure {
             force
         } else {
             self.should_auto_install()?
         };
-
-        if !should_install_active {
-            return Ok(Some(((&toolchain).into(), reason)));
+        if !should_ensure {
+            return self.active_toolchain();
         }
 
-        let components = components.iter().map(AsRef::as_ref).collect::<Vec<_>>();
-        let targets = targets.iter().map(AsRef::as_ref).collect::<Vec<_>>();
-        match DistributableToolchain::new(self, toolchain.clone()) {
-            Err(RustupError::ToolchainNotInstalled { .. }) => {
-                DistributableToolchain::install(
-                    self,
-                    &toolchain,
-                    &components,
-                    &targets,
-                    profile.unwrap_or_default(),
-                    false,
-                )
-                .await?;
-            }
-            Ok(mut distributable) => {
-                if !distributable.components_exist(&components, &targets)? {
-                    distributable
-                        .update(&components, &targets, profile.unwrap_or_default())
-                        .await?;
-                }
-            }
-            Err(e) => return Err(e.into()),
-        };
+        match self.ensure_active_toolchain(true, false).await {
+            Ok(r) => Ok(Some(r)),
+            Err(e) => match e.downcast_ref::<RustupError>() {
+                Some(RustupError::ToolchainNotSelected(_)) => Ok(None),
+                _ => Err(e),
+            },
+        }
+    }
 
-        Ok(Some(((&toolchain).into(), reason)))
+    pub(crate) fn active_toolchain(&self) -> Result<Option<(LocalToolchainName, ActiveReason)>> {
+        Ok(
+            if let Some((override_config, reason)) = self.find_override_config()? {
+                Some((override_config.into_local_toolchain_name(), reason))
+            } else {
+                self.get_default()?
+                    .map(|x| (x.into(), ActiveReason::Default))
+            },
+        )
     }
 
     fn find_override_config(&self) -> Result<Option<(OverrideCfg, ActiveReason)>> {
@@ -703,17 +675,13 @@ impl<'a> Cfg<'a> {
 
                     // XXX: this awkwardness deals with settings file being locked already
                     let toolchain_name = toolchain_name.resolve(&default_host_triple)?;
-                    match Toolchain::new(self, (&toolchain_name).into()) {
-                        Err(RustupError::ToolchainNotInstalled { .. }) => {
-                            if matches!(toolchain_name, ToolchainName::Custom(_)) {
-                                bail!(
-                                    "custom toolchain specified in override file '{}' is not installed",
-                                    toolchain_file.display()
-                                )
-                            }
-                        }
-                        Ok(_) => {}
-                        Err(e) => Err(e)?,
+                    if !Toolchain::exists(self, &(&toolchain_name).into())?
+                        && matches!(toolchain_name, ToolchainName::Custom(_))
+                    {
+                        bail!(
+                            "custom toolchain specified in override file '{}' is not installed",
+                            toolchain_file.display()
+                        )
                     }
                 }
 
@@ -765,7 +733,7 @@ impl<'a> Cfg<'a> {
             self.set_toolchain_override(&ResolvableToolchainName::try_from(&t[1..])?);
         }
 
-        let Some((name, _)) = self.find_active_toolchain(None).await? else {
+        let Some((name, _)) = self.maybe_ensure_active_toolchain(None).await? else {
             return Ok(None);
         };
         Ok(Some(Toolchain::new(self, name)?.rustc_version()))
@@ -799,7 +767,7 @@ impl<'a> Cfg<'a> {
             }
             None => {
                 let tc = self
-                    .find_active_toolchain(None)
+                    .maybe_ensure_active_toolchain(None)
                     .await?
                     .ok_or_else(|| no_toolchain_error(self.process))?
                     .0;
@@ -809,7 +777,7 @@ impl<'a> Cfg<'a> {
     }
 
     #[tracing::instrument(level = "trace", skip_all)]
-    pub(crate) async fn find_or_install_active_toolchain(
+    pub(crate) async fn ensure_active_toolchain(
         &self,
         force_non_host: bool,
         verbose: bool,

src/errors.rs

@@ -98,12 +98,16 @@ pub enum RustupError {
     #[error(
         "toolchain '{name}' is not installed{}",
         if let ToolchainName::Official(t) = name {
-            format!("\nhelp: run `rustup toolchain install {t}` to install it")
+            let t = if *is_active { "" } else { &format!(" {t}") };
+            format!("\nhelp: run `rustup toolchain install{t}` to install it")
         } else {
             String::new()
         },
     )]
-    ToolchainNotInstalled { name: ToolchainName },
+    ToolchainNotInstalled {
+        name: ToolchainName,
+        is_active: bool,
+    },
     #[error("path '{0}' not found")]
     PathToolchainNotInstalled(PathBasedToolchainName),
     #[error(

src/toolchain.rs

@@ -53,6 +53,7 @@ impl<'a> Toolchain<'a> {
             Ok(tc) => Ok(tc),
             Err(RustupError::ToolchainNotInstalled {
                 name: ToolchainName::Official(desc),
+                ..
             }) if install_if_missing => {
                 Ok(
                     DistributableToolchain::install(cfg, &desc, &[], &[], cfg.get_profile()?, true)
@@ -107,7 +108,10 @@ impl<'a> Toolchain<'a> {
         let path = cfg.toolchain_path(&name);
         if !Toolchain::exists(cfg, &name)? {
             return Err(match name {
-                LocalToolchainName::Named(name) => RustupError::ToolchainNotInstalled { name },
+                LocalToolchainName::Named(name) => {
+                    let is_active = matches!(cfg.active_toolchain(), Ok(Some((t, _))) if t == name);
+                    RustupError::ToolchainNotInstalled { name, is_active }
+                }
                 LocalToolchainName::Path(name) => RustupError::PathToolchainNotInstalled(name),
             });
         }

tests/suite/cli_exact.rs

@@ -5,6 +5,7 @@ use rustup::for_host;
 use rustup::test::{
     CROSS_ARCH1, CROSS_ARCH2, CliTestContext, MULTI_ARCH1, Scenario, this_host_triple,
 };
+use rustup::utils::raw;
 
 #[tokio::test]
 async fn update_once() {
@@ -699,6 +700,35 @@ help: run `rustup toolchain install nightly-{0}` to install it
         .await;
 }
 
+// issue #4212
+#[tokio::test]
+async fn show_suggestion_for_missing_toolchain_with_components() {
+    let cx = CliTestContext::new(Scenario::SimpleV2).await;
+
+    let cwd = cx.config.current_dir();
+    let toolchain_file = cwd.join("rust-toolchain.toml");
+    raw::write_file(
+        &toolchain_file,
+        r#"
+[toolchain]
+channel = "stable"
+components = [ "rust-src" ]
+"#,
+    )
+    .unwrap();
+    cx.config
+        .expect_err_env(
+            &["cargo", "fmt"],
+            &[("RUSTUP_AUTO_INSTALL", "0")],
+            for_host!(
+                r"error: toolchain 'stable-{0}' is not installed
+help: run `rustup toolchain install` to install it
+"
+            ),
+        )
+        .await;
+}
+
 // issue #927
 #[tokio::test]
 async fn undefined_linked_toolchain() {