fix!(config): re-enable active toolchain installation in Cfg::find_active_toolchain() with optional opt-out

Author: rami3l

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().await
+                cfg.find_active_toolchain(None).await
             {
                 Some(toolchain)
             } else {

src/cli/rustup_mode.rs

@@ -753,7 +753,7 @@ async fn default_(
             }
         };
 
-        if let Some((toolchain, reason)) = cfg.find_active_toolchain().await? {
+        if let Some((toolchain, reason)) = cfg.find_active_toolchain(None).await? {
             if !matches!(reason, ActiveReason::Default) {
                 info!("note that the toolchain '{toolchain}' is currently in use ({reason})");
             }
@@ -964,7 +964,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().await
+            cfg.find_active_toolchain(None).await
         {
             Some((toolchain_name, reason))
         } else {
@@ -1084,7 +1084,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().await? {
+    match cfg.find_active_toolchain(None).await? {
         Some((toolchain_name, reason)) => {
             let toolchain = Toolchain::with_reason(cfg, toolchain_name.clone(), &reason)?;
             writeln!(
@@ -1316,7 +1316,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()
+        .find_active_toolchain(Some(false))
         .await
         .ok()
         .flatten()

src/config.rs

@@ -516,15 +516,63 @@ impl<'a> Cfg<'a> {
 
     pub(crate) async fn find_active_toolchain(
         &self,
+        force_install_active: Option<bool>,
     ) -> Result<Option<(LocalToolchainName, ActiveReason)>> {
-        Ok(
-            if let Some((override_config, reason)) = self.find_override_config()? {
+        Ok(match self.find_override_config()? {
+            Some((
+                OverrideCfg::Official {
+                    components,
+                    targets,
+                    profile,
+                    ref toolchain,
+                },
+                reason,
+            )) => {
+                let should_install_active = force_install_active.unwrap_or_else(|| {
+                    self.process
+                        .var("RUSTUP_AUTO_INSTALL")
+                        .map_or(true, |it| it != "0")
+                });
+                if should_install_active {
+                    let components: Vec<_> = components.iter().map(AsRef::as_ref).collect();
+                    let targets: Vec<_> = targets.iter().map(AsRef::as_ref).collect();
+                    match DistributableToolchain::new(self, toolchain.clone()) {
+                        Err(RustupError::ToolchainNotInstalled { .. }) => {
+                            DistributableToolchain::install(
+                                self,
+                                toolchain,
+                                &components,
+                                &targets,
+                                profile.unwrap_or(Profile::Default),
+                                false,
+                            )
+                            .await?
+                            .1
+                        }
+                        Ok(mut distributable) => {
+                            if !distributable.components_exist(&components, &targets)? {
+                                distributable
+                                    .update(
+                                        &components,
+                                        &targets,
+                                        profile.unwrap_or(Profile::Default),
+                                    )
+                                    .await?;
+                            }
+                            distributable
+                        }
+                        Err(e) => return Err(e.into()),
+                    };
+                }
+                Some((toolchain.into(), reason))
+            }
+            Some((override_config, reason)) => {
                 Some((override_config.into_local_toolchain_name(), reason))
-            } else {
-                self.get_default()?
-                    .map(|x| (x.into(), ActiveReason::Default))
-            },
-        )
+            }
+            None => self
+                .get_default()?
+                .map(|x| (x.into(), ActiveReason::Default)),
+        })
     }
 
     fn find_override_config(&self) -> Result<Option<(OverrideCfg, ActiveReason)>> {
@@ -709,7 +757,7 @@ impl<'a> Cfg<'a> {
             self.set_toolchain_override(&ResolvableToolchainName::try_from(&t[1..])?);
         }
 
-        let Some((name, _)) = self.find_active_toolchain().await? else {
+        let Some((name, _)) = self.find_active_toolchain(None).await? else {
             return Ok(None);
         };
         Ok(Some(Toolchain::new(self, name)?.rustc_version()))
@@ -739,7 +787,7 @@ impl<'a> Cfg<'a> {
         let toolchain = match name {
             Some(tc) => tc,
             None => {
-                self.find_active_toolchain()
+                self.find_active_toolchain(None)
                     .await?
                     .ok_or_else(|| no_toolchain_error(self.process))?
                     .0

tests/suite/cli_rustup.rs

@@ -1052,12 +1052,12 @@ async fn show_toolchain_override_not_installed() {
         .expect_ok(&["rustup", "toolchain", "remove", "nightly"])
         .await;
     let out = cx.config.run("rustup", ["show"], &[]).await;
-    assert!(!out.ok);
+    assert!(out.ok);
     assert!(
-        out.stderr
+        !out.stderr
             .contains("is not installed: the directory override for")
     );
-    assert!(!out.stderr.contains("info: installing component 'rustc'"));
+    assert!(out.stderr.contains("info: installing component 'rustc'"));
 }
 
 #[tokio::test]
@@ -1137,7 +1137,7 @@ async fn show_toolchain_env_not_installed() {
         .run("rustup", ["show"], &[("RUSTUP_TOOLCHAIN", "nightly")])
         .await;
 
-    assert!(!out.ok);
+    assert!(out.ok);
 
     let expected_out = for_host_and_home!(
         cx.config,
@@ -1149,17 +1149,13 @@ installed toolchains
 
 active toolchain
 ----------------
+name: nightly-{0}
+active because: overridden by environment variable RUSTUP_TOOLCHAIN
+installed targets:
+  {0}
 "
     );
     assert!(&out.stdout == expected_out);
-    assert!(
-        out.stderr
-            == format!(
-                "error: override toolchain 'nightly-{}' is not installed: \
-                the RUSTUP_TOOLCHAIN environment variable specifies an uninstalled toolchain\n",
-                this_host_triple()
-            )
-    );
 }
 
 #[tokio::test]

tests/suite/cli_v1.rs

@@ -182,14 +182,10 @@ async fn remove_override_toolchain_err_handling() {
         .expect_ok(&["rustup", "toolchain", "remove", "beta"])
         .await;
     cx.config
-        .expect_err_ex(
+        .expect_ok_contains(
             &["rustc", "--version"],
-            "",
-            for_host!(
-                r"error: toolchain 'beta-{0}' is not installed
-help: run `rustup toolchain install beta-{0}` to install it
-"
-            ),
+            "1.2.0 (hash-beta-1.2.0)",
+            "info: downloading component 'rust'",
         )
         .await;
 }

tests/suite/cli_v2.rs

@@ -327,14 +327,10 @@ async fn remove_override_toolchain_err_handling() {
         .expect_ok(&["rustup", "toolchain", "remove", "beta"])
         .await;
     cx.config
-        .expect_err_ex(
+        .expect_ok_contains(
             &["rustc", "--version"],
-            "",
-            for_host!(
-                r"error: toolchain 'beta-{0}' is not installed
-help: run `rustup toolchain install beta-{0}` to install it
-"
-            ),
+            "1.2.0 (hash-beta-1.2.0)",
+            "info: downloading component 'rustc'",
         )
         .await;
 }
@@ -346,9 +342,10 @@ async fn file_override_toolchain_err_handling() {
     let toolchain_file = cwd.join("rust-toolchain");
     rustup::utils::raw::write_file(&toolchain_file, "beta").unwrap();
     cx.config
-        .expect_err(
+        .expect_ok_contains(
             &["rustc", "--version"],
-            for_host!("toolchain 'beta-{0}' is not installed"),
+            "1.2.0 (hash-beta-1.2.0)",
+            "info: downloading component 'rustc'",
         )
         .await;
 }