dist: deduplicate DistOptions initialization

Author: djc

src/dist/mod.rs

@@ -1,7 +1,8 @@
 //! Installation from a Rust distribution server
 
 use std::{
-    collections::HashSet, env, fmt, io::Write, ops::Deref, path::Path, str::FromStr, sync::LazyLock,
+    collections::HashSet, env, fmt, io::Write, ops::Deref, path::PathBuf, str::FromStr,
+    sync::LazyLock,
 };
 
 use anyhow::{Context, Result, anyhow, bail};
@@ -871,26 +872,49 @@ impl fmt::Display for Profile {
 }
 
 pub(crate) struct DistOptions<'a> {
-    pub(crate) cfg: &'a Cfg<'a>,
-    pub(crate) toolchain: &'a ToolchainDesc,
-    pub(crate) profile: Profile,
-    pub(crate) update_hash: &'a Path,
-    pub(crate) dl_cfg: DownloadCfg<'a>,
+    pub(super) cfg: &'a Cfg<'a>,
+    pub(super) toolchain: &'a ToolchainDesc,
+    profile: Profile,
+    pub(super) update_hash: PathBuf,
+    dl_cfg: DownloadCfg<'a>,
     /// --force bool is whether to force an update/install
-    pub(crate) force: bool,
+    force: bool,
     /// --allow-downgrade
-    pub(crate) allow_downgrade: bool,
+    pub(super) allow_downgrade: bool,
     /// toolchain already exists
-    pub(crate) exists: bool,
+    pub(super) exists: bool,
     /// currently installed date and version
-    pub(crate) old_date_version: Option<(String, String)>,
+    pub(super) old_date_version: Option<(String, String)>,
     /// Extra components to install from dist
-    pub(crate) components: &'a [&'a str],
+    components: &'a [&'a str],
     /// Extra targets to install from dist
-    pub(crate) targets: &'a [&'a str],
+    targets: &'a [&'a str],
 }
 
 impl<'a> DistOptions<'a> {
+    pub(super) fn new(
+        components: &'a [&'a str],
+        targets: &'a [&'a str],
+        toolchain: &'a ToolchainDesc,
+        profile: Profile,
+        force: bool,
+        cfg: &'a Cfg<'_>,
+    ) -> Result<Self> {
+        Ok(Self {
+            cfg,
+            toolchain,
+            profile,
+            update_hash: cfg.get_hash_file(toolchain, true)?,
+            dl_cfg: DownloadCfg::new(cfg),
+            force,
+            allow_downgrade: false,
+            exists: false,
+            old_date_version: None,
+            components,
+            targets,
+        })
+    }
+
     // Installs or updates a toolchain from a dist server. If an initial
     // install then it will be installed with the default components. If
     // an upgrade then all the existing components will be upgraded.
@@ -900,12 +924,12 @@ impl<'a> DistOptions<'a> {
     pub(crate) async fn install_into(&self, prefix: &InstallPrefix) -> 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
-        if fresh_install && Path::exists(self.update_hash) {
+        if fresh_install && self.update_hash.exists() {
             warn!(
                 "removing stray hash file in order to continue: {}",
                 self.update_hash.display()
             );
-            std::fs::remove_file(self.update_hash)?;
+            std::fs::remove_file(&self.update_hash)?;
         }
 
         let mut fetched = String::new();
@@ -1067,7 +1091,7 @@ impl<'a> DistOptions<'a> {
                 // So if components or targets is not empty, we skip passing `update_hash` so that
                 // we essentially degenerate to `rustup component add` / `rustup target add`
                 if self.components.is_empty() && self.targets.is_empty() {
-                    Some(self.update_hash)
+                    Some(&self.update_hash)
                 } else {
                     None
                 },

src/install.rs

@@ -107,7 +107,7 @@ impl InstallMethod<'_> {
                 let maybe_new_hash = opts.install_into(prefix).await?;
 
                 if let Some(hash) = maybe_new_hash {
-                    utils::write_file("update hash", opts.update_hash, &hash)?;
+                    utils::write_file("update hash", &opts.update_hash, &hash)?;
                     Ok(true)
                 } else {
                     Ok(false)

src/toolchain/distributable.rs

@@ -43,22 +43,8 @@ impl<'a> DistributableToolchain<'a> {
         profile: Profile,
         force: bool,
     ) -> anyhow::Result<(UpdateStatus, Self)> {
-        let hash_path = cfg.get_hash_file(toolchain, true)?;
-        let status = InstallMethod::Dist(DistOptions {
-            cfg,
-            toolchain,
-            profile,
-            update_hash: &hash_path,
-            dl_cfg: DownloadCfg::new(cfg),
-            force,
-            allow_downgrade: false,
-            exists: false,
-            old_date_version: None,
-            components,
-            targets,
-        })
-        .install()
-        .await?;
+        let options = DistOptions::new(components, targets, toolchain, profile, force, cfg)?;
+        let status = InstallMethod::Dist(options).install().await?;
         Ok((status, Self::new(cfg, toolchain.clone())?))
     }
 
@@ -385,7 +371,18 @@ impl<'a> DistributableToolchain<'a> {
         force: bool,
         allow_downgrade: bool,
     ) -> anyhow::Result<UpdateStatus> {
-        let old_date_version =
+        let mut options = DistOptions::new(
+            components,
+            targets,
+            &self.desc,
+            profile,
+            force,
+            self.toolchain.cfg,
+        )?;
+
+        options.allow_downgrade = allow_downgrade;
+        options.exists = true;
+        options.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.
@@ -400,23 +397,7 @@ impl<'a> DistributableToolchain<'a> {
                 })
                 .ok();
 
-        let cfg = self.toolchain.cfg;
-        let hash_path = cfg.get_hash_file(&self.desc, true)?;
-        InstallMethod::Dist(DistOptions {
-            cfg,
-            toolchain: &self.desc,
-            profile,
-            update_hash: &hash_path,
-            dl_cfg: DownloadCfg::new(cfg),
-            force,
-            allow_downgrade,
-            exists: true,
-            old_date_version,
-            components,
-            targets,
-        })
-        .install()
-        .await
+        InstallMethod::Dist(options).install().await
     }
 
     pub fn recursion_error(&self, binary_lossy: String) -> Result<Infallible, anyhow::Error> {