fix(toml): Warn, rather than fail publish, if targets are excluded

This could offer performance gains when parsing a published
manifest since the targets don't need to be discovered.
To see this, we'd first need to stop discovering potential targets even when it isn't
needed.

Author: epage

src/cargo/util/toml/mod.rs

@@ -264,7 +264,7 @@ fn resolve_toml(
     manifest_file: &Path,
     gctx: &GlobalContext,
     warnings: &mut Vec<String>,
-    _errors: &mut Vec<String>,
+    errors: &mut Vec<String>,
 ) -> CargoResult<manifest::TomlManifest> {
     if let Some(workspace) = &original_toml.workspace {
         if workspace.resolver.as_deref() == Some("3") {
@@ -277,11 +277,11 @@ fn resolve_toml(
         package: None,
         project: None,
         profile: original_toml.profile.clone(),
-        lib: original_toml.lib.clone(),
-        bin: original_toml.bin.clone(),
-        example: original_toml.example.clone(),
-        test: original_toml.test.clone(),
-        bench: original_toml.bench.clone(),
+        lib: None,
+        bin: None,
+        example: None,
+        test: None,
+        bench: None,
         dependencies: None,
         dev_dependencies: None,
         dev_dependencies2: None,
@@ -318,6 +318,47 @@ fn resolve_toml(
             });
         resolved_toml.package = Some(resolved_package);
 
+        resolved_toml.lib = targets::resolve_lib(
+            original_toml.lib.as_ref(),
+            package_root,
+            &original_package.name,
+            edition,
+            warnings,
+        )?;
+        resolved_toml.bin = Some(targets::resolve_bins(
+            original_toml.bin.as_ref(),
+            package_root,
+            &original_package.name,
+            edition,
+            original_package.autobins,
+            warnings,
+            resolved_toml.lib.is_some(),
+        )?);
+        resolved_toml.example = Some(targets::resolve_examples(
+            original_toml.example.as_ref(),
+            package_root,
+            edition,
+            original_package.autoexamples,
+            warnings,
+            errors,
+        )?);
+        resolved_toml.test = Some(targets::resolve_tests(
+            original_toml.test.as_ref(),
+            package_root,
+            edition,
+            original_package.autotests,
+            warnings,
+            errors,
+        )?);
+        resolved_toml.bench = Some(targets::resolve_benches(
+            original_toml.bench.as_ref(),
+            package_root,
+            edition,
+            original_package.autobenches,
+            warnings,
+            errors,
+        )?);
+
         let activated_opt_deps = resolved_toml
             .features
             .as_ref()
@@ -519,10 +560,10 @@ fn resolve_package_toml<'a>(
             .map(manifest::InheritableField::Value),
         workspace: original_package.workspace.clone(),
         im_a_teapot: original_package.im_a_teapot.clone(),
-        autobins: original_package.autobins.clone(),
-        autoexamples: original_package.autoexamples.clone(),
-        autotests: original_package.autotests.clone(),
-        autobenches: original_package.autobenches.clone(),
+        autobins: Some(false),
+        autoexamples: Some(false),
+        autotests: Some(false),
+        autobenches: Some(false),
         default_run: original_package.default_run.clone(),
         description: original_package
             .description
@@ -1149,8 +1190,8 @@ fn to_real_manifest(
     // If we have a lib with no path, use the inferred lib or else the package name.
     let targets = to_targets(
         &features,
+        &original_toml,
         &resolved_toml,
-        package_name,
         package_root,
         edition,
         &resolved_package.metabuild,
@@ -2520,14 +2561,14 @@ fn prepare_toml_for_publish(
     }
 
     let lib = if let Some(target) = &me.lib {
-        Some(prepare_target_for_publish(target, "library")?)
+        prepare_target_for_publish(target, included, "library", ws.gctx())?
     } else {
         None
     };
-    let bin = prepare_targets_for_publish(me.bin.as_ref(), "binary")?;
-    let example = prepare_targets_for_publish(me.example.as_ref(), "example")?;
-    let test = prepare_targets_for_publish(me.test.as_ref(), "test")?;
-    let bench = prepare_targets_for_publish(me.bench.as_ref(), "benchmark")?;
+    let bin = prepare_targets_for_publish(me.bin.as_ref(), included, "binary", ws.gctx())?;
+    let example = prepare_targets_for_publish(me.example.as_ref(), included, "example", ws.gctx())?;
+    let test = prepare_targets_for_publish(me.test.as_ref(), included, "test", ws.gctx())?;
+    let bench = prepare_targets_for_publish(me.bench.as_ref(), included, "benchmark", ws.gctx())?;
 
     let all = |_d: &manifest::TomlDependency| true;
     let mut manifest = manifest::TomlManifest {
@@ -2685,31 +2726,51 @@ fn prepare_toml_for_publish(
 
 fn prepare_targets_for_publish(
     targets: Option<&Vec<manifest::TomlTarget>>,
+    included: &[PathBuf],
     context: &str,
+    gctx: &GlobalContext,
 ) -> CargoResult<Option<Vec<manifest::TomlTarget>>> {
     let Some(targets) = targets else {
         return Ok(None);
     };
 
     let mut prepared = Vec::with_capacity(targets.len());
     for target in targets {
-        let target = prepare_target_for_publish(target, context)?;
+        let Some(target) = prepare_target_for_publish(target, included, context, gctx)? else {
+            continue;
+        };
         prepared.push(target);
     }
 
-    Ok(Some(prepared))
+    if prepared.is_empty() {
+        Ok(None)
+    } else {
+        Ok(Some(prepared))
+    }
 }
 
 fn prepare_target_for_publish(
     target: &manifest::TomlTarget,
+    included: &[PathBuf],
     context: &str,
-) -> CargoResult<manifest::TomlTarget> {
-    let mut target = target.clone();
-    if let Some(path) = target.path {
-        let path = normalize_path(&path.0);
-        target.path = Some(manifest::PathValue(normalize_path_sep(path, context)?));
+    gctx: &GlobalContext,
+) -> CargoResult<Option<manifest::TomlTarget>> {
+    let path = target.path.as_ref().expect("previously resolved");
+    let path = normalize_path(&path.0);
+    if !included.contains(&path) {
+        let name = target.name.as_ref().expect("previously resolved");
+        gctx.shell().warn(format!(
+            "ignoring {context} `{name}` as `{}` is not included in the published package",
+            path.display()
+        ))?;
+        return Ok(None);
     }
-    Ok(target)
+
+    let mut target = target.clone();
+    let path = normalize_path_sep(path, context)?;
+    target.path = Some(manifest::PathValue(path.into()));
+
+    Ok(Some(target))
 }
 
 fn normalize_path_sep(path: PathBuf, context: &str) -> CargoResult<PathBuf> {

src/cargo/util/toml/targets.rs

@@ -34,8 +34,8 @@ const DEFAULT_EXAMPLE_DIR_NAME: &'static str = "examples";
 #[tracing::instrument(skip_all)]
 pub(super) fn to_targets(
     features: &Features,
+    original_toml: &TomlManifest,
     resolved_toml: &TomlManifest,
-    package_name: &str,
     package_root: &Path,
     edition: Edition,
     metabuild: &Option<StringOrVec>,
@@ -44,79 +44,46 @@ pub(super) fn to_targets(
 ) -> CargoResult<Vec<Target>> {
     let mut targets = Vec::new();
 
-    let has_lib;
-
-    let lib = resolve_lib(
-        resolved_toml.lib.as_ref(),
-        package_root,
-        package_name,
-        edition,
-        warnings,
-    )?;
     if let Some(target) = to_lib_target(
+        original_toml.lib.as_ref(),
         resolved_toml.lib.as_ref(),
-        lib.as_ref(),
         package_root,
         edition,
         warnings,
     )? {
         targets.push(target);
-        has_lib = true;
-    } else {
-        has_lib = false;
     }
 
     let package = resolved_toml
         .package
         .as_ref()
         .ok_or_else(|| anyhow::format_err!("manifest has no `package` (or `project`)"))?;
 
-    let bins = resolve_bins(
-        resolved_toml.bin.as_ref(),
-        package_root,
-        package_name,
-        edition,
-        package.autobins,
-        warnings,
-        has_lib,
-    )?;
     targets.extend(to_bin_targets(
         features,
-        &bins,
+        resolved_toml.bin.as_deref().unwrap_or_default(),
         package_root,
         edition,
         errors,
     )?);
 
-    let toml_examples = resolve_examples(
-        resolved_toml.example.as_ref(),
+    targets.extend(to_example_targets(
+        resolved_toml.example.as_deref().unwrap_or_default(),
         package_root,
         edition,
-        package.autoexamples,
-        warnings,
-        errors,
-    )?;
-    targets.extend(to_example_targets(&toml_examples, package_root, edition)?);
+    )?);
 
-    let toml_tests = resolve_tests(
-        resolved_toml.test.as_ref(),
+    targets.extend(to_test_targets(
+        resolved_toml.test.as_deref().unwrap_or_default(),
         package_root,
         edition,
-        package.autotests,
-        warnings,
-        errors,
-    )?;
-    targets.extend(to_test_targets(&toml_tests, package_root, edition)?);
+    )?);
 
-    let toml_benches = resolve_benches(
-        resolved_toml.bench.as_ref(),
+    targets.extend(to_bench_targets(
+        resolved_toml.bench.as_deref().unwrap_or_default(),
         package_root,
         edition,
-        package.autobenches,
-        warnings,
-        errors,
-    )?;
-    targets.extend(to_bench_targets(&toml_benches, package_root, edition)?);
+    )?);
 
     // processing the custom build script
     if let Some(custom_build) = package.resolved_build().expect("should be resolved") {
@@ -158,7 +125,7 @@ pub(super) fn to_targets(
     Ok(targets)
 }
 
-fn resolve_lib(
+pub fn resolve_lib(
     original_lib: Option<&TomlLibTarget>,
     package_root: &Path,
     package_name: &str,
@@ -283,7 +250,7 @@ fn to_lib_target(
     Ok(Some(target))
 }
 
-fn resolve_bins(
+pub fn resolve_bins(
     toml_bins: Option<&Vec<TomlBinTarget>>,
     package_root: &Path,
     package_name: &str,
@@ -409,7 +376,7 @@ fn legacy_bin_path(package_root: &Path, name: &str, has_lib: bool) -> Option<Pat
     None
 }
 
-fn resolve_examples(
+pub fn resolve_examples(
     toml_examples: Option<&Vec<TomlExampleTarget>>,
     package_root: &Path,
     edition: Edition,
@@ -464,7 +431,7 @@ fn to_example_targets(
     Ok(result)
 }
 
-fn resolve_tests(
+pub fn resolve_tests(
     toml_tests: Option<&Vec<TomlTestTarget>>,
     package_root: &Path,
     edition: Edition,
@@ -512,7 +479,7 @@ fn to_test_targets(
     Ok(result)
 }
 
-fn resolve_benches(
+pub fn resolve_benches(
     toml_benches: Option<&Vec<TomlBenchTarget>>,
     package_root: &Path,
     edition: Edition,

tests/testsuite/artifact_dep.rs

@@ -2215,6 +2215,10 @@ name = "foo"
 version = "0.1.0"
 authors = []
 build = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
 description = "foo"
 homepage = "foo"
 documentation = "foo"
@@ -2223,6 +2227,10 @@ license = "MIT"
 repository = "foo"
 resolver = "2"
 
+[lib]
+name = "foo"
+path = "src/lib.rs"
+
 [dependencies.bar]
 version = "1.0"
 artifact = ["bin"]

tests/testsuite/features2.rs

@@ -1704,11 +1704,19 @@ name = "a"
 version = "0.1.0"
 authors = ["Zzz"]
 build = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
 description = "foo"
 homepage = "https://example.com/"
 readme = false
 license = "MIT"
 resolver = "2"
+
+[lib]
+name = "a"
+path = "src/lib.rs"
 "#,
         cargo::core::manifest::MANIFEST_PREAMBLE
     );