feat(install): flag to DistOptions and try_update_from_dist_

Author: cachebag

src/cli/common.rs

@@ -218,7 +218,7 @@ pub(crate) async fn update_all_channels(
     let profile = cfg.get_profile()?;
     let mut toolchains = Vec::new();
     for (desc, distributable) in cfg.list_channels()? {
-        let options = DistOptions::new(&[], &[], &desc, profile, force_update, cfg)?
+        let options = DistOptions::new(&[], &[], &desc, profile, force_update, false, cfg)?
             .for_update(&distributable, false);
         let result = InstallMethod::Dist(options).install().await;
 

src/cli/rustup_mode.rs

@@ -966,6 +966,7 @@ async fn update(
                 &desc,
                 cfg.get_profile()?,
                 opts.force,
+                false,
                 cfg,
             )?;
 
@@ -1516,7 +1517,8 @@ async fn override_add(
         Err(e @ RustupError::ToolchainNotInstalled { .. }) => match &toolchain_name {
             ToolchainName::Custom(_) => Err(e)?,
             ToolchainName::Official(desc) => {
-                let options = DistOptions::new(&[], &[], desc, cfg.get_profile()?, false, cfg)?;
+                let options =
+                    DistOptions::new(&[], &[], desc, cfg.get_profile()?, false, false, cfg)?;
                 let status = DistributableToolchain::install(options).await?.0;
                 writeln!(cfg.process.stdout().lock())?;
                 common::show_channel_update(

src/cli/self_update.rs

@@ -999,7 +999,15 @@ 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 options = DistOptions::new(
+            components,
+            targets,
+            desc,
+            cfg.get_profile()?,
+            true,
+            false,
+            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:

src/config.rs

@@ -56,6 +56,7 @@ struct ToolchainSection {
     components: Option<Vec<String>>,
     targets: Option<Vec<String>>,
     profile: Option<String>,
+    skip_std: Option<bool>,
 }
 
 impl ToolchainSection {
@@ -64,6 +65,7 @@ impl ToolchainSection {
             && self.components.is_none()
             && self.targets.is_none()
             && self.path.is_none()
+            && self.skip_std.is_none()
     }
 }
 
@@ -180,16 +182,18 @@ impl OverrideCfg {
             ToolchainName::Official(desc) => {
                 let components = file.toolchain.components.unwrap_or_default();
                 let targets = file.toolchain.targets.unwrap_or_default();
+                let profile = file
+                    .toolchain
+                    .profile
+                    .as_deref()
+                    .map(Profile::from_str)
+                    .transpose()?;
+
                 Self::Official {
                     toolchain: desc,
                     components,
                     targets,
-                    profile: file
-                        .toolchain
-                        .profile
-                        .as_deref()
-                        .map(Profile::from_str)
-                        .transpose()?,
+                    profile,
                 }
             }
             ToolchainName::Custom(name) => Self::Custom(name),
@@ -798,6 +802,7 @@ impl<'a> Cfg<'a> {
                 None => self.get_profile()?,
             },
             false,
+            false,
             self,
         )?;
 
@@ -1030,6 +1035,7 @@ mod tests {
                     components: None,
                     targets: None,
                     profile: None,
+                    skip_std,
                 }
             }
         );

src/dist/mod.rs

@@ -900,6 +900,8 @@ pub(crate) struct DistOptions<'cfg, 'a> {
     components: &'a [&'a str],
     /// Extra targets to install from dist
     targets: &'a [&'a str],
+    /// Flag to skip installation of rust-std
+    pub(super) skip_std: bool,
 }
 
 impl<'cfg, 'a> DistOptions<'cfg, 'a> {
@@ -909,6 +911,7 @@ impl<'cfg, 'a> DistOptions<'cfg, 'a> {
         toolchain: &'a ToolchainDesc,
         profile: Profile,
         force: bool,
+        skip_std: bool,
         cfg: &'cfg Cfg<'cfg>,
     ) -> Result<Self> {
         Ok(Self {
@@ -923,6 +926,7 @@ impl<'cfg, 'a> DistOptions<'cfg, 'a> {
             old_date_version: None,
             components,
             targets,
+            skip_std,
         })
     }
 
@@ -1034,6 +1038,7 @@ pub(crate) async fn update_from_dist(
             opts.targets,
             &mut fetched,
             opts.cfg,
+            opts.skip_std,
         )
         .await;
 
@@ -1131,6 +1136,7 @@ async fn try_update_from_dist_(
     targets: &[&str],
     fetched: &mut String,
     cfg: &Cfg<'_>,
+    skip_std: bool,
 ) -> Result<Option<String>> {
     let toolchain_str = toolchain.to_string();
     let manifestation = Manifestation::open(prefix.clone(), toolchain.target.clone())?;
@@ -1165,6 +1171,10 @@ async fn try_update_from_dist_(
 
             let mut all_components: HashSet<Component> = profile_components.into_iter().collect();
 
+            if skip_std {
+                all_components.retain(|c| !c.short_name_in_manifest().starts_with("rust-std"));
+            }
+
             let rust_package = m.get_package("rust")?;
             let rust_target_package = rust_package.get_target(Some(&toolchain.target.clone()))?;
 
@@ -1188,9 +1198,15 @@ async fn try_update_from_dist_(
                 all_components.insert(component);
             }
 
-            for &target in targets {
-                let triple = TargetTriple::new(target);
-                all_components.insert(Component::new("rust-std".to_string(), Some(triple), false));
+            if !skip_std {
+                for &target in targets {
+                    let triple = TargetTriple::new(target);
+                    all_components.insert(Component::new(
+                        "rust-std".to_string(),
+                        Some(triple),
+                        false,
+                    ));
+                }
             }
 
             let mut explicit_add_components: Vec<_> = all_components.into_iter().collect();

src/toolchain.rs

@@ -61,7 +61,8 @@ impl<'a> Toolchain<'a> {
                 name: ToolchainName::Official(desc),
                 ..
             }) if install_if_missing => {
-                let options = DistOptions::new(&[], &[], &desc, cfg.get_profile()?, true, cfg)?;
+                let options =
+                    DistOptions::new(&[], &[], &desc, cfg.get_profile()?, true, false, cfg)?;
                 Ok(DistributableToolchain::install(options).await?.1.toolchain)
             }
             Err(e) => Err(e.into()),