fix(install): force-skip behavior for rust-std - #4442

cachebag · cachebag · commit 0eb6b73a4121 · 2025-11-03T17:12:16.000-05:00
diff --git a/src/cli/rustup_mode.rs b/src/cli/rustup_mode.rs
@@ -775,7 +775,7 @@ async fn default_(
             MaybeResolvableToolchainName::Some(ResolvableToolchainName::Official(toolchain)) => {
                 let desc = toolchain.resolve(&cfg.get_default_host_triple()?)?;
                 let status = cfg
-                    .ensure_installed(&desc, vec![], vec![], None, force_non_host, true)
+                    .ensure_installed(&desc, vec![], vec![], None, false, force_non_host, true)
                     .await?
                     .0;
 
@@ -977,6 +977,7 @@ async fn update(
                         &targets,
                         profile,
                         force,
+                        false,
                     )
                     .await?
                     .0
@@ -1519,10 +1520,17 @@ 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 status = DistributableToolchain::install(
+                    cfg,
+                    desc,
+                    &[],
+                    &[],
+                    cfg.get_profile()?,
+                    false,
+                    false,
+                )
+                .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
@@ -1015,6 +1015,7 @@ async fn maybe_install_rust(opts: InstallOpts<'_>, cfg: &mut Cfg<'_>) -> Result<
                 targets,
                 cfg.get_profile()?,
                 true,
+                false,
             )
             .await?
             .0
diff --git a/src/config.rs b/src/config.rs
@@ -55,6 +55,7 @@ struct ToolchainSection {
     components: Option<Vec<String>>,
     targets: Option<Vec<String>>,
     profile: Option<String>,
+    skip_std: Option<bool>,
 }
 
 impl ToolchainSection {
@@ -63,6 +64,8 @@ impl ToolchainSection {
             && self.components.is_none()
             && self.targets.is_none()
             && self.path.is_none()
+            && self.profile.is_none()
+            && self.skip_std.is_none()
     }
 }
 
@@ -136,6 +139,7 @@ enum OverrideCfg {
         components: Vec<String>,
         targets: Vec<String>,
         profile: Option<Profile>,
+        skip_std: bool,
     },
 }
 
@@ -189,6 +193,7 @@ impl OverrideCfg {
                         .as_deref()
                         .map(Profile::from_str)
                         .transpose()?,
+                    skip_std: file.toolchain.skip_std.unwrap_or(false),
                 }
             }
             ToolchainName::Custom(name) => Self::Custom(name),
@@ -212,6 +217,7 @@ impl From<ToolchainName> for OverrideCfg {
                 components: vec![],
                 targets: vec![],
                 profile: None,
+                skip_std: false,
             },
             ToolchainName::Custom(name) => Self::Custom(name),
         }
@@ -736,13 +742,15 @@ impl<'a> Cfg<'a> {
                 components,
                 targets,
                 profile,
+                skip_std,
             } = override_config
             {
                 self.ensure_installed(
                     &toolchain,
                     components,
                     targets,
                     profile,
+                    skip_std,
                     force_non_host,
                     verbose,
                 )
@@ -754,7 +762,7 @@ impl<'a> Cfg<'a> {
         } else if let Some(toolchain) = self.get_default()? {
             let source = ActiveSource::Default;
             if let ToolchainName::Official(desc) = &toolchain {
-                self.ensure_installed(desc, vec![], vec![], None, force_non_host, verbose)
+                self.ensure_installed(desc, vec![], vec![], None, false, force_non_host, verbose)
                     .await?;
             } else {
                 Toolchain::with_source(self, toolchain.clone().into(), &source)?;
@@ -774,6 +782,7 @@ impl<'a> Cfg<'a> {
         components: Vec<String>,
         targets: Vec<String>,
         profile: Option<Profile>,
+        skip_std: bool,
         force_non_host: bool,
         verbose: bool,
     ) -> Result<(UpdateStatus, Toolchain<'_>)> {
@@ -801,6 +810,7 @@ impl<'a> Cfg<'a> {
                     &targets,
                     profile,
                     false,
+                    skip_std,
                 )
                 .await?
             }
@@ -1048,6 +1058,7 @@ mod tests {
                     components: None,
                     targets: None,
                     profile: None,
+                    skip_std: None,
                 }
             }
         );
@@ -1075,6 +1086,7 @@ profile = "default"
                         "thumbv2-none-eabi".into()
                     ]),
                     profile: Some("default".into()),
+                    skip_std: None,
                 }
             }
         );
@@ -1096,6 +1108,7 @@ channel = "nightly-2020-07-10"
                     components: None,
                     targets: None,
                     profile: None,
