refactor(custom-toolchains): unify target listing functions

Listing targets/components can now use the same function, both for
custom or distributable toolchains.

Author: FranciscoTGouveia

src/cli/common.rs

@@ -19,14 +19,12 @@ use super::self_update;
 use crate::{
     cli::download_tracker::DownloadTracker,
     config::Cfg,
-    dist::{
-        TargetTriple, ToolchainDesc, manifest::ComponentStatus, notifications as dist_notifications,
-    },
+    dist::{TargetTriple, ToolchainDesc, notifications as dist_notifications},
     errors::RustupError,
     install::UpdateStatus,
     notifications::Notification,
     process::{Process, terminalsource},
-    toolchain::{DistributableToolchain, LocalToolchainName, Toolchain, ToolchainName},
+    toolchain::{LocalToolchainName, Toolchain, ToolchainName},
     utils::{self, notifications as util_notifications, notify::NotificationLevel},
 };
 
@@ -381,70 +379,26 @@ where
 }
 
 pub(super) fn list_items(
-    distributable: DistributableToolchain<'_>,
-    f: impl Fn(&ComponentStatus) -> Option<&str>,
+    items: impl Iterator<Item = (String, bool)>,
     installed_only: bool,
     quiet: bool,
     process: &Process,
 ) -> Result<utils::ExitCode> {
     let mut t = process.stdout().terminal(process);
-    for component in distributable.components()? {
-        let Some(name) = f(&component) else { continue };
-        match (component.available, component.installed, installed_only) {
-            (false, _, _) | (_, false, true) => continue,
-            (true, true, false) if !quiet => {
+    for (name, installed) in items {
+        if !installed_only || installed {
+            if installed && !installed_only && !quiet {
                 t.attr(terminalsource::Attr::Bold)?;
                 writeln!(t.lock(), "{name} (installed)")?;
                 t.reset()?;
-            }
-            (true, _, false) | (_, true, true) => {
+            } else {
                 writeln!(t.lock(), "{name}")?;
             }
         }
     }
-
     Ok(utils::ExitCode(0))
 }
 
-pub(super) fn list_items_custom(
-    toolchain: Toolchain<'_>,
-    targets: bool,
-    installed_only: bool,
-    quiet: bool,
-    process: &Process,
-) -> Result<utils::ExitCode> {
-    let mut t = process.stdout().terminal(process);
-    let mut display_items = |items: Vec<String>| -> Result<utils::ExitCode> {
-        for item in items {
-            if !installed_only && !quiet {
-                t.attr(terminalsource::Attr::Bold)?;
-                writeln!(t.lock(), "{} (installed)", item)?;
-                t.reset()?;
-            } else {
-                writeln!(t.lock(), "{}", item)?;
-            }
-        }
-        Ok(utils::ExitCode(0))
-    };
-    if targets {
-        display_items(
-            toolchain
-                .installed_targets()?
-                .iter()
-                .map(|s| s.to_string())
-                .collect(),
-        )
-    } else {
-        display_items(
-            toolchain
-                .installed_components()?
-                .iter()
-                .map(|s| s.name().to_string())
-                .collect(),
-        )
-    }
-}
-
 pub(crate) async fn list_toolchains(
     cfg: &Cfg<'_>,
     verbose: bool,

src/cli/rustup_mode.rs

@@ -1175,22 +1175,31 @@ async fn target_list(
     // NB: this is decision is made based on the absence of a manifest in custom toolchains.
     if let Ok(distributable) = DistributableToolchain::from_partial(toolchain.clone(), cfg).await {
         common::list_items(
-            distributable,
-            |c| {
-                (c.component.short_name_in_manifest() == "rust-std").then(|| {
+            distributable.components()?.into_iter().filter_map(|c| {
+                if c.component.short_name_in_manifest() == "rust-std" && c.available {
                     c.component
                         .target
                         .as_deref()
-                        .expect("rust-std should have a target")
-                })
-            },
+                        .map(|target| (target.to_string(), c.installed))
+                } else {
+                    None
+                }
+            }),
             installed_only,
             quiet,
             cfg.process,
         )
     } else {
         let toolchain = cfg.toolchain_from_partial(toolchain).await?;
-        common::list_items_custom(toolchain, true, installed_only, quiet, cfg.process)
+        common::list_items(
+            toolchain
+                .installed_targets()?
+                .iter()
+                .map(|s| (s.to_string(), true)),
+            installed_only,
+            quiet,
+            cfg.process,
+        )
     }
 }
 
@@ -1288,15 +1297,28 @@ async fn component_list(
     // downcasting required because the toolchain files can name any toolchain
     if let Ok(distributable) = DistributableToolchain::from_partial(toolchain.clone(), cfg).await {
         common::list_items(
-            distributable,
-            |c| Some(&c.name),
+            distributable.components()?.into_iter().filter_map(|c| {
+                if c.available {
+                    Some((c.name, c.installed))
+                } else {
+                    None
+                }
+            }),
             installed_only,
             quiet,
             cfg.process,
         )
     } else {
         let toolchain = cfg.toolchain_from_partial(toolchain).await?;
-        common::list_items_custom(toolchain, false, installed_only, quiet, cfg.process)
+        common::list_items(
+            toolchain
+                .installed_components()?
+                .iter()
+                .map(|s| (s.name().to_string(), true)),
+            installed_only,
+            quiet,
+            cfg.process,
+        )
     }
 }