refactor: map feature with published deps

Author: baby230211

src/cargo/util/toml/mod.rs

@@ -11,7 +11,9 @@ use cargo_platform::Platform;
 use cargo_util::paths;
 use cargo_util_schemas::core::PartialVersion;
 use cargo_util_schemas::manifest;
-use cargo_util_schemas::manifest::RustVersion;
+use cargo_util_schemas::manifest::{
+    InheritableDependency, PackageName, RustVersion, TomlManifest, TomlPlatform,
+};
 use itertools::Itertools;
 use lazycell::LazyCell;
 use pathdiff::diff_paths;
@@ -315,15 +317,12 @@ pub fn prepare_for_publish(
             manifest::StringOrBool::Bool(_) => {}
         }
     }
-    let all = |_d: &manifest::TomlDependency| true;
 
-    let target_dep = me.target.as_ref().map(|target_map| {
-        target_map
-            .iter()
-            .filter_map(|(_k, v)| v.dev_dependencies.clone())
-            .flatten()
-            .collect::<BTreeMap<_, _>>()
-    });
+    let mut published_deps = BTreeSet::new();
+    let (dependencies, dev_dependencies, build_dependencies, target) =
+        build_published_deps(gctx, me, &mut published_deps)?;
+
+    let features = map_feature(me.features.as_ref(), &published_deps)?;
     return Ok(manifest::TomlManifest {
         package: Some(package),
         project: None,
@@ -333,35 +332,74 @@ pub fn prepare_for_publish(
         example: me.example.clone(),
         test: me.test.clone(),
         bench: me.bench.clone(),
-        dependencies: map_deps(gctx, me.dependencies.as_ref(), all)?,
-        dev_dependencies: map_deps(
-            gctx,
-            me.dev_dependencies(),
-            manifest::TomlDependency::is_version_specified,
-        )?,
+        dependencies,
+        dev_dependencies,
         dev_dependencies2: None,
-        build_dependencies: map_deps(gctx, me.build_dependencies(), all)?,
+        build_dependencies,
         build_dependencies2: None,
-        features: map_feature(
-            me.features.as_ref(),
-            me.dev_dependencies(),
-            target_dep.as_ref(),
-        )?,
-        target: match me.target.as_ref().map(|target_map| {
+        features,
+        target,
+        replace: None,
+        patch: None,
+        workspace: None,
+        badges: me.badges.clone(),
+        cargo_features: me.cargo_features.clone(),
+        lints: me.lints.clone(),
+    });
+
+    fn build_published_deps(
+        gctx: &GlobalContext,
+        me: &TomlManifest,
+        published_deps: &mut BTreeSet<manifest::PackageName>,
+    ) -> CargoResult<(
+        Option<BTreeMap<PackageName, InheritableDependency>>,
+        Option<BTreeMap<PackageName, InheritableDependency>>,
+        Option<BTreeMap<PackageName, InheritableDependency>>,
+        Option<BTreeMap<String, TomlPlatform>>,
+    )> {
+        fn insert_deps(
+            published_dep: &mut BTreeSet<manifest::PackageName>,
+            deps: Option<&BTreeMap<manifest::PackageName, manifest::InheritableDependency>>,
+        ) {
+            if let Some(deps) = deps {
+                for (dep_name, _dep) in deps {
+                    if published_dep.get(dep_name).is_none() {
+                        published_dep.insert(dep_name.clone());
+                    }
+                }
+            };
+        }
+        let all = |_d: &manifest::TomlDependency| true;
+        let dependencies = map_deps(gctx, me.dependencies.as_ref(), all)?;
+        let dev_dependencies = map_deps(
+            gctx,
+            me.dev_dependencies.as_ref(),
+            manifest::TomlDependency::is_version_specified,
+        )?;
+        let build_dependencies = map_deps(gctx, me.build_dependencies(), all)?;
+        let target = match me.target.as_ref().map(|target_map| {
             target_map
                 .iter()
                 .map(|(k, v)| {
+                    let dependencies = map_deps(gctx, v.dependencies.as_ref(), all)?;
+
+                    let dev_dependencies = map_deps(
+                        gctx,
+                        v.dev_dependencies.as_ref(),
+                        manifest::TomlDependency::is_version_specified,
+                    )?;
+                    let build_dependencies = map_deps(gctx, v.build_dependencies(), all)?;
+
+                    insert_deps(published_deps, dependencies.as_ref());
+                    insert_deps(published_deps, dev_dependencies.as_ref());
+                    insert_deps(published_deps, build_dependencies.as_ref());
                     Ok((
                         k.clone(),
                         manifest::TomlPlatform {
-                            dependencies: map_deps(gctx, v.dependencies.as_ref(), all)?,
-                            dev_dependencies: map_deps(
-                                gctx,
-                                v.dev_dependencies(),
-                                manifest::TomlDependency::is_version_specified,
-                            )?,
+                            dependencies,
+                            dev_dependencies,
                             dev_dependencies2: None,
-                            build_dependencies: map_deps(gctx, v.build_dependencies(), all)?,
+                            build_dependencies,
                             build_dependencies2: None,
                         },
                     ))
@@ -371,19 +409,16 @@ pub fn prepare_for_publish(
             Some(Ok(v)) => Some(v),
             Some(Err(e)) => return Err(e),
             None => None,
-        },
-        replace: None,
-        patch: None,
-        workspace: None,
-        badges: me.badges.clone(),
-        cargo_features: me.cargo_features.clone(),
-        lints: me.lints.clone(),
-    });
+        };
+        insert_deps(published_deps, dependencies.as_ref());
+        insert_deps(published_deps, dev_dependencies.as_ref());
+        insert_deps(published_deps, build_dependencies.as_ref());
+        Ok((dependencies, dev_dependencies, build_dependencies, target))
+    }
 
     fn map_feature(
         features: Option<&BTreeMap<manifest::FeatureName, Vec<String>>>,
-        dev_deps: Option<&BTreeMap<manifest::PackageName, manifest::InheritableDependency>>,
-        target_deps: Option<&BTreeMap<manifest::PackageName, manifest::InheritableDependency>>,
+        published_deps: &BTreeSet<PackageName>,
     ) -> CargoResult<Option<BTreeMap<manifest::FeatureName, Vec<String>>>> {
         let Some(features) = features else {
             return Ok(None);
@@ -400,21 +435,7 @@ pub fn prepare_for_publish(
                             | FeatureValue::DepFeature { dep_name, .. } => {
                                 let k = &manifest::PackageName::new(dep_name.to_string()).unwrap();
 
-                                if let Some(dev_deps) = dev_deps {
-                                    if let Some(dep) = dev_deps.get(k) {
-                                        if let manifest::InheritableDependency::Value(def) = dep {
-                                            return def.is_version_specified();
-                                        }
-                                    }
-                                };
-                                if let Some(target_deps) = target_deps {
-                                    if let Some(dep) = target_deps.get(k) {
-                                        if let manifest::InheritableDependency::Value(def) = dep {
-                                            return def.is_version_specified();
-                                        }
-                                    }
-                                }
-                                true
+                                published_deps.get(k).is_some()
                             }
                             _ => true,
                         }
@@ -832,8 +853,8 @@ pub fn to_real_manifest(
                         {
                             d.public = None;
                             manifest_ctx.warnings.push(format!(
-                            "Ignoring `public` on dependency {name}.  Pass `-Zpublic-dependency` to enable support for it", name = &dep.name_in_toml()
-                        ))
+                                "Ignoring `public` on dependency {name}.  Pass `-Zpublic-dependency` to enable support for it", name = &dep.name_in_toml()
+                            ))
                         }
                     } else {
                         d.public = None;