feat(custom-toolchains): target and component list working on custom toolchains

As we cannot assume the existence of a manifest for custom toolchains,
we can only report the installed components/targets.
Thus, running `rustup target list` or `rustup target list --installed`,
will yield the same result.

The `list_items()` function was also refactored so that both custom and
distributable toolchains can make use of it.

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},
 };
 
@@ -380,29 +378,26 @@ where
     Ok(utils::ExitCode(0))
 }
 
+/// Iterates over pairs representing the name of a target or component and a
+/// boolean value indicating whether it is installed or not.
+/// The boolean value is needed to determine whether to print "(installed)"
+/// next to the target/component name."
 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 => {
-                t.attr(terminalsource::Attr::Bold)?;
-                writeln!(t.lock(), "{name} (installed)")?;
-                t.reset()?;
-            }
-            (true, _, false) | (_, true, true) => {
-                writeln!(t.lock(), "{name}")?;
-            }
+    for (name, installed) in items {
+        if installed && !installed_only && !quiet {
+            t.attr(terminalsource::Attr::Bold)?;
+            writeln!(t.lock(), "{name} (installed)")?;
+            t.reset()?;
+        } else if installed || !installed_only {
+            writeln!(t.lock(), "{name}")?;
         }
     }
-
     Ok(utils::ExitCode(0))
 }
 

src/cli/rustup_mode.rs

@@ -1170,22 +1170,37 @@ async fn target_list(
     installed_only: bool,
     quiet: bool,
 ) -> Result<utils::ExitCode> {
-    // downcasting required because the toolchain files can name any toolchain
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
-    common::list_items(
-        distributable,
-        |c| {
-            (c.component.short_name_in_manifest() == "rust-std").then(|| {
-                c.component
-                    .target
-                    .as_deref()
-                    .expect("rust-std should have a target")
-            })
-        },
-        installed_only,
-        quiet,
-        cfg.process,
-    )
+    // If a toolchain is Distributable, we can assume it has a manifest and thus print all possible targets and the installed ones.
+    // However, if it is a custom toolchain, we can only print the installed targets.
+    // NB: this 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.components()?.into_iter().filter_map(|c| {
+                if c.component.short_name_in_manifest() == "rust-std" && c.available {
+                    c.component
+                        .target
+                        .as_deref()
+                        .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(
+            toolchain
+                .installed_targets()?
+                .iter()
+                .map(|s| (s.to_string(), true)),
+            installed_only,
+            quiet,
+            cfg.process,
+        )
+    }
 }
 
 async fn target_add(
@@ -1280,14 +1295,31 @@ async fn component_list(
     quiet: bool,
 ) -> Result<utils::ExitCode> {
     // downcasting required because the toolchain files can name any toolchain
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
-    common::list_items(
-        distributable,
-        |c| Some(&c.name),
-        installed_only,
-        quiet,
-        cfg.process,
-    )
+    if let Ok(distributable) = DistributableToolchain::from_partial(toolchain.clone(), cfg).await {
+        common::list_items(
+            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(
+            toolchain
+                .installed_components()?
+                .iter()
+                .map(|s| (s.name().to_string(), true)),
+            installed_only,
+            quiet,
+            cfg.process,
+        )
+    }
 }
 
 async fn component_add(