refactor(dist): rename *ToolchainName::resolve() to _::complete()

Author: rami3l

src/cli/proxy_mode.rs

@@ -38,7 +38,7 @@ pub async fn main(
     let (toolchain, source) = cfg
         .local_toolchain(match toolchain {
             Some(name) => Some((
-                name.resolve(&cfg)?.resolve(&cfg.default_host_tuple()?)?,
+                name.resolve(&cfg)?.complete(&cfg.default_host_tuple()?)?,
                 ActiveSource::CommandLine,
             )),
 

src/cli/rustup_mode.rs

@@ -940,7 +940,7 @@ async fn default_(
                 cfg.set_default(Some(&toolchain_name.into()))?;
             }
             MaybePartialToolchainName::Some(PartialToolchainName::Official(toolchain)) => {
-                let desc = toolchain.clone().resolve(&cfg.default_host_tuple()?)?;
+                let desc = toolchain.clone().complete(&cfg.default_host_tuple()?)?;
                 let status = cfg
                     .ensure_installed(&desc, vec![], vec![], None, force_non_host, true)
                     .await?
@@ -1136,15 +1136,15 @@ async fn update(
             // This needs another pass to fix it all up
             if !name.target.is_empty() {
                 let host_arch = TargetTuple::from_host_or_build(cfg.process);
-                let target_tuple = name.clone().resolve(&host_arch)?.target;
+                let target_tuple = name.clone().complete(&host_arch)?.target;
                 common::check_non_host_toolchain(
                     name.to_string(),
                     &host_arch,
                     &target_tuple,
                     force_non_host,
                 )?;
             }
-            let desc = name.clone().resolve(&cfg.default_host_tuple()?)?;
+            let desc = name.clone().complete(&cfg.default_host_tuple()?)?;
 
             let components = opts.component.iter().map(|s| &**s).collect::<Vec<_>>();
             let targets = opts.target.iter().map(|s| &**s).collect::<Vec<_>>();
@@ -1214,7 +1214,7 @@ async fn run(
     command: Vec<String>,
     install: bool,
 ) -> anyhow::Result<ExitStatus> {
-    let toolchain = toolchain.resolve(&cfg.default_host_tuple()?)?;
+    let toolchain = toolchain.complete(&cfg.default_host_tuple()?)?;
     let toolchain = Toolchain::from_local(toolchain, install, cfg).await?;
     let cmd = toolchain.command(&command[0])?;
     command::run_command_for_dir(cmd, &command[0], &command[1..])
@@ -1228,7 +1228,7 @@ async fn which(
     let (toolchain, _) = cfg
         .local_toolchain(match toolchain {
             Some(name) => Some((
-                name.resolve(&cfg.default_host_tuple()?)?.into(),
+                name.complete(&cfg.default_host_tuple()?)?.into(),
                 ActiveSource::CommandLine, // From --toolchain option
             )),
             None => None,
@@ -1664,7 +1664,7 @@ async fn toolchain_remove(cfg: &Cfg<'_>, opts: UninstallOpts) -> anyhow::Result<
         .map(|(it, _)| it);
 
     for toolchain_name in opts.toolchain {
-        let toolchain_name = toolchain_name.resolve(&cfg.default_host_tuple()?)?;
+        let toolchain_name = toolchain_name.complete(&cfg.default_host_tuple()?)?;
 
         if active_toolchain
             .as_ref()
@@ -1700,7 +1700,7 @@ fn pin_active_toolchain(qualified: bool, cfg: &Cfg<'_>) -> anyhow::Result<ExitCo
             let components = match &default {
                 PartialToolchainName::Official(desc) => {
                     let tc =
-                        DistributableToolchain::new(cfg, desc.clone().resolve(&default_host)?)?;
+                        DistributableToolchain::new(cfg, desc.clone().complete(&default_host)?)?;
                     let manifest = tc.get_manifest()?;
 
                     Some(
@@ -1760,7 +1760,7 @@ async fn override_add(
     let toolchain_name = toolchain
         .clone()
         .resolve(cfg)?
-        .resolve(&cfg.default_host_tuple()?)?;
+        .complete(&cfg.default_host_tuple()?)?;
     match Toolchain::new(cfg, toolchain_name.clone().into()) {
         Ok(_) => {}
         Err(e @ RustupError::ToolchainNotInstalled { .. }) => match &toolchain_name {

src/cli/self_update.rs

@@ -271,7 +271,7 @@ impl InstallOpts<'_> {
         let (components, targets) = (self.components, self.targets);
         let toolchain = self.select_toolchain(&mut cfg)?;
         if let Some(partial_desc) = toolchain {
-            let desc = partial_desc.clone().resolve(&cfg.default_host_tuple()?)?;
+            let desc = partial_desc.clone().complete(&cfg.default_host_tuple()?)?;
             let options =
                 DistOptions::new(components, targets, &desc, cfg.get_profile()?, true, &cfg)?;
             let status = if Toolchain::exists(&cfg, &desc.clone().into())? {
@@ -440,7 +440,7 @@ impl InstallOpts<'_> {
             }
             Some(MaybeOfficialToolchainName::Some(s)) => s.into(),
         };
-        let resolved = partial_channel.resolve(&host_tuple)?;
+        let resolved = partial_channel.complete(&host_tuple)?;
         trace!("Successfully resolved installation toolchain as: {resolved}");
         Ok(())
     }
@@ -697,7 +697,7 @@ fn check_existence_of_settings_file(process: &Process) -> anyhow::Result<()> {
     warn!("{}", settings_file.path.display());
     let default_host_tuple = settings_file.with(|s| Ok(default_host_tuple(s, process)))?;
     let inferred =
-        PartialOfficialToolchainName::from_str("stable")?.resolve(&default_host_tuple)?;
+        PartialOfficialToolchainName::from_str("stable")?.complete(&default_host_tuple)?;
     if default_toolchain != inferred.to_string() {
         warn!("rustup will install the default toolchain as specified in the settings file,");
         warn!("instead of the one inferred from the default host tuple.");

src/config.rs

@@ -253,7 +253,7 @@ impl OverrideCfg {
         Ok(match self {
             Self::PathBased(path_based_name) => path_based_name.into(),
             Self::Custom(custom_name) => custom_name.into(),
-            Self::Official { toolchain, .. } => toolchain.resolve(host_tuple)?.into(),
+            Self::Official { toolchain, .. } => toolchain.complete(host_tuple)?.into(),
         })
     }
 
@@ -412,7 +412,7 @@ impl<'a> Cfg<'a> {
         // Run some basic checks against the constructed configuration
         // For now, that means simply checking that 'stable' can resolve
         // for the current configuration.
-        PartialToolchainName::from_str("stable")?.resolve(
+        PartialToolchainName::from_str("stable")?.complete(
             &cfg.default_host_tuple()
                 .context("Unable parse configuration")?,
         )?;
@@ -589,7 +589,7 @@ impl<'a> Cfg<'a> {
             .map(|(desc, source)| {
                 anyhow::Ok((
                     ToolchainNameOrPath::Named(ToolchainName::Official(
-                        desc.resolve(&self.default_host_tuple()?)?,
+                        desc.complete(&self.default_host_tuple()?)?,
                     )),
                     source,
                 ))
@@ -766,7 +766,7 @@ impl<'a> Cfg<'a> {
                     }
 
                     // XXX: this awkwardness deals with settings file being locked already
-                    let toolchain_name = toolchain_name.resolve(&default_host)?;
+                    let toolchain_name = toolchain_name.complete(&default_host)?;
                     if !Toolchain::exists(self, &toolchain_name.clone().into())?
                         && matches!(toolchain_name, ToolchainName::Custom(_))
                     {
@@ -860,7 +860,7 @@ impl<'a> Cfg<'a> {
             } = override_config
             {
                 self.ensure_installed(
-                    &toolchain.resolve(&default_host)?,
+                    &toolchain.complete(&default_host)?,
                     components.unwrap_or_default(),
                     targets.unwrap_or_default(),
                     profile,
@@ -955,7 +955,7 @@ impl<'a> Cfg<'a> {
         let Some(toolchain) = self.get_default_resolvable()? else {
             return Ok(None);
         };
-        Ok(Some(toolchain.resolve(&self.default_host_tuple()?)?))
+        Ok(Some(toolchain.complete(&self.default_host_tuple()?)?))
     }
 
     /// Gets the configured default toolchain name in its unresolved form, if any.
@@ -1069,7 +1069,7 @@ impl<'a> Cfg<'a> {
         // against the 'stable' toolchain.  This provides early errors
         // if the supplied tuple is insufficient / bad.
         PartialOfficialToolchainName::from_str("stable")?
-            .resolve(&TargetTuple::new(host_tuple.clone()))?;
+            .complete(&TargetTuple::new(host_tuple.clone()))?;
         self.settings_file.with_mut(|s| {
             s.default_host_tuple = Some(host_tuple);
             Ok(())
@@ -1113,7 +1113,7 @@ impl<'a> Cfg<'a> {
 
         let default_host = self.default_host_tuple()?;
         let stable_desc =
-            PartialOfficialToolchainName::from_str("stable")?.resolve(&default_host)?;
+            PartialOfficialToolchainName::from_str("stable")?.complete(&default_host)?;
         let stable = match DistributableToolchain::new(self, stable_desc) {
             Ok(stable) => stable,
             // If the `stable` toolchain is not installed, we don't notify the user.

src/dist/mod.rs

@@ -207,7 +207,10 @@ pub struct PartialOfficialToolchainName {
 
 impl PartialOfficialToolchainName {
     /// Create a toolchain desc using input_host to fill in missing fields
-    pub(crate) fn resolve(self, input_host: &TargetTuple) -> anyhow::Result<OfficialToolchainName> {
+    pub(crate) fn complete(
+        self,
+        input_host: &TargetTuple,
+    ) -> anyhow::Result<OfficialToolchainName> {
         Ok(OfficialToolchainName {
             channel: self.channel,
             date: self.date,

src/toolchain.rs

@@ -378,7 +378,7 @@ impl<'a> Toolchain<'a> {
         // toolchains in principle.
         for fallback in ["nightly", "beta", "stable"] {
             let resolved =
-                PartialOfficialToolchainName::from_str(fallback)?.resolve(&default_host_tuple)?;
+                PartialOfficialToolchainName::from_str(fallback)?.complete(&default_host_tuple)?;
             if let Ok(fallback) = DistributableToolchain::new(self.cfg, resolved) {
                 let cmd = fallback.create_fallback_command("cargo", self)?;
                 return Ok(Some(cmd));

src/toolchain/names.rs

@@ -162,10 +162,10 @@ pub(crate) enum PartialToolchainName {
 
 impl PartialToolchainName {
     /// Resolve to a concrete toolchain name
-    pub fn resolve(self, host: &TargetTuple) -> Result<ToolchainName, anyhow::Error> {
+    pub fn complete(self, host: &TargetTuple) -> Result<ToolchainName, anyhow::Error> {
         Ok(match self {
             Self::Custom(c) => ToolchainName::Custom(c),
-            Self::Official(desc) => ToolchainName::Official(desc.resolve(host)?),
+            Self::Official(desc) => ToolchainName::Official(desc.complete(host)?),
         })
     }
 }
@@ -329,9 +329,9 @@ pub(crate) enum PartialToolchainNameOrPath {
 
 impl PartialToolchainNameOrPath {
     /// Resolve to a concrete toolchain name
-    pub fn resolve(&self, host: &TargetTuple) -> Result<ToolchainNameOrPath, anyhow::Error> {
+    pub fn complete(&self, host: &TargetTuple) -> Result<ToolchainNameOrPath, anyhow::Error> {
         match self.clone() {
-            Self::Named(t) => Ok(ToolchainNameOrPath::Named(t.resolve(host)?)),
+            Self::Named(t) => Ok(ToolchainNameOrPath::Named(t.complete(host)?)),
             Self::Path(t) => Ok(ToolchainNameOrPath::Path(t)),
         }
     }