fix(config): warn if host is incompatible with the toolchain in rustup default

src/cli/common.rs

@@ -15,17 +15,18 @@ use git_testament::{git_testament, render_testament};
 use tracing::{debug, error, info, trace, warn};
 
 use super::self_update;
-use crate::cli::download_tracker::DownloadTracker;
-use crate::dist::{
- manifest::ComponentStatus, notifications as dist_notifications, TargetTriple, ToolchainDesc,
+use crate::{
+ cli::download_tracker::DownloadTracker,
+ config::Cfg,
+ dist::{
+ manifest::ComponentStatus, notifications as dist_notifications, TargetTriple, ToolchainDesc,
+ },
+ install::UpdateStatus,
+ notifications::Notification,
+ process::{terminalsource, Process},
+ toolchain::{DistributableToolchain, LocalToolchainName, Toolchain, ToolchainName},
+ utils::{notifications as util_notifications, notify::NotificationLevel, utils},
 };
-use crate::install::UpdateStatus;
-use crate::process::{terminalsource, Process};
-use crate::toolchain::{DistributableToolchain, LocalToolchainName, Toolchain, ToolchainName};
-use crate::utils::notifications as util_notifications;
-use crate::utils::notify::NotificationLevel;
-use crate::utils::utils;
-use crate::{config::Cfg, notifications::Notification};
 
 pub(crate) const WARN_COMPLETE_PROFILE: &str = "downloading with complete profile isn't recommended unless you are a developer of the rust language";
 
@@ -633,6 +634,23 @@ pub(crate) fn ignorable_error(
  }
 }
 