+                    skip_std: None,
                 }
             }
         );
@@ -1117,6 +1130,7 @@ path = "foobar"
                     components: None,
                     targets: None,
                     profile: None,
+                    skip_std: None,
                 }
             }
         );
@@ -1139,6 +1153,7 @@ components = []
                     components: Some(vec![]),
                     targets: None,
                     profile: None,
+                    skip_std: None,
                 }
             }
         );
@@ -1161,6 +1176,7 @@ targets = []
                     components: None,
                     targets: Some(vec![]),
                     profile: None,
+                    skip_std: None,
                 }
             }
         );
@@ -1182,6 +1198,7 @@ components = [ "rustfmt" ]
                     components: Some(vec!["rustfmt".into()]),
                     targets: None,
                     profile: None,
+                    skip_std: None,
                 }
             }
         );
diff --git a/src/dist/mod.rs b/src/dist/mod.rs
@@ -905,6 +905,7 @@ pub(crate) struct DistOptions<'a> {
 pub(crate) async fn update_from_dist(
     prefix: &InstallPrefix,
     opts: &DistOptions<'_>,
+    skip_std: bool,
 ) -> Result<Option<String>> {
     let fresh_install = !prefix.path().exists();
     if let Some(hash) = opts.update_hash {
@@ -980,6 +981,7 @@ pub(crate) async fn update_from_dist(
             opts.targets,
             &mut fetched,
             &opts.cfg.dist_root_url,
+            skip_std,
         )
         .await;
 
@@ -1077,6 +1079,7 @@ async fn try_update_from_dist_(
     targets: &[&str],
     fetched: &mut String,
     dist_root: &str,
+    skip_std: bool,
 ) -> Result<Option<String>> {
     let toolchain_str = toolchain.to_string();
     let manifestation = Manifestation::open(prefix.clone(), toolchain.target.clone())?;
@@ -1134,9 +1137,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();
diff --git a/src/install.rs b/src/install.rs
@@ -31,7 +31,7 @@ pub(crate) enum InstallMethod<'a> {
         dest: &'a CustomToolchainName,
         cfg: &'a Cfg<'a>,
     },
-    Dist(DistOptions<'a>),
+    Dist(DistOptions<'a>, bool),
 }
 
 impl InstallMethod<'_> {
@@ -46,10 +46,13 @@ impl InstallMethod<'_> {
         match self {
             InstallMethod::Copy { .. }
             | InstallMethod::Link { .. }
-            | InstallMethod::Dist(DistOptions {
-                old_date_version: None,
-                ..
-            }) => debug!("installing toolchain {}", self.dest_basename()),
+            | InstallMethod::Dist(
+                DistOptions {
+                    old_date_version: None,
+                    ..
+                },
+                _,
+            ) => debug!("installing toolchain {}", self.dest_basename()),
             _ => debug!("updating existing install for '{}'", self.dest_basename()),
         }
 
@@ -64,10 +67,13 @@ impl InstallMethod<'_> {
             true => {
                 debug!("toolchain {} installed", self.dest_basename());
                 match self {
-                    InstallMethod::Dist(DistOptions {
-                        old_date_version: Some((_, v)),
-                        ..
-                    }) => UpdateStatus::Updated(v.clone()),
+                    InstallMethod::Dist(
+                        DistOptions {
+                            old_date_version: Some((_, v)),
+                            ..
+                        },
+                        _,
+                    ) => UpdateStatus::Updated(v.clone()),
                     InstallMethod::Copy { .. }
                     | InstallMethod::Link { .. }
                     | InstallMethod::Dist { .. } => UpdateStatus::Installed,
@@ -102,9 +108,9 @@ impl InstallMethod<'_> {
                 utils::symlink_dir(src, path)?;
                 Ok(true)
             }
-            InstallMethod::Dist(opts) => {
+            InstallMethod::Dist(opts, skip_std) => {
                 let prefix = &InstallPrefix::from(path.to_owned());
-                let maybe_new_hash = dist::update_from_dist(prefix, opts).await?;
+                let maybe_new_hash = dist::update_from_dist(prefix, opts, *skip_std).await?;
 
                 if let Some(hash) = maybe_new_hash {
                     if let Some(hash_file) = opts.update_hash {
@@ -123,17 +129,20 @@ impl InstallMethod<'_> {
         match self {
             InstallMethod::Copy { cfg, .. } => cfg,
             InstallMethod::Link { cfg, .. } => cfg,
-            InstallMethod::Dist(DistOptions { cfg, .. }) => cfg,
+            InstallMethod::Dist(DistOptions { cfg, .. }, _) => cfg,
         }
     }
 
     fn local_name(&self) -> LocalToolchainName {
         match self {
             InstallMethod::Copy { dest, .. } => (*dest).into(),
             InstallMethod::Link { dest, .. } => (*dest).into(),
-            InstallMethod::Dist(DistOptions {
-                toolchain: desc, ..
-            }) => (*desc).into(),
+            InstallMethod::Dist(
+                DistOptions {
+                    toolchain: desc, ..
+                },
+                _,
+            ) => (*desc).into(),
         }
     }
 
@@ -145,11 +154,14 @@ impl InstallMethod<'_> {
         match self {
             InstallMethod::Copy { cfg, dest, .. } => cfg.toolchain_path(&(*dest).into()),
             InstallMethod::Link { cfg, dest, .. } => cfg.toolchain_path(&(*dest).into()),
-            InstallMethod::Dist(DistOptions {
-                cfg,
-                toolchain: desc,
-                ..
-            }) => cfg.toolchain_path(&(*desc).into()),
+            InstallMethod::Dist(
+                DistOptions {
+                    cfg,
+                    toolchain: desc,
+                    ..
+                },
+                _,
+            ) => cfg.toolchain_path(&(*desc).into()),
         }
     }
 }
diff --git a/src/toolchain.rs b/src/toolchain.rs
@@ -60,14 +60,18 @@ impl<'a> Toolchain<'a> {
             Err(RustupError::ToolchainNotInstalled {
                 name: ToolchainName::Official(desc),
                 ..
-            }) if install_if_missing => {
-                Ok(
-                    DistributableToolchain::install(cfg, &desc, &[], &[], cfg.get_profile()?, true)
-                        .await?
-                        .1
-                        .toolchain,
-                )
-            }
+            }) if install_if_missing => Ok(DistributableToolchain::install(
+                cfg,
+                &desc,
+                &[],
+                &[],
+                cfg.get_profile()?,
+                true,
+                false,
+            )
+            .await?
+            .1
+            .toolchain),
             Err(e) => Err(e.into()),
         }
     }
diff --git a/src/toolchain/distributable.rs b/src/toolchain/distributable.rs

Original file line number	Diff line number	Diff line change
`@@ -1015,6 +1015,7 @@ async fn maybe_install_rust(opts: InstallOpts<'_>, cfg: &mut Cfg<'_>) -> Result<`
`1015`	`1015`	`targets,`
`1016`	`1016`	`cfg.get_profile()?,`
`1017`	`1017`	`true,`
	`1018`	`+ false,`
`1018`	`1019`	`)`
`1019`	`1020`	`.await?`
`1020`	`1021`	`.0`
Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,7 @@ struct ToolchainSection {`
`55`	`55`	`components: Option<Vec<String>>,`
`56`	`56`	`targets: Option<Vec<String>>,`
`57`	`57`	`profile: Option<String>,`
	`58`	`+ skip_std: Option<bool>,`
`58`	`59`	`}`
`59`	`60`
`60`	`61`	`impl ToolchainSection {`
`@@ -63,6 +64,8 @@ impl ToolchainSection {`
`63`	`64`	`&& self.components.is_none()`
`64`	`65`	`&& self.targets.is_none()`
`65`	`66`	`&& self.path.is_none()`
	`67`	`+ && self.profile.is_none()`
	`68`	`+ && self.skip_std.is_none()`
`66`	`69`	`}`
`67`	`70`	`}`
`68`	`71`
`@@ -136,6 +139,7 @@ enum OverrideCfg {`
`136`	`139`	`components: Vec<String>,`
`137`	`140`	`targets: Vec<String>,`
`138`	`141`	`profile: Option<Profile>,`
	`142`	`+ skip_std: bool,`
`139`	`143`	`},`
`140`	`144`	`}`
`141`	`145`
`@@ -189,6 +193,7 @@ impl OverrideCfg {`
`189`	`193`	`.as_deref()`
`190`	`194`	`.map(Profile::from_str)`
`191`	`195`	`.transpose()?,`
	`196`	`+ skip_std: file.toolchain.skip_std.unwrap_or(false),`
`192`	`197`	`}`
`193`	`198`	`}`
`194`	`199`	`ToolchainName::Custom(name) => Self::Custom(name),`
`@@ -212,6 +217,7 @@ impl From<ToolchainName> for OverrideCfg {`
`212`	`217`	`components: vec![],`
`213`	`218`	`targets: vec![],`
`214`	`219`	`profile: None,`
	`220`	`+ skip_std: false,`
`215`	`221`	`},`
`216`	`222`	`ToolchainName::Custom(name) => Self::Custom(name),`
`217`	`223`	`}`
`@@ -736,13 +742,15 @@ impl<'a> Cfg<'a> {`
`736`	`742`	`components,`
`737`	`743`	`targets,`
`738`	`744`	`profile,`
	`745`	`+ skip_std,`
`739`	`746`	`} = override_config`
`740`	`747`	`{`
`741`	`748`	`self.ensure_installed(`
`742`	`749`	`&toolchain,`
`743`	`750`	`components,`
`744`	`751`	`targets,`
`745`	`752`	`profile,`
	`753`	`+ skip_std,`
`746`	`754`	`force_non_host,`
`747`	`755`	`verbose,`
`748`	`756`	`)`
`@@ -754,7 +762,7 @@ impl<'a> Cfg<'a> {`
`754`	`762`	`} else if let Some(toolchain) = self.get_default()? {`
`755`	`763`	`let source = ActiveSource::Default;`
`756`	`764`	`if let ToolchainName::Official(desc) = &toolchain {`
`757`		`- self.ensure_installed(desc, vec![], vec![], None, force_non_host, verbose)`
	`765`	`+ self.ensure_installed(desc, vec![], vec![], None, false, force_non_host, verbose)`
`758`	`766`	`.await?;`
`759`	`767`	`} else {`
`760`	`768`	`Toolchain::with_source(self, toolchain.clone().into(), &source)?;`
`@@ -774,6 +782,7 @@ impl<'a> Cfg<'a> {`
`774`	`782`	`components: Vec<String>,`
`775`	`783`	`targets: Vec<String>,`
`776`	`784`	`profile: Option<Profile>,`
	`785`	`+ skip_std: bool,`
`777`	`786`	`force_non_host: bool,`
`778`	`787`	`verbose: bool,`
`779`	`788`	`) -> Result<(UpdateStatus, Toolchain<'_>)> {`
`@@ -801,6 +810,7 @@ impl<'a> Cfg<'a> {`
`801`	`810`	`&targets,`
`802`	`811`	`profile,`
`803`	`812`	`false,`
	`813`	`+ skip_std,`
`804`	`814`	`)`
`805`	`815`	`.await?`
`806`	`816`	`}`
`@@ -1048,6 +1058,7 @@ mod tests {`
`1048`	`1058`	`components: None,`
`1049`	`1059`	`targets: None,`
`1050`	`1060`	`profile: None,`
	`1061`	`+ skip_std: None,`
`1051`	`1062`	`}`
`1052`	`1063`	`}`
`1053`	`1064`	`);`
`@@ -1075,6 +1086,7 @@ profile = "default"`
`1075`	`1086`	`"thumbv2-none-eabi".into()`
`1076`	`1087`	`]),`
`1077`	`1088`	`profile: Some("default".into()),`
	`1089`	`+ skip_std: None,`
`1078`	`1090`	`}`
`1079`	`1091`	`}`
`1080`	`1092`	`);`
`@@ -1096,6 +1108,7 @@ channel = "nightly-2020-07-10"`
`1096`	`1108`	`components: None,`
`1097`	`1109`	`targets: None,`
`1098`	`1110`	`profile: None,`
	`1111`	`+ skip_std: None,`
`1099`	`1112`	`}`
`1100`	`1113`	`}`
`1101`	`1114`	`);`
`@@ -1117,6 +1130,7 @@ path = "foobar"`
`1117`	`1130`	`components: None,`
`1118`	`1131`	`targets: None,`
`1119`	`1132`	`profile: None,`
	`1133`	`+ skip_std: None,`
`1120`	`1134`	`}`
`1121`	`1135`	`}`
`1122`	`1136`	`);`
`@@ -1139,6 +1153,7 @@ components = []`
`1139`	`1153`	`components: Some(vec![]),`
`1140`	`1154`	`targets: None,`
`1141`	`1155`	`profile: None,`
	`1156`	`+ skip_std: None,`
`1142`	`1157`	`}`
`1143`	`1158`	`}`
`1144`	`1159`	`);`
`@@ -1161,6 +1176,7 @@ targets = []`
`1161`	`1176`	`components: None,`
`1162`	`1177`	`targets: Some(vec![]),`
`1163`	`1178`	`profile: None,`
	`1179`	`+ skip_std: None,`
`1164`	`1180`	`}`
`1165`	`1181`	`}`
`1166`	`1182`	`);`
`@@ -1182,6 +1198,7 @@ components = [ "rustfmt" ]`
`1182`	`1198`	`components: Some(vec!["rustfmt".into()]),`
`1183`	`1199`	`targets: None,`
`1184`	`1200`	`profile: None,`
	`1201`	`+ skip_std: None,`
`1185`	`1202`	`}`
`1186`	`1203`	`}`
`1187`	`1204`	`);`