From cc891a0bc57c9aac18f298fa4dbd96b0b1feec41 Mon Sep 17 00:00:00 2001 From: hi-rustin Date: Sat, 7 Aug 2021 11:51:56 +0800 Subject: [PATCH 1/5] Warning for no lib dependencies Signed-off-by: hi-rustin --- src/cargo/ops/resolve.rs | 16 +++++++++++++++ tests/testsuite/run.rs | 42 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 58 insertions(+) diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs index c305bc3a353..a307ba5ea2e 100644 --- a/src/cargo/ops/resolve.rs +++ b/src/cargo/ops/resolve.rs @@ -171,6 +171,22 @@ pub fn resolve_ws_with_opts<'cfg>( feature_opts, )?; + // Check if there are any dependency packages that do not have any libs. + if let Some(r) = resolve.as_ref() { + for id in member_ids.iter() { + for (package_id, _) in r.deps(*id) { + if let Ok(dep_pkg) = pkg_set.get_one(package_id) { + if !dep_pkg.targets().iter().any(|t| t.is_lib()) { + ws.config().shell().warn(format!( + "No library were found in package `{}`", + dep_pkg.name() + ))? + } + } + } + } + } + Ok(WorkspaceResolve { pkg_set, workspace_resolve: resolve, diff --git a/tests/testsuite/run.rs b/tests/testsuite/run.rs index 106e2259fc4..a1684766bf4 100644 --- a/tests/testsuite/run.rs +++ b/tests/testsuite/run.rs @@ -723,6 +723,48 @@ fn run_dylib_dep() { p.cargo("run hello world").run(); } +#[cargo_test] +fn run_with_bin_dep() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + + [dependencies.bar] + path = "bar" + "#, + ) + .file("src/main.rs", r#"fn main() { println!("hello"); }"#) + .file( + "bar/Cargo.toml", + r#" + [package] + name = "bar" + version = "0.0.1" + authors = [] + + [[bin]] + name = "bar" + "#, + ) + .file("bar/src/main.rs", r#"fn main() { println!("bar"); }"#) + .build(); + + p.cargo("run") + .with_stderr( + "\ +[WARNING] No library were found in package `bar` +[COMPILING] foo v0.0.1 ([CWD]) +[FINISHED] dev [unoptimized + debuginfo] target(s) in [..] +[RUNNING] `target/debug/foo[EXE]`", + ) + .with_stdout("hello") + .run(); +} + #[cargo_test] fn release_works() { let p = project() From 27c103063c38a2f7229450c0e87f277abb4bb7e4 Mon Sep 17 00:00:00 2001 From: hi-rustin Date: Sat, 7 Aug 2021 14:10:14 +0800 Subject: [PATCH 2/5] Use batch warnings and only warn about used dependency packages Signed-off-by: hi-rustin --- src/cargo/core/package.rs | 89 ++++++++++++++++++++++++++++++--------- src/cargo/ops/resolve.rs | 32 ++++++++------ tests/testsuite/run.rs | 64 +++++++++++++++++++++++++++- 3 files changed, 149 insertions(+), 36 deletions(-) diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs index 63503193eba..6b34d1b18ed 100644 --- a/src/cargo/core/package.rs +++ b/src/cargo/core/package.rs @@ -516,27 +516,14 @@ impl<'cfg> PackageSet<'cfg> { if !used.insert(pkg_id) { return Ok(()); } - let filtered_deps = resolve.deps(pkg_id).filter(|&(_id, deps)| { - deps.iter().any(|dep| { - if dep.kind() == DepKind::Development && has_dev_units == HasDevUnits::No { - return false; - } - // This is overly broad, since not all target-specific - // dependencies are used both for target and host. To tighten this - // up, this function would need to track "for_host" similar to how - // unit dependencies handles it. - if force_all_targets == ForceAllTargets::No { - let activated = requested_kinds - .iter() - .chain(Some(&CompileKind::Host)) - .any(|kind| target_data.dep_platform_activated(dep, *kind)); - if !activated { - return false; - } - } - true - }) - }); + let filtered_deps = PackageSet::filter_deps( + pkg_id, + resolve, + has_dev_units, + requested_kinds, + target_data, + force_all_targets, + ); for (dep_id, _deps) in filtered_deps { collect_used_deps( used, @@ -571,6 +558,66 @@ impl<'cfg> PackageSet<'cfg> { Ok(()) } + /// Check if there are any dependency packages that do not have any libs. + pub(crate) fn no_lib_pkgs( + &self, + resolve: &Resolve, + root_ids: &[PackageId], + has_dev_units: HasDevUnits, + requested_kinds: &[CompileKind], + target_data: &RustcTargetData<'_>, + force_all_targets: ForceAllTargets, + ) -> CargoResult> { + let mut ret = vec![]; + + root_ids.iter().for_each(|pkg_id| { + PackageSet::filter_deps( + *pkg_id, + resolve, + has_dev_units, + requested_kinds, + target_data, + force_all_targets, + ) + .for_each(|(package_id, _)| { + if let Ok(dep_pkg) = self.get_one(package_id) { + if !dep_pkg.targets().iter().any(|t| t.is_lib()) { + ret.push(dep_pkg); + } + } + }); + }); + + Ok(ret) + } + + fn filter_deps<'a>( + pkg_id: PackageId, + resolve: &'a Resolve, + has_dev_units: HasDevUnits, + requested_kinds: &'a [CompileKind], + target_data: &'a RustcTargetData<'_>, + force_all_targets: ForceAllTargets, + ) -> impl Iterator)> { + resolve.deps(pkg_id).filter(move |&(_id, deps)| { + deps.iter().any(|dep| { + if dep.kind() == DepKind::Development && has_dev_units == HasDevUnits::No { + return false; + } + if force_all_targets == ForceAllTargets::No { + let activated = requested_kinds + .iter() + .chain(Some(&CompileKind::Host)) + .any(|kind| target_data.dep_platform_activated(dep, *kind)); + if !activated { + return false; + } + } + true + }) + }) + } + pub fn sources(&self) -> Ref<'_, SourceMap<'cfg>> { self.sources.borrow() } diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs index a307ba5ea2e..73071e2e74b 100644 --- a/src/cargo/ops/resolve.rs +++ b/src/cargo/ops/resolve.rs @@ -171,20 +171,24 @@ pub fn resolve_ws_with_opts<'cfg>( feature_opts, )?; - // Check if there are any dependency packages that do not have any libs. - if let Some(r) = resolve.as_ref() { - for id in member_ids.iter() { - for (package_id, _) in r.deps(*id) { - if let Ok(dep_pkg) = pkg_set.get_one(package_id) { - if !dep_pkg.targets().iter().any(|t| t.is_lib()) { - ws.config().shell().warn(format!( - "No library were found in package `{}`", - dep_pkg.name() - ))? - } - } - } - } + let no_lib_warnings: Vec = pkg_set + .no_lib_pkgs( + &resolved_with_overrides, + &member_ids, + has_dev_units, + requested_targets, + target_data, + force_all_targets, + )? + .iter() + .map(|pkg| format!("No lib found in package `{}`.", pkg.name())) + .collect(); + if !no_lib_warnings.is_empty() { + ws.config().shell().warn(format!( + "{} The dependent package should have a lib, \ + otherwise it is an invalid dependency.", + no_lib_warnings.join("\n") + ))?; } Ok(WorkspaceResolve { diff --git a/tests/testsuite/run.rs b/tests/testsuite/run.rs index a1684766bf4..f8df617bb6f 100644 --- a/tests/testsuite/run.rs +++ b/tests/testsuite/run.rs @@ -756,7 +756,69 @@ fn run_with_bin_dep() { p.cargo("run") .with_stderr( "\ -[WARNING] No library were found in package `bar` +[WARNING] No lib found in package `bar`. \ +The dependent package should have a lib, \ +otherwise it is an invalid dependency. +[COMPILING] foo v0.0.1 ([CWD]) +[FINISHED] dev [unoptimized + debuginfo] target(s) in [..] +[RUNNING] `target/debug/foo[EXE]`", + ) + .with_stdout("hello") + .run(); +} + +#[cargo_test] +fn run_with_bin_deps() { + let p = project() + .file( + "Cargo.toml", + r#" + [package] + name = "foo" + version = "0.0.1" + + [dependencies.bar1] + path = "bar1" + [dependencies.bar2] + path = "bar2" + "#, + ) + .file("src/main.rs", r#"fn main() { println!("hello"); }"#) + .file( + "bar1/Cargo.toml", + r#" + [package] + name = "bar1" + version = "0.0.1" + authors = [] + + [[bin]] + name = "bar1" + "#, + ) + .file("bar1/src/main.rs", r#"fn main() { println!("bar"); }"#) + .file( + "bar2/Cargo.toml", + r#" + [package] + name = "bar2" + version = "0.0.1" + authors = [] + + [[bin]] + name = "bar2" + "#, + ) + .file("bar2/src/main.rs", r#"fn main() { println!("bar"); }"#) + .build(); + + p.cargo("run") + .with_stderr( + "\ +[WARNING] No lib found in package `bar1`. +No lib found in package `bar2`. \ +The dependent package should have a lib, \ +otherwise it is an invalid dependency. [COMPILING] foo v0.0.1 ([CWD]) [FINISHED] dev [unoptimized + debuginfo] target(s) in [..] [RUNNING] `target/debug/foo[EXE]`", From f1278314a2993957f5f4b1b4389ee6825da190b1 Mon Sep 17 00:00:00 2001 From: hi-rustin Date: Mon, 9 Aug 2021 16:35:09 +0800 Subject: [PATCH 3/5] Just return a vec Signed-off-by: hi-rustin --- src/cargo/core/package.rs | 57 +++++++++++++++++++++------------------ src/cargo/ops/resolve.rs | 2 +- 2 files changed, 32 insertions(+), 27 deletions(-) diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs index 6b34d1b18ed..bc738693417 100644 --- a/src/cargo/core/package.rs +++ b/src/cargo/core/package.rs @@ -524,11 +524,11 @@ impl<'cfg> PackageSet<'cfg> { target_data, force_all_targets, ); - for (dep_id, _deps) in filtered_deps { + for &pkg_id in filtered_deps.iter() { collect_used_deps( used, resolve, - dep_id, + pkg_id, has_dev_units, requested_kinds, target_data, @@ -567,19 +567,20 @@ impl<'cfg> PackageSet<'cfg> { requested_kinds: &[CompileKind], target_data: &RustcTargetData<'_>, force_all_targets: ForceAllTargets, - ) -> CargoResult> { + ) -> Vec<&Package> { let mut ret = vec![]; - root_ids.iter().for_each(|pkg_id| { + root_ids.iter().for_each(|root_id| { PackageSet::filter_deps( - *pkg_id, + *root_id, resolve, has_dev_units, requested_kinds, target_data, force_all_targets, ) - .for_each(|(package_id, _)| { + .iter() + .for_each(|&package_id| { if let Ok(dep_pkg) = self.get_one(package_id) { if !dep_pkg.targets().iter().any(|t| t.is_lib()) { ret.push(dep_pkg); @@ -588,34 +589,38 @@ impl<'cfg> PackageSet<'cfg> { }); }); - Ok(ret) + ret } - fn filter_deps<'a>( + fn filter_deps( pkg_id: PackageId, - resolve: &'a Resolve, + resolve: &Resolve, has_dev_units: HasDevUnits, - requested_kinds: &'a [CompileKind], - target_data: &'a RustcTargetData<'_>, + requested_kinds: &[CompileKind], + target_data: &RustcTargetData<'_>, force_all_targets: ForceAllTargets, - ) -> impl Iterator)> { - resolve.deps(pkg_id).filter(move |&(_id, deps)| { - deps.iter().any(|dep| { - if dep.kind() == DepKind::Development && has_dev_units == HasDevUnits::No { - return false; - } - if force_all_targets == ForceAllTargets::No { - let activated = requested_kinds - .iter() - .chain(Some(&CompileKind::Host)) - .any(|kind| target_data.dep_platform_activated(dep, *kind)); - if !activated { + ) -> Vec { + resolve + .deps(pkg_id) + .filter(|&(_id, deps)| { + deps.iter().any(|dep| { + if dep.kind() == DepKind::Development && has_dev_units == HasDevUnits::No { return false; } - } - true + if force_all_targets == ForceAllTargets::No { + let activated = requested_kinds + .iter() + .chain(Some(&CompileKind::Host)) + .any(|kind| target_data.dep_platform_activated(dep, *kind)); + if !activated { + return false; + } + } + true + }) }) - }) + .map(|(pkg_id, _)| pkg_id) + .collect() } pub fn sources(&self) -> Ref<'_, SourceMap<'cfg>> { diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs index 73071e2e74b..bc67d7ee004 100644 --- a/src/cargo/ops/resolve.rs +++ b/src/cargo/ops/resolve.rs @@ -179,7 +179,7 @@ pub fn resolve_ws_with_opts<'cfg>( requested_targets, target_data, force_all_targets, - )? + ) .iter() .map(|pkg| format!("No lib found in package `{}`.", pkg.name())) .collect(); From 61780a90d9cb32774387d5801a4356a986b08e4a Mon Sep 17 00:00:00 2001 From: hi-rustin Date: Tue, 10 Aug 2021 22:49:00 +0800 Subject: [PATCH 4/5] Separate warning and with root_id Signed-off-by: hi-rustin --- src/cargo/core/package.rs | 25 ++++++--- src/cargo/ops/resolve.rs | 20 +++++--- tests/testsuite/run.rs | 104 ++++++++++++++++++++++++++++++++++---- 3 files changed, 125 insertions(+), 24 deletions(-) diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs index bc738693417..02bf9b824fb 100644 --- a/src/cargo/core/package.rs +++ b/src/cargo/core/package.rs @@ -567,12 +567,12 @@ impl<'cfg> PackageSet<'cfg> { requested_kinds: &[CompileKind], target_data: &RustcTargetData<'_>, force_all_targets: ForceAllTargets, - ) -> Vec<&Package> { - let mut ret = vec![]; + ) -> BTreeMap> { + let mut ret = BTreeMap::new(); - root_ids.iter().for_each(|root_id| { - PackageSet::filter_deps( - *root_id, + root_ids.iter().for_each(|&root_id| { + let pkgs: Vec<&Package> = PackageSet::filter_deps( + root_id, resolve, has_dev_units, requested_kinds, @@ -580,13 +580,22 @@ impl<'cfg> PackageSet<'cfg> { force_all_targets, ) .iter() - .for_each(|&package_id| { + .filter_map(|&package_id| { if let Ok(dep_pkg) = self.get_one(package_id) { if !dep_pkg.targets().iter().any(|t| t.is_lib()) { - ret.push(dep_pkg); + Some(dep_pkg) + } else { + None } + } else { + None } - }); + }) + .collect(); + + if !pkgs.is_empty() { + ret.insert(root_id, pkgs); + } }); ret diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs index bc67d7ee004..1cdb855380a 100644 --- a/src/cargo/ops/resolve.rs +++ b/src/cargo/ops/resolve.rs @@ -181,14 +181,20 @@ pub fn resolve_ws_with_opts<'cfg>( force_all_targets, ) .iter() - .map(|pkg| format!("No lib found in package `{}`.", pkg.name())) + .flat_map(|(pkg_id, dep_pkgs)| { + dep_pkgs.iter().map(move |dep_pkg| { + format!( + "{} has invalid dependency `{}`. `{}` has no lib package.", + pkg_id, + dep_pkg.name(), + dep_pkg.name(), + ) + }) + }) .collect(); - if !no_lib_warnings.is_empty() { - ws.config().shell().warn(format!( - "{} The dependent package should have a lib, \ - otherwise it is an invalid dependency.", - no_lib_warnings.join("\n") - ))?; + + for warn in no_lib_warnings { + ws.config().shell().warn(warn)?; } Ok(WorkspaceResolve { diff --git a/tests/testsuite/run.rs b/tests/testsuite/run.rs index f8df617bb6f..b9372ac30ca 100644 --- a/tests/testsuite/run.rs +++ b/tests/testsuite/run.rs @@ -756,9 +756,7 @@ fn run_with_bin_dep() { p.cargo("run") .with_stderr( "\ -[WARNING] No lib found in package `bar`. \ -The dependent package should have a lib, \ -otherwise it is an invalid dependency. +[WARNING] foo v0.0.1 ([CWD]) has invalid dependency `bar`. `bar` has no lib package. [COMPILING] foo v0.0.1 ([CWD]) [FINISHED] dev [unoptimized + debuginfo] target(s) in [..] [RUNNING] `target/debug/foo[EXE]`", @@ -796,7 +794,7 @@ fn run_with_bin_deps() { name = "bar1" "#, ) - .file("bar1/src/main.rs", r#"fn main() { println!("bar"); }"#) + .file("bar1/src/main.rs", r#"fn main() { println!("bar1"); }"#) .file( "bar2/Cargo.toml", r#" @@ -809,16 +807,14 @@ fn run_with_bin_deps() { name = "bar2" "#, ) - .file("bar2/src/main.rs", r#"fn main() { println!("bar"); }"#) + .file("bar2/src/main.rs", r#"fn main() { println!("bar2"); }"#) .build(); p.cargo("run") .with_stderr( "\ -[WARNING] No lib found in package `bar1`. -No lib found in package `bar2`. \ -The dependent package should have a lib, \ -otherwise it is an invalid dependency. +[WARNING] foo v0.0.1 ([CWD]) has invalid dependency `bar1`. `bar1` has no lib package. +[WARNING] foo v0.0.1 ([CWD]) has invalid dependency `bar2`. `bar2` has no lib package. [COMPILING] foo v0.0.1 ([CWD]) [FINISHED] dev [unoptimized + debuginfo] target(s) in [..] [RUNNING] `target/debug/foo[EXE]`", @@ -827,6 +823,96 @@ otherwise it is an invalid dependency. .run(); } +#[cargo_test] +fn run_with_bin_dep_in_workspace() { + let p = project() + .file( + "Cargo.toml", + r#" + [workspace] + members = ["foo1", "foo2"] + "#, + ) + .file( + "foo1/Cargo.toml", + r#" + [package] + name = "foo1" + version = "0.0.1" + + [dependencies.bar1] + path = "bar1" + "#, + ) + .file("foo1/src/main.rs", r#"fn main() { println!("hello"); }"#) + .file( + "foo1/bar1/Cargo.toml", + r#" + [package] + name = "bar1" + version = "0.0.1" + authors = [] + + [[bin]] + name = "bar1" + "#, + ) + .file( + "foo1/bar1/src/main.rs", + r#"fn main() { println!("bar1"); }"#, + ) + .file( + "foo2/Cargo.toml", + r#" + [package] + name = "foo2" + version = "0.0.1" + + [dependencies.bar2] + path = "bar2" + "#, + ) + .file("foo2/src/main.rs", r#"fn main() { println!("hello"); }"#) + .file( + "foo2/bar2/Cargo.toml", + r#" + [package] + name = "bar2" + version = "0.0.1" + authors = [] + + [[bin]] + name = "bar2" + "#, + ) + .file( + "foo2/bar2/src/main.rs", + r#"fn main() { println!("bar2"); }"#, + ) + .build(); + + p.cargo("run") + .with_status(101) + .with_stderr( + "\ +[ERROR] `cargo run` could not determine which binary to run[..] +available binaries: bar1, bar2, foo1, foo2", + ) + .run(); + + p.cargo("run --bin foo1") + .with_stderr( + "\ +[WARNING] foo1 v0.0.1 ([CWD]/foo1) has invalid dependency `bar1`. `bar1` has no lib package. +[WARNING] foo2 v0.0.1 ([CWD]/foo2) has invalid dependency `bar2`. `bar2` has no lib package. +[COMPILING] foo1 v0.0.1 ([CWD]/foo1) +[FINISHED] dev [unoptimized + debuginfo] target(s) in [..] +[RUNNING] `target/debug/foo1[EXE]`", + ) + .with_stdout("hello") + .run(); +} + #[cargo_test] fn release_works() { let p = project() From 0b543baafff7dc9ff9c853eeb7cdd1e99a7730fa Mon Sep 17 00:00:00 2001 From: hi-rustin Date: Mon, 16 Aug 2021 10:04:18 +0800 Subject: [PATCH 5/5] Refine warnings and better code Signed-off-by: hi-rustin --- src/cargo/core/package.rs | 63 ++++++++++++++++++--------------------- src/cargo/ops/resolve.rs | 40 ++++++++++--------------- tests/testsuite/run.rs | 10 +++---- 3 files changed, 50 insertions(+), 63 deletions(-) diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs index 02bf9b824fb..6605a348e38 100644 --- a/src/cargo/core/package.rs +++ b/src/cargo/core/package.rs @@ -524,7 +524,7 @@ impl<'cfg> PackageSet<'cfg> { target_data, force_all_targets, ); - for &pkg_id in filtered_deps.iter() { + for pkg_id in filtered_deps { collect_used_deps( used, resolve, @@ -568,50 +568,45 @@ impl<'cfg> PackageSet<'cfg> { target_data: &RustcTargetData<'_>, force_all_targets: ForceAllTargets, ) -> BTreeMap> { - let mut ret = BTreeMap::new(); - - root_ids.iter().for_each(|&root_id| { - let pkgs: Vec<&Package> = PackageSet::filter_deps( - root_id, - resolve, - has_dev_units, - requested_kinds, - target_data, - force_all_targets, - ) + root_ids .iter() - .filter_map(|&package_id| { - if let Ok(dep_pkg) = self.get_one(package_id) { - if !dep_pkg.targets().iter().any(|t| t.is_lib()) { - Some(dep_pkg) + .map(|&root_id| { + let pkgs = PackageSet::filter_deps( + root_id, + resolve, + has_dev_units, + requested_kinds, + target_data, + force_all_targets, + ) + .filter_map(|package_id| { + if let Ok(dep_pkg) = self.get_one(package_id) { + if !dep_pkg.targets().iter().any(|t| t.is_lib()) { + Some(dep_pkg) + } else { + None + } } else { None } - } else { - None - } + }) + .collect(); + (root_id, pkgs) }) - .collect(); - - if !pkgs.is_empty() { - ret.insert(root_id, pkgs); - } - }); - - ret + .collect() } - fn filter_deps( + fn filter_deps<'a>( pkg_id: PackageId, - resolve: &Resolve, + resolve: &'a Resolve, has_dev_units: HasDevUnits, - requested_kinds: &[CompileKind], - target_data: &RustcTargetData<'_>, + requested_kinds: &'a [CompileKind], + target_data: &'a RustcTargetData<'_>, force_all_targets: ForceAllTargets, - ) -> Vec { + ) -> impl Iterator + 'a { resolve .deps(pkg_id) - .filter(|&(_id, deps)| { + .filter(move |&(_id, deps)| { deps.iter().any(|dep| { if dep.kind() == DepKind::Development && has_dev_units == HasDevUnits::No { return false; @@ -629,7 +624,7 @@ impl<'cfg> PackageSet<'cfg> { }) }) .map(|(pkg_id, _)| pkg_id) - .collect() + .into_iter() } pub fn sources(&self) -> Ref<'_, SourceMap<'cfg>> { diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs index 1cdb855380a..f2d213f85d1 100644 --- a/src/cargo/ops/resolve.rs +++ b/src/cargo/ops/resolve.rs @@ -171,30 +171,22 @@ pub fn resolve_ws_with_opts<'cfg>( feature_opts, )?; - let no_lib_warnings: Vec = pkg_set - .no_lib_pkgs( - &resolved_with_overrides, - &member_ids, - has_dev_units, - requested_targets, - target_data, - force_all_targets, - ) - .iter() - .flat_map(|(pkg_id, dep_pkgs)| { - dep_pkgs.iter().map(move |dep_pkg| { - format!( - "{} has invalid dependency `{}`. `{}` has no lib package.", - pkg_id, - dep_pkg.name(), - dep_pkg.name(), - ) - }) - }) - .collect(); - - for warn in no_lib_warnings { - ws.config().shell().warn(warn)?; + let no_lib_pkgs = pkg_set.no_lib_pkgs( + &resolved_with_overrides, + &member_ids, + has_dev_units, + requested_targets, + target_data, + force_all_targets, + ); + for (pkg_id, dep_pkgs) in no_lib_pkgs { + for dep_pkg in dep_pkgs { + ws.config().shell().warn(&format!( + "{} ignoring invalid dependency `{}` which is missing a lib target", + pkg_id, + dep_pkg.name(), + ))?; + } } Ok(WorkspaceResolve { diff --git a/tests/testsuite/run.rs b/tests/testsuite/run.rs index b9372ac30ca..5775e5b8e00 100644 --- a/tests/testsuite/run.rs +++ b/tests/testsuite/run.rs @@ -756,7 +756,7 @@ fn run_with_bin_dep() { p.cargo("run") .with_stderr( "\ -[WARNING] foo v0.0.1 ([CWD]) has invalid dependency `bar`. `bar` has no lib package. +[WARNING] foo v0.0.1 ([CWD]) ignoring invalid dependency `bar` which is missing a lib target [COMPILING] foo v0.0.1 ([CWD]) [FINISHED] dev [unoptimized + debuginfo] target(s) in [..] [RUNNING] `target/debug/foo[EXE]`", @@ -813,8 +813,8 @@ fn run_with_bin_deps() { p.cargo("run") .with_stderr( "\ -[WARNING] foo v0.0.1 ([CWD]) has invalid dependency `bar1`. `bar1` has no lib package. -[WARNING] foo v0.0.1 ([CWD]) has invalid dependency `bar2`. `bar2` has no lib package. +[WARNING] foo v0.0.1 ([CWD]) ignoring invalid dependency `bar1` which is missing a lib target +[WARNING] foo v0.0.1 ([CWD]) ignoring invalid dependency `bar2` which is missing a lib target [COMPILING] foo v0.0.1 ([CWD]) [FINISHED] dev [unoptimized + debuginfo] target(s) in [..] [RUNNING] `target/debug/foo[EXE]`", @@ -903,8 +903,8 @@ available binaries: bar1, bar2, foo1, foo2", p.cargo("run --bin foo1") .with_stderr( "\ -[WARNING] foo1 v0.0.1 ([CWD]/foo1) has invalid dependency `bar1`. `bar1` has no lib package. -[WARNING] foo2 v0.0.1 ([CWD]/foo2) has invalid dependency `bar2`. `bar2` has no lib package. +[WARNING] foo1 v0.0.1 ([CWD]/foo1) ignoring invalid dependency `bar1` which is missing a lib target +[WARNING] foo2 v0.0.1 ([CWD]/foo2) ignoring invalid dependency `bar2` which is missing a lib target [COMPILING] foo1 v0.0.1 ([CWD]/foo1) [FINISHED] dev [unoptimized + debuginfo] target(s) in [..] [RUNNING] `target/debug/foo1[EXE]`",