fix(dist): bulk rename triple to tuple for variables and messages

Author: motorailgun

src/cli/rustup_mode.rs

@@ -982,13 +982,13 @@ async fn update(
     if !names.is_empty() {
         for name in names {
             // This needs another pass to fix it all up
-            if name.has_triple() {
+            if name.has_tuple() {
                 let host_arch = TargetTuple::from_host_or_build(cfg.process);
-                let target_triple = name.clone().resolve(&host_arch)?.target;
+                let target_tuple = name.clone().resolve(&host_arch)?.target;
                 common::check_non_host_toolchain(
                     name.to_string(),
                     &host_arch,
-                    &target_triple,
+                    &target_tuple,
                     force_non_host,
                 )?;
             }

src/config.rs

@@ -636,7 +636,7 @@ impl<'a> Cfg<'a> {
                     // Do not permit architecture/os selection in channels as
                     // these are host specific and toolchain files are portable.
                     if let ResolvableToolchainName::Official(name) = &toolchain_name
-                        && name.has_triple()
+                        && name.has_tuple()
                     {
                         // Permit fully qualified names IFF the toolchain is installed. TODO(robertc): consider
                         // disabling this and backing out https://github.com/rust-lang/rustup/pull/2141 (but provide

src/dist/manifestation.rs

@@ -42,7 +42,7 @@ pub(crate) const CONFIG_FILE: &str = "multirust-config.toml";
 #[derive(Debug)]
 pub struct Manifestation {
     installation: Components,
-    target_triple: TargetTuple,
+    target_tuple: TargetTuple,
 }
 
 #[derive(Debug)]
@@ -87,12 +87,12 @@ impl Manifestation {
     /// it will be created as needed. If there's an existing install
     /// then the rust-install installation format will be verified. A
     /// bad installer version is the only reason this will fail.
-    pub fn open(prefix: InstallPrefix, triple: TargetTuple) -> Result<Self> {
-        // TODO: validate the triple with the existing install as well
+    pub fn open(prefix: InstallPrefix, target_tuple: TargetTuple) -> Result<Self> {
+        // TODO: validate the tuple with the existing install as well
         // as the metadata format of the existing install
         Ok(Self {
             installation: Components::open(prefix)?,
-            target_triple: triple,
+            target_tuple,
         })
     }
 
@@ -146,7 +146,7 @@ impl Manifestation {
             {
                 for component in &components {
                     match &component.target {
-                        Some(t) if t != &self.target_triple => warn!(
+                        Some(t) if t != &self.target_tuple => warn!(
                             "skipping unavailable component {} for target {}",
                             new_manifest.short_name(component),
                             t
@@ -215,14 +215,14 @@ impl Manifestation {
         // Uninstall components
         for component in update.components_to_uninstall {
             match (implicit_modify, &component.target) {
-                (true, Some(t)) if t != &self.target_triple => {
+                (true, Some(t)) if t != &self.target_tuple => {
                     info!(
                         "removing previous version of component {} for target {}",
                         new_manifest.short_name(&component),
                         t
                     );
                 }
-                (false, Some(t)) if t != &self.target_triple => {
+                (false, Some(t)) if t != &self.target_tuple => {
                     info!(
                         "removing component {} for target {}",
                         new_manifest.short_name(&component),
@@ -416,11 +416,11 @@ impl Manifestation {
 
         let url = new_manifest
             .iter()
-            .find(|u| u.contains(&format!("{}{}", self.target_triple, ".tar.gz")));
+            .find(|u| u.contains(&format!("{}{}", self.target_tuple, ".tar.gz")));
         if url.is_none() {
             return Err(anyhow!(
                 "binary package was not provided for '{}'",
-                self.target_triple,
+                self.target_tuple,
             ));
         }
         // Only replace once. The cost is inexpensive.
@@ -595,7 +595,7 @@ impl Update {
     ) -> Result<Self> {
         // The package to install.
         let rust_package = new_manifest.get_package("rust")?;
-        let rust_target_package = rust_package.get_target(Some(&manifestation.target_triple))?;
+        let rust_target_package = rust_package.get_target(Some(&manifestation.target_tuple))?;
 
         changes.check_invariants(config)?;
 
@@ -609,7 +609,7 @@ impl Update {
         let looks_like_v1 = config.is_none() && !installed_components.is_empty();
         if looks_like_v1 {
             let mut profile_components = new_manifest
-                .get_profile_components(Profile::Default, &manifestation.target_triple)?;
+                .get_profile_components(Profile::Default, &manifestation.target_tuple)?;
             starting_list.append(&mut profile_components);
         }
 
@@ -689,7 +689,7 @@ impl Update {
                     result.components_to_install.push(component.clone());
                 } else if changes.explicit_add_components.contains(component) {
                     match &component.target {
-                        Some(t) if t != &manifestation.target_triple => info!(
+                        Some(t) if t != &manifestation.target_tuple => info!(
                             "component {} for target {} is up to date",
                             new_manifest.short_name(component),
                             t,

src/dist/mod.rs

@@ -481,8 +481,8 @@ impl TargetTuple {
 
             // Default to msvc
             let arch = arch_primary().or_else(arch_fallback)?;
-            let msvc_triple = format!("{arch}-pc-windows-msvc");
-            Some(TargetTuple(msvc_triple))
+            let msvc_tuple = format!("{arch}-pc-windows-msvc");
+            Some(TargetTuple(msvc_tuple))
         }
 
         #[cfg(not(windows))]
@@ -504,7 +504,7 @@ impl TargetTuple {
             };
 
             #[cfg(not(target_os = "android"))]
-            let host_triple = match (sysname, machine) {
+            let host_tuple = match (sysname, machine) {
                 (b"Linux", b"x86_64") => Some(TRIPLE_X86_64_UNKNOWN_LINUX),
                 (b"Linux", b"i686") => Some("i686-unknown-linux-gnu"),
                 (b"Linux", b"mips") => Some(TRIPLE_MIPS_UNKNOWN_LINUX_GNU),
@@ -538,7 +538,7 @@ impl TargetTuple {
             };
 
             #[cfg(target_os = "android")]
-            let host_triple = match (sysname, machine) {
+            let host_tuple = match (sysname, machine) {
                 (_, b"arm") => Some("arm-linux-androideabi"),
                 (_, b"armv7l") => Some("armv7-linux-androideabi"),
                 (_, b"armv8l") => Some("armv7-linux-androideabi"),
@@ -548,7 +548,7 @@ impl TargetTuple {
                 _ => None,
             };
 
-            host_triple.map(TargetTuple::new)
+            host_tuple.map(TargetTuple::new)
         }
 
         if let Ok(tuple) = process.var("RUSTUP_OVERRIDE_HOST_TUPLE") {
@@ -614,7 +614,7 @@ impl PartialToolchainDesc {
     pub(crate) fn resolve(self, input_host: &TargetTuple) -> Result<ToolchainDesc> {
         let host = PartialTargetTuple::new(&input_host.0).ok_or_else(|| {
             anyhow!(format!(
-                "Provided host '{}' couldn't be converted to partial triple",
+                "Provided host '{}' couldn't be converted to partial tuple",
                 input_host.0
             ))
         })?;
@@ -655,7 +655,7 @@ impl PartialToolchainDesc {
         })
     }
 
-    pub(crate) fn has_triple(&self) -> bool {
+    pub(crate) fn has_tuple(&self) -> bool {
         self.target.arch.is_some() || self.target.os.is_some() || self.target.env.is_some()
     }
 }
@@ -1195,8 +1195,8 @@ async fn try_update_from_dist_(
             }
 
             for &target in targets {
-                let triple = TargetTuple::new(target);
-                all_components.insert(Component::new("rust-std".to_string(), Some(triple), false));
+                let tuple = TargetTuple::new(target);
+                all_components.insert(Component::new("rust-std".to_string(), Some(tuple), false));
             }
 
             let mut explicit_add_components: Vec<_> = all_components.into_iter().collect();
@@ -1457,7 +1457,7 @@ mod tests {
     }
 
     #[test]
-    fn compatible_host_triples() {
+    fn compatible_host_tuples() {
         static CASES: &[(&str, &[&str], &[&str])] = &[
             (
                 // 64bit linux

tests/suite/cli_rustup.rs

@@ -1599,21 +1599,21 @@ Default host: [HOST_TUPLE]
 
 // #846
 #[tokio::test]
-async fn set_default_host_invalid_triple() {
+async fn set_default_host_invalid_tuple() {
     let cx = CliTestContext::new(Scenario::None).await;
     cx.config
         .expect(["rustup", "set", "default-host", "foo"])
         .await
         .with_stderr(snapbox::str![[r#"
-error: Provided host 'foo' couldn't be converted to partial triple
+error: Provided host 'foo' couldn't be converted to partial tuple
 
 "#]])
         .is_err();
 }
 
 // #745
 #[tokio::test]
-async fn set_default_host_invalid_triple_valid_partial() {
+async fn set_default_host_invalid_tuple_valid_partial() {
     let cx = CliTestContext::new(Scenario::None).await;
     cx.config
         .expect(["rustup", "set", "default-host", "x86_64-msvc"])