refactor(package): Make target filtering optional

We'll be doing a second `prepare_for_publish` call that doesn't need the
filtering, we don't have access to the `included`, and we don't want the
warnings duplicated.

Author: epage

src/cargo/ops/cargo_package.rs

@@ -732,7 +732,7 @@ fn tar(
         .iter()
         .map(|ar_file| ar_file.rel_path.clone())
         .collect::<Vec<_>>();
-    let publish_pkg = prepare_for_publish(pkg, ws, &included)?;
+    let publish_pkg = prepare_for_publish(pkg, ws, Some(&included))?;
 
     let mut uncompressed_size = 0;
     for ar_file in ar_files {

src/cargo/util/toml/mod.rs

@@ -2575,7 +2575,7 @@ fn unused_dep_keys(
 pub fn prepare_for_publish(
     me: &Package,
     ws: &Workspace<'_>,
-    included: &[PathBuf],
+    included: Option<&[PathBuf]>,
 ) -> CargoResult<Package> {
     let contents = me.manifest().contents();
     let document = me.manifest().document();
@@ -2612,7 +2612,7 @@ fn prepare_toml_for_publish(
     me: &manifest::TomlManifest,
     ws: &Workspace<'_>,
     package_root: &Path,
-    included: &[PathBuf],
+    included: Option<&[PathBuf]>,
 ) -> CargoResult<manifest::TomlManifest> {
     let gctx = ws.gctx();
 
@@ -2629,7 +2629,8 @@ fn prepare_toml_for_publish(
     package.workspace = None;
     if let Some(StringOrBool::String(path)) = &package.build {
         let path = paths::normalize_path(Path::new(path));
-        let build = if included.contains(&path) {
+        let included = included.map(|i| i.contains(&path)).unwrap_or(true);
+        let build = if included {
             let path = path
                 .into_os_string()
                 .into_string()
@@ -2898,7 +2899,7 @@ fn prepare_toml_for_publish(
 
 fn prepare_targets_for_publish(
     targets: Option<&Vec<manifest::TomlTarget>>,
-    included: &[PathBuf],
+    included: Option<&[PathBuf]>,
     context: &str,
     gctx: &GlobalContext,
 ) -> CargoResult<Option<Vec<manifest::TomlTarget>>> {
@@ -2923,19 +2924,21 @@ fn prepare_targets_for_publish(
 
 fn prepare_target_for_publish(
     target: &manifest::TomlTarget,
-    included: &[PathBuf],
+    included: Option<&[PathBuf]>,
     context: &str,
     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);
+    if let Some(included) = included {
+        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);
+        }
     }
 
     let mut target = target.clone();