feat(workspace): Get all members even though default-members was specified

Author: linyihai

src/cargo/ops/cargo_compile/unit_generator.rs

@@ -17,6 +17,7 @@ use crate::util::{closest_msg, CargoResult};
 
 use super::compile_filter::{CompileFilter, FilterRule, LibRule};
 use super::packages::build_glob;
+use super::Packages;
 
 /// A proposed target.
 ///
@@ -267,35 +268,61 @@ impl<'a> UnitGenerator<'a, '_> {
                 })
                 .collect::<Vec<_>>();
             let suggestion = closest_msg(target_name, targets.iter(), |t| t.name(), "target");
-            if !suggestion.is_empty() {
-                anyhow::bail!(
-                    "no {} target {} `{}`{}",
-                    target_desc,
-                    if is_glob { "matches pattern" } else { "named" },
-                    target_name,
-                    suggestion
-                );
+            let target_elsewhere = if is_glob {
+                let pattern = build_glob(target_name)?;
+                let filter = |t: &Target| is_expected_kind(t) && pattern.matches(t.name());
+                self.get_targets_from_other_packages(filter)?
             } else {
-                let mut msg = String::new();
-                writeln!(
-                    msg,
-                    "no {} target {} `{}`.",
-                    target_desc,
-                    if is_glob { "matches pattern" } else { "named" },
-                    target_name,
-                )?;
-                if !targets.is_empty() {
-                    writeln!(msg, "Available {} targets:", target_desc)?;
-                    for target in targets {
-                        writeln!(msg, "    {}", target.name())?;
-                    }
+                let filter = |t: &Target| t.name() == target_name && is_expected_kind(t);
+                self.get_targets_from_other_packages(filter)?
+            };
+
+            let mut msg = String::new();
+            write!(
+                msg,
+                "no {} target {} `{}`",
+                target_desc,
+                if is_glob { "matches pattern" } else { "named" },
+                target_name
+            )?;
+            if let Some((package, target)) = target_elsewhere {
+                writeln!(msg, "\nAvailable {target_desc} targets in {package}:")?;
+                writeln!(msg, "    {target}")?;
+            } else if !suggestion.is_empty() {
+                write!(msg, "{suggestion}")?;
+            } else if !targets.is_empty() {
+                writeln!(msg, "\nAvailable {} targets:", target_desc)?;
+                for target in targets {
+                    writeln!(msg, "    {}", target.name())?;
                 }
-                anyhow::bail!(msg);
             }
+
+            anyhow::bail!(msg);
         }
         Ok(proposals)
     }
 
+    fn get_targets_from_other_packages(
+        &self,
+        filter_fn: impl Fn(&Target) -> bool,
+    ) -> CargoResult<Option<(String, String)>> {
+        let packages = Packages::All(Vec::new()).get_packages(self.ws)?;
+        let targets = packages.into_iter().find_map(|pkg| {
+            if let Some(target) = pkg
+                .manifest()
+                .targets()
+                .iter()
+                .find(|target| filter_fn(target))
+            {
+                Some((pkg.name().to_string(), target.name().to_string()))
+            } else {
+                None
+            }
+        });
+
+        Ok(targets)
+    }
+
     /// Returns a list of proposed targets based on command-line target selection flags.
     fn list_rule_targets(
         &self,

src/cargo/util/workspace.rs

@@ -2,33 +2,45 @@ use crate::core::compiler::Unit;
 use crate::core::manifest::TargetSourcePath;
 use crate::core::{Target, Workspace};
 use crate::ops::CompileOptions;
+use crate::ops::Packages;
 use crate::util::CargoResult;
 use anyhow::bail;
 use cargo_util::paths::normalize_path;
 use cargo_util::ProcessBuilder;
+use std::collections::BTreeMap;
 use std::fmt::Write;
 use std::path::PathBuf;
 
 fn get_available_targets<'a>(
     filter_fn: fn(&Target) -> bool,
     ws: &'a Workspace<'_>,
     options: &'a CompileOptions,
-) -> CargoResult<Vec<&'a str>> {
-    let packages = options.spec.get_packages(ws)?;
-
-    let mut targets: Vec<_> = packages
+) -> CargoResult<BTreeMap<String, Vec<String>>> {
+    let packages = if matches!(options.spec, Packages::Default) {
+        Packages::All(Vec::new()).get_packages(ws)?
+    } else {
+        options.spec.get_packages(ws)?
+    };
+    let targets: BTreeMap<String, Vec<String>> = packages
         .into_iter()
-        .flat_map(|pkg| {
-            pkg.manifest()
+        .filter_map(|pkg| {
+            let mut targets = pkg
+                .manifest()
                 .targets()
                 .iter()
                 .filter(|target| filter_fn(target))
+                .map(|t| t.name().to_owned())
+                .collect::<Vec<String>>();
+
+            if targets.is_empty() {
+                return None;
+            }
+            targets.sort();
+
+            Some((pkg.name().to_string(), targets))
         })
-        .map(Target::name)
         .collect();
 
-    targets.sort();
-
     Ok(targets)
 }
 
@@ -47,9 +59,14 @@ fn print_available_targets(
     if targets.is_empty() {
         writeln!(output, "No {} available.", plural_name)?;
     } else {
-        writeln!(output, "Available {}:", plural_name)?;
-        for target in targets {
-            writeln!(output, "    {}", target)?;
+        for (package, targets) in targets {
+            if targets.is_empty() {
+                continue;
+            }
+            writeln!(output, "Available {} in {}:", plural_name, package)?;
+            for target in targets {
+                writeln!(output, "    {}", target)?;
+            }
         }
     }
     bail!("{}", output)

tests/testsuite/build.rs

@@ -1337,7 +1337,7 @@ fn cargo_compile_with_filename() {
     p.cargo("build --bin bin.rs")
         .with_status(101)
         .with_stderr_data(str![[r#"
-[ERROR] no bin target named `bin.rs`.
+[ERROR] no bin target named `bin.rs`
 Available bin targets:
     a
 
@@ -1358,7 +1358,7 @@ Available bin targets:
     p.cargo("build --example example.rs")
         .with_status(101)
         .with_stderr_data(str![[r#"
-[ERROR] no example target named `example.rs`.
+[ERROR] no example target named `example.rs`
 Available example targets:
     a
 

tests/testsuite/install.rs

@@ -600,7 +600,7 @@ fn install_relative_path_outside_current_ws() {
         .with_status(101)
         .with_stderr_data(str![[r#"
 [ERROR] "--bin" takes one argument.
-Available binaries:
+Available binaries in foo:
     foo