cli: prepare DistOptions in advance

djc · djc · commit 323bf9fcb891 · 2025-11-04T13:56:31.000Z
diff --git a/src/cli/common.rs b/src/cli/common.rs
@@ -16,9 +16,9 @@ use tracing_subscriber::{EnvFilter, Registry, reload::Handle};
 
 use crate::{
     config::Cfg,
-    dist::{TargetTriple, ToolchainDesc},
+    dist::{DistOptions, TargetTriple, ToolchainDesc},
     errors::RustupError,
-    install::UpdateStatus,
+    install::{InstallMethod, UpdateStatus},
     process::Process,
     toolchain::{LocalToolchainName, Toolchain, ToolchainName},
     utils,
@@ -217,10 +217,10 @@ pub(crate) async fn update_all_channels(
 ) -> Result<utils::ExitCode> {
     let profile = cfg.get_profile()?;
     let mut toolchains = Vec::new();
-    for (desc, mut distributable) in cfg.list_channels()? {
-        let result = distributable
-            .update(&[], &[], profile, force_update, false)
-            .await;
+    for (desc, distributable) in cfg.list_channels()? {
+        let options = DistOptions::new(&[], &[], &desc, profile, force_update, cfg)?
+            .for_update(&distributable, false);
+        let result = InstallMethod::Dist(options).install().await;
 
         if let Err(e) = &result {
             error!("{e}");
diff --git a/src/cli/rustup_mode.rs b/src/cli/rustup_mode.rs
@@ -41,7 +41,7 @@ use crate::{
     command, component_for_bin,
     config::{ActiveSource, Cfg},
     dist::{
-        AutoInstallMode, PartialToolchainDesc, Profile, TargetTriple,
+        AutoInstallMode, DistOptions, PartialToolchainDesc, Profile, TargetTriple,
         download::DownloadCfg,
         manifest::{Component, ComponentStatus},
     },
@@ -960,27 +960,23 @@ async fn update(
 
             let components = opts.component.iter().map(|s| &**s).collect::<Vec<_>>();
             let targets = opts.target.iter().map(|s| &**s).collect::<Vec<_>>();
+            let dist_opts = DistOptions::new(
+                &components,
+                &targets,
+                &desc,
+                cfg.get_profile()?,
+                opts.force,
+                cfg,
+            )?;
 
-            let force = opts.force;
-            let allow_downgrade = opts.allow_downgrade;
-            let profile = cfg.get_profile()?;
             let status = match DistributableToolchain::new(cfg, desc.clone()) {
-                Ok(mut d) => {
-                    let profile = cfg.get_profile()?;
-                    d.update(&components, &targets, profile, force, allow_downgrade)
+                Ok(d) => {
+                    InstallMethod::Dist(dist_opts.for_update(&d, opts.allow_downgrade))
+                        .install()
                         .await?
                 }
                 Err(RustupError::ToolchainNotInstalled { .. }) => {
-                    DistributableToolchain::install(
-                        cfg,
-                        &desc,
-                        &components,
-                        &targets,
-                        profile,
-                        force,
-                    )
-                    .await?
-                    .0
+                    DistributableToolchain::install(dist_opts).await?.0
                 }
                 Err(e) => Err(e)?,
             };
@@ -1520,10 +1516,8 @@ async fn override_add(
         Err(e @ RustupError::ToolchainNotInstalled { .. }) => match &toolchain_name {
             ToolchainName::Custom(_) => Err(e)?,
             ToolchainName::Official(desc) => {
-                let status =
-                    DistributableToolchain::install(cfg, desc, &[], &[], cfg.get_profile()?, false)
-                        .await?
-                        .0;
+                let options = DistOptions::new(&[], &[], desc, cfg.get_profile()?, false, cfg)?;
+                let status = DistributableToolchain::install(options).await?.0;
                 writeln!(cfg.process.stdout().lock())?;
                 common::show_channel_update(
                     cfg,
diff --git a/src/cli/self_update.rs b/src/cli/self_update.rs
@@ -59,10 +59,13 @@ use crate::{
         markdown::md,
     },
     config::Cfg,
-    dist::{PartialToolchainDesc, Profile, TargetTriple, ToolchainDesc, download::DownloadCfg},
+    dist::{
+        DistOptions, PartialToolchainDesc, Profile, TargetTriple, ToolchainDesc,
+        download::DownloadCfg,
+    },
     download::download_file,
     errors::RustupError,
-    install::UpdateStatus,
+    install::{InstallMethod, UpdateStatus},
     process::Process,
     toolchain::{
         DistributableToolchain, MaybeOfficialToolchainName, ResolvableToolchainName, Toolchain,
@@ -996,28 +999,20 @@ async fn maybe_install_rust(opts: InstallOpts<'_>, cfg: &mut Cfg<'_>) -> Result<
     let (components, targets) = (opts.components, opts.targets);
     let toolchain = opts.install(cfg)?;
     if let Some(desc) = &toolchain {
+        let options = DistOptions::new(components, targets, desc, cfg.get_profile()?, true, cfg)?;
         let status = if Toolchain::exists(cfg, &desc.into())? {
             warn!("Updating existing toolchain, profile choice will be ignored");
             // If we have a partial install we might not be able to read content here. We could:
             // - fail and folk have to delete the partially present toolchain to recover
             // - silently ignore it (and provide inconsistent metadata for reporting the install/update change)
             // - delete the partial install and start over
             // For now, we error.
-            let mut toolchain = DistributableToolchain::new(cfg, desc.clone())?;
-            toolchain
-                .update(components, targets, cfg.get_profile()?, true, false)
+            let toolchain = DistributableToolchain::new(cfg, desc.clone())?;
+            InstallMethod::Dist(options.for_update(&toolchain, false))
+                .install()
                 .await?
         } else {
-            DistributableToolchain::install(
-                cfg,
-                desc,
-                components,
-                targets,
-                cfg.get_profile()?,
-                true,
-            )
-            .await?
-            .0
+            DistributableToolchain::install(options).await?.0
         };
 
         check_proxy_sanity(cfg.process, components, desc)?;
diff --git a/src/config.rs b/src/config.rs
@@ -8,13 +8,15 @@ use serde::Deserialize;
 use thiserror::Error as ThisError;
 use tracing::{debug, error, info, trace, warn};
 
-use crate::dist::AutoInstallMode;
 use crate::{
     cli::{common, self_update::SelfUpdateMode},
-    dist::{self, PartialToolchainDesc, Profile, TargetTriple, ToolchainDesc, temp},
+    dist::{
+        self, AutoInstallMode, DistOptions, PartialToolchainDesc, Profile, TargetTriple,
+        ToolchainDesc, temp,
+    },
     errors::RustupError,
     fallback_settings::FallbackSettings,
-    install::UpdateStatus,
+    install::{InstallMethod, UpdateStatus},
     process::Process,
     settings::{MetadataVersion, Settings, SettingsFile},
     toolchain::{
@@ -787,29 +789,30 @@ impl<'a> Cfg<'a> {
         }
         let components: Vec<_> = components.iter().map(AsRef::as_ref).collect();
         let targets: Vec<_> = targets.iter().map(AsRef::as_ref).collect();
-        let profile = match profile {
-            Some(profile) => profile,
-            None => self.get_profile()?,
-        };
+        let mut options = DistOptions::new(
+            &components,
+            &targets,
+            toolchain,
+            match profile {
+                Some(p) => p,
+                None => self.get_profile()?,
+            },
+            false,
+            self,
+        )?;
+
         let (status, toolchain) = match DistributableToolchain::new(self, toolchain.clone()) {
             Err(RustupError::ToolchainNotInstalled { .. }) => {
-                DistributableToolchain::install(
-                    self,
-                    toolchain,
-                    &components,
-                    &targets,
-                    profile,
-                    false,
-                )
-                .await?
+                DistributableToolchain::install(options).await?
             }
-            Ok(mut distributable) => {
+            Ok(distributable) => {
                 if verbose {
                     info!("using existing install for {toolchain}");
                 }
                 let status = if !distributable.components_exist(&components, &targets)? {
-                    distributable
-                        .update(&components, &targets, profile, true, false)
+                    options.force = true;
+                    InstallMethod::Dist(options.for_update(&distributable, false))
+                        .install()
                         .await?
                 } else {
                     UpdateStatus::Unchanged
diff --git a/src/dist/mod.rs b/src/dist/mod.rs
@@ -19,7 +19,13 @@ use serde::{Deserialize, Serialize};
 use thiserror::Error as ThisError;
 use tracing::{debug, info, warn};
 
-use crate::{config::Cfg, errors::RustupError, process::Process, toolchain::ToolchainName, utils};
+use crate::{
+    config::Cfg,
+    errors::RustupError,
+    process::Process,
+    toolchain::{DistributableToolchain, ToolchainName},
+    utils,
+};
 
 pub mod component;
 pub(crate) mod config;
@@ -876,14 +882,14 @@ impl fmt::Display for Profile {
     }
 }
 
-pub(crate) struct DistOptions<'a> {
-    pub(super) cfg: &'a Cfg<'a>,
+pub(crate) struct DistOptions<'cfg, 'a> {
+    pub(super) cfg: &'cfg Cfg<'cfg>,
     pub(super) toolchain: &'a ToolchainDesc,
     profile: Profile,
     pub(super) update_hash: PathBuf,
-    dl_cfg: DownloadCfg<'a>,
+    dl_cfg: DownloadCfg<'cfg>,
     /// --force bool is whether to force an update/install
-    force: bool,
+    pub(super) force: bool,
     /// --allow-downgrade
     pub(super) allow_downgrade: bool,
     /// toolchain already exists
@@ -896,14 +902,14 @@ pub(crate) struct DistOptions<'a> {
     targets: &'a [&'a str],
 }
 
-impl<'a> DistOptions<'a> {
+impl<'cfg, 'a> DistOptions<'cfg, 'a> {
     pub(super) fn new(
         components: &'a [&'a str],
         targets: &'a [&'a str],
         toolchain: &'a ToolchainDesc,
         profile: Profile,
         force: bool,
-        cfg: &'a Cfg<'_>,
+        cfg: &'cfg Cfg<'cfg>,
     ) -> Result<Self> {
         Ok(Self {
             cfg,
@@ -919,6 +925,31 @@ impl<'a> DistOptions<'a> {
             targets,
         })
     }
+
+    pub(super) fn for_update(
+        mut self,
+        toolchain: &'a DistributableToolchain<'cfg>,
+        allow_downgrade: bool,
+    ) -> Self {
+        self.allow_downgrade = allow_downgrade;
+        self.exists = true;
+        self.old_date_version =
+            // Ignore a missing manifest: we can't report the old version
+            // correctly, and it probably indicates an incomplete install, so do
+            // not report an old rustc version either.
+            toolchain.get_manifest()
+                .map(|m| {
+                    (
+                        m.date,
+                        // should rustc_version be a free function on a trait?
+                        // note that prev_version can be junk if the rustc component is missing ...
+                        toolchain.toolchain.rustc_version(),
+                    )
+                })
+                .ok();
+
+        self
+    }
 }
 
 // Installs or updates a toolchain from a dist server. If an initial
@@ -929,7 +960,7 @@ impl<'a> DistOptions<'a> {
 #[tracing::instrument(level = "trace", err(level = "trace"), skip_all, fields(profile = ?opts.profile, prefix = %prefix.path().display()))]
 pub(crate) async fn update_from_dist(
     prefix: &InstallPrefix,
-    opts: &DistOptions<'_>,
+    opts: &DistOptions<'_, '_>,
 ) -> Result<Option<String>> {
     let fresh_install = !prefix.path().exists();
     // fresh_install means the toolchain isn't present, but hash_exists means there is a stray hash file
diff --git a/src/install.rs b/src/install.rs
@@ -20,21 +20,21 @@ pub(crate) enum UpdateStatus {
     Unchanged,
 }
 
-pub(crate) enum InstallMethod<'a> {
+pub(crate) enum InstallMethod<'cfg, 'a> {
     Copy {
         src: &'a Path,
         dest: &'a CustomToolchainName,
-        cfg: &'a Cfg<'a>,
+        cfg: &'cfg Cfg<'cfg>,
     },
     Link {
         src: &'a Path,
         dest: &'a CustomToolchainName,
-        cfg: &'a Cfg<'a>,
+        cfg: &'cfg Cfg<'cfg>,
     },
-    Dist(DistOptions<'a>),
+    Dist(DistOptions<'cfg, 'a>),
 }
 
-impl InstallMethod<'_> {
+impl InstallMethod<'_, '_> {
     // Install a toolchain
     #[tracing::instrument(level = "trace", err(level = "trace"), skip_all)]
     pub(crate) async fn install(self) -> Result<UpdateStatus> {
diff --git a/src/toolchain.rs b/src/toolchain.rs
@@ -23,7 +23,7 @@ use crate::{
     RustupError,
     config::{ActiveSource, Cfg, InstalledPath},
     dist::{
-        PartialToolchainDesc, TargetTriple,
+        DistOptions, PartialToolchainDesc, TargetTriple,
         component::{Component, Components},
         prefix::InstallPrefix,
     },
@@ -61,12 +61,8 @@ impl<'a> Toolchain<'a> {
                 name: ToolchainName::Official(desc),
                 ..
             }) if install_if_missing => {
-                Ok(
-                    DistributableToolchain::install(cfg, &desc, &[], &[], cfg.get_profile()?, true)
-                        .await?
-                        .1
-                        .toolchain,
-                )
+                let options = DistOptions::new(&[], &[], &desc, cfg.get_profile()?, true, cfg)?;
+                Ok(DistributableToolchain::install(options).await?.1.toolchain)
             }
             Err(e) => Err(e.into()),
         }
diff --git a/src/toolchain/distributable.rs b/src/toolchain/distributable.rs