+/// Warns if rustup is trying to install a toolchain that might not be
+/// able to run on the host system.
+pub(crate) fn warn_if_host_is_incompatible(
+ toolchain: impl Display,
+ host_arch: &TargetTriple,
+ target_triple: &TargetTriple,
+ force_non_host: bool,
+) -> Result<()> {
+ if force_non_host || host_arch.can_run(target_triple)? {
+ return Ok(());
+ }
+ error!("DEPRECATED: future versions of rustup will require --force-non-host to install a non-host toolchain.");
+ warn!("toolchain '{toolchain}' may not be able to run on this system.");
+ warn!("If you meant to build software to target that platform, perhaps try `rustup target add {target_triple}` instead?");
+ Ok(())
+}
+
 /// Warns if rustup is running under emulation, such as macOS Rosetta
 pub(crate) fn warn_if_host_is_emulated(process: &Process) {
  if TargetTriple::is_host_emulated() {

src/cli/rustup_mode.rs

@@ -9,7 +9,7 @@ use anyhow::{anyhow, Error, Result};
 use clap::{builder::PossibleValue, Args, CommandFactory, Parser, Subcommand, ValueEnum};
 use clap_complete::Shell;
 use itertools::Itertools;
-use tracing::{error, info, trace, warn};
+use tracing::{info, trace, warn};
 
 use crate::{
  cli::{
@@ -717,7 +717,10 @@ async fn default_(
  }
  MaybeResolvableToolchainName::Some(ResolvableToolchainName::Official(toolchain)) => {
  let desc = toolchain.resolve(&cfg.get_default_host_triple()?)?;
- let status = DistributableToolchain::install_if_not_installed(cfg, &desc).await?;
+ let status = cfg
+ .ensure_installed(&desc, vec![], vec![], None, true)
+ .await?
+ .0;
 
  cfg.set_default(Some(&(&desc).into()))?;
 
@@ -814,16 +817,8 @@ async fn update(cfg: &mut Cfg<'_>, opts: UpdateOpts) -> Result<utils::ExitCode>
  // This needs another pass to fix it all up
  if name.has_triple() {
  let host_arch = TargetTriple::from_host_or_build(cfg.process);
-
  let target_triple = name.clone().resolve(&host_arch)?.target;
- if !forced && !host_arch.can_run(&target_triple)? {
- error!("DEPRECATED: future versions of rustup will require --force-non-host to install a non-host toolchain.");
- warn!("toolchain '{name}' may not be able to run on this system.");
- warn!(
- "If you meant to build software to target that platform, perhaps try `rustup target add {}` instead?",
- target_triple.to_string()
- );
- }
+ common::warn_if_host_is_incompatible(&name, &host_arch, &target_triple, forced)?;
  }
  let desc = name.resolve(&cfg.get_default_host_triple()?)?;
 

src/config.rs

@@ -11,8 +11,11 @@ use tokio_stream::StreamExt;
 use tracing::trace;
 
 use crate::{
- cli::self_update::SelfUpdateMode,
- dist::{self, download::DownloadCfg, temp, PartialToolchainDesc, Profile, ToolchainDesc},
+ cli::{common, self_update::SelfUpdateMode},
+ dist::{
+ self, download::DownloadCfg, temp, PartialToolchainDesc, Profile, TargetTriple,
+ ToolchainDesc,
+ },
  errors::RustupError,
  fallback_settings::FallbackSettings,
  install::UpdateStatus,
@@ -120,7 +123,7 @@ enum OverrideCfg {
  toolchain: ToolchainDesc,
  components: Vec<String>,
  targets: Vec<String>,
- profile: Option<dist::Profile>,
+ profile: Option<Profile>,
  },
 }
 
@@ -172,7 +175,7 @@ impl OverrideCfg {
  .toolchain
  .profile
  .as_deref()
- .map(dist::Profile::from_str)
+ .map(Profile::from_str)
  .transpose()?,
  }
  }
@@ -227,7 +230,7 @@ impl From<LocalToolchainName> for OverrideCfg {
 pub(crate) const UNIX_FALLBACK_SETTINGS: &str = "/etc/rustup/settings.toml";
 
 pub(crate) struct Cfg<'a> {
- profile_override: Option<dist::Profile>,
+ profile_override: Option<Profile>,
  pub rustup_dir: PathBuf,
  pub settings_file: SettingsFile,
  pub fallback_settings: Option<FallbackSettings>,
@@ -345,7 +348,7 @@ impl<'a> Cfg<'a> {
  }
  }
 
- pub(crate) fn set_profile_override(&mut self, profile: dist::Profile) {
+ pub(crate) fn set_profile_override(&mut self, profile: Profile) {
  self.profile_override = Some(profile);
  }
 
@@ -388,7 +391,7 @@ impl<'a> Cfg<'a> {
  // if there is no profile in the settings file. The last variant happens when
  // a user upgrades from a version of Rustup without profiles to a version of
  // Rustup with profiles.
- pub(crate) fn get_profile(&self) -> Result<dist::Profile> {
+ pub(crate) fn get_profile(&self) -> Result<Profile> {
  if let Some(p) = self.profile_override {
  return Ok(p);
  }
@@ -752,8 +755,9 @@ impl<'a> Cfg<'a> {
  profile,
  } => {
  let toolchain = self
- .ensure_installed(toolchain, components, targets, profile)
- .await?;
+ .ensure_installed(&toolchain, components, targets, profile, false)
+ .await?
+ .1;
  Ok((toolchain, reason))
  }
  },
@@ -767,8 +771,9 @@ impl<'a> Cfg<'a> {
  Some(ToolchainName::Official(toolchain_desc)) => {
  let reason = ActiveReason::Default;
  let toolchain = self
- .ensure_installed(toolchain_desc, vec![], vec![], None)
- .await?;
+ .ensure_installed(&toolchain_desc, vec![], vec![], None, false)
+ .await?
+ .1;
  Ok((toolchain, reason))
  }
  },
@@ -777,40 +782,56 @@ impl<'a> Cfg<'a> {
 
  // Returns a Toolchain matching the given ToolchainDesc, installing it and
  // the given components and targets if they aren't already installed.
- async fn ensure_installed(
+ #[tracing::instrument(level = "trace", err(level = "trace"), skip_all)]
+ pub(crate) async fn ensure_installed(
  &self,
- toolchain: ToolchainDesc,
+ toolchain: &ToolchainDesc,
  components: Vec<String>,
  targets: Vec<String>,
  profile: Option<Profile>,
- ) -> Result<Toolchain<'_>> {
+ verbose: bool,
+ ) -> Result<(UpdateStatus, Toolchain<'_>)> {
+ common::warn_if_host_is_incompatible(
+ toolchain,
+ &TargetTriple::from_host_or_build(self.process),
+ &toolchain.target,
+ false,
+ )?;
+ if verbose {
+ (self.notify_handler)(Notification::LookingForToolchain(toolchain));
+ }
  let components: Vec<_> = components.iter().map(AsRef::as_ref).collect();
  let targets: Vec<_> = targets.iter().map(AsRef::as_ref).collect();
- let toolchain = match DistributableToolchain::new(self, toolchain.clone()) {
+ let profile = match profile {
+ Some(profile) => profile,
+ None => self.get_profile()?,
+ };
+ let (status, toolchain) = match DistributableToolchain::new(self, toolchain.clone()) {
  Err(RustupError::ToolchainNotInstalled(_)) => {
  DistributableToolchain::install(
  self,
-&toolchain,
+ toolchain,
  &components,
  &targets,
- profile.unwrap_or(Profile::Default),
+ profile,
  false,
  )
  .await?
- .1
  }
  Ok(mut distributable) => {
- if !distributable.components_exist(&components, &targets)? {
- distributable
- .update(&components, &targets, profile.unwrap_or(Profile::Default))
- .await?;
+ if verbose {
+ (self.notify_handler)(Notification::UsingExistingToolchain(toolchain));
  }
- distributable
+ let status = if !distributable.components_exist(&components, &targets)? {
+ distributable.update(&components, &targets, profile).await?
+ } else {
+ UpdateStatus::Unchanged
+ };
+ (status, distributable)
  }
  Err(e) => return Err(e.into()),
- }
- .into();
- Ok(toolchain)
+ };
+ Ok((status, toolchain.into()))
  }
 
  /// Get the configured default toolchain.
@@ -913,15 +934,15 @@ impl<'a> Cfg<'a> {
  // against the 'stable' toolchain. This provides early errors
  // if the supplied triple is insufficient / bad.
  dist::PartialToolchainDesc::from_str("stable")?
- .resolve(&dist::TargetTriple::new(host_triple.clone()))?;
+ .resolve(&TargetTriple::new(host_triple.clone()))?;
  self.settings_file.with_mut(|s| {
  s.default_host_triple = Some(host_triple);
  Ok(())
  })
  }
 
  #[tracing::instrument(level = "trace", skip_all)]
- pub(crate) fn get_default_host_triple(&self) -> Result<dist::TargetTriple> {
+ pub(crate) fn get_default_host_triple(&self) -> Result<TargetTriple> {
  self.settings_file
  .with(|s| Ok(get_default_host_triple(s, self.process)))
  }
@@ -989,11 +1010,11 @@ impl<'a> Debug for Cfg<'a> {
  }
 }
 
-fn get_default_host_triple(s: &Settings, process: &Process) -> dist::TargetTriple {
+fn get_default_host_triple(s: &Settings, process: &Process) -> TargetTriple {
  s.default_host_triple
  .as_ref()
- .map(dist::TargetTriple::new)
- .unwrap_or_else(|| dist::TargetTriple::from_host_or_build(process))
+ .map(TargetTriple::new)
+ .unwrap_or_else(|| TargetTriple::from_host_or_build(process))
 }
 
 fn non_empty_env_var(name: &str, process: &Process) -> anyhow::Result<Option<String>> {

src/toolchain/distributable.rs

@@ -17,7 +17,6 @@ use crate::{
  DistOptions, PartialToolchainDesc, Profile, ToolchainDesc,
  },
  install::{InstallMethod, UpdateStatus},
- notifications::Notification,
  RustupError,
 };
 
@@ -358,24 +357,6 @@ impl<'a> DistributableToolchain<'a> {
  Ok((status, Self::new(cfg, toolchain.clone())?))
  }
 
- #[tracing::instrument(level = "trace", err(level = "trace"), skip_all)]
- pub async fn install_if_not_installed(
- cfg: &'a Cfg<'a>,
- desc: &ToolchainDesc,
- ) -> anyhow::Result<UpdateStatus> {
- (cfg.notify_handler)(Notification::LookingForToolchain(desc));
- if Toolchain::exists(cfg, &desc.into())? {
- (cfg.notify_handler)(Notification::UsingExistingToolchain(desc));
- Ok(UpdateStatus::Unchanged)
- } else {
- Ok(
- Self::install(cfg, desc, &[], &[], cfg.get_profile()?, false)
- .await?
- .0,
- )
- }
- }
-
  #[tracing::instrument(level = "trace", err(level = "trace"), skip_all)]
  pub(crate) async fn update(
  &mut self,

tests/suite/cli_rustup.rs

@@ -2725,6 +2725,19 @@ warn: If you meant to build software to target that platform, perhaps try `rustu
  ).await;
 }
 
+#[tokio::test]
+async fn warn_on_unmatch_build_default() {
+ let cx = CliTestContext::new(Scenario::MultiHost).await;
+ let arch = clitools::MULTI_ARCH1;
+ cx.config.expect_stderr_ok(
+ &["rustup", "default", &format!("nightly-{arch}")],
+ &format!(
+ r"warn: toolchain 'nightly-{arch}' may not be able to run on this system.
+warn: If you meant to build software to target that platform, perhaps try `rustup target add {arch}` instead?",
+ ),
+ ).await;
+}
+
 #[tokio::test]
 async fn dont_warn_on_partial_build() {
  let cx = CliTestContext::new(Scenario::SimpleV2).await;