Strip features which is owned by dev dependencies only

src/cargo/ops/registry.rs

@@ -366,13 +366,34 @@ fn transmit(
         return Ok(());
     }
 
+    fn is_deps_feature(deps: &Vec<NewCrateDependency>, feature: &str) -> bool {
+        if !feature.contains('/') {
+            return true;
+        }
+        let mut iter = feature.split('/');
+        let dep_name = iter.next().unwrap();
+        let feature_name = iter.next().unwrap();
+        for dep in deps.iter() {
+            if dep.name == dep_name {
+                if dep.features.contains(&feature_name.to_string()) {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
     let string_features = match manifest.original().features() {
         Some(features) => features
             .iter()
             .map(|(feat, values)| {
                 (
                     feat.to_string(),
-                    values.iter().map(|fv| fv.to_string()).collect(),
+                    values
+                        .iter()
+                        .map(|fv| fv.to_string())
+                        .filter(|feat| is_deps_feature(&deps, feat))
+                        .collect(),
                 )
             })
             .collect::<BTreeMap<String, Vec<String>>>(),

src/cargo/util/toml/mod.rs

@@ -1851,6 +1851,14 @@ impl TomlManifest {
             }
         }
         let all = |_d: &TomlDependency| true;
+        let dependencies = map_deps(config, self.dependencies.as_ref(), all)?;
+        let dev_dependencies = map_deps(
+            config,
+            self.dev_dependencies
+                .as_ref()
+                .or_else(|| self.dev_dependencies2.as_ref()),
+            TomlDependency::is_version_specified,
+        )?;
         return Ok(TomlManifest {
             package: Some(package),
             project: None,
@@ -1860,14 +1868,8 @@ impl TomlManifest {
             example: self.example.clone(),
             test: self.test.clone(),
             bench: self.bench.clone(),
-            dependencies: map_deps(config, self.dependencies.as_ref(), all)?,
-            dev_dependencies: map_deps(
-                config,
-                self.dev_dependencies
-                    .as_ref()
-                    .or_else(|| self.dev_dependencies2.as_ref()),
-                TomlDependency::is_version_specified,
-            )?,
+            dependencies: dependencies.clone(),
+            dev_dependencies: dev_dependencies.clone(),
             dev_dependencies2: None,
             build_dependencies: map_deps(
                 config,
@@ -1877,7 +1879,7 @@ impl TomlManifest {
                 all,
             )?,
             build_dependencies2: None,
-            features: self.features.clone(),
+            features: map_features(dependencies, dev_dependencies, self.features.clone()),
             target: match self.target.as_ref().map(|target_map| {
                 target_map
                     .iter()
@@ -1919,6 +1921,60 @@ impl TomlManifest {
             lints: self.lints.clone(),
         });
 
+        fn map_features(
+            deps: Option<BTreeMap<String, MaybeWorkspaceDependency>>,
+            dev_deps: Option<BTreeMap<String, MaybeWorkspaceDependency>>,
+            features: Option<BTreeMap<InternedString, Vec<InternedString>>>,
+        ) -> Option<BTreeMap<InternedString, Vec<InternedString>>> {
+            if deps.is_none() && dev_deps.is_none() {
+                return None;
+            }
+            let all_deps = {
+                if deps.is_none() {
+                    dev_deps?
+                } else {
+                    let mut all_deps = deps?;
+                    if let Some(dev_deps) = dev_deps {
+                        all_deps.extend(dev_deps);
+                    }
+                    all_deps
+                }
+            };
+
+            let mut features = features.clone()?;
+            features.iter_mut().for_each(|(_name, features)| {
+                features.retain(|feature| {
+                    if !feature.contains('/') {
+                        return true;
+                    }
+                    let mut iter = feature.split('/');
+                    let dep_name = iter.next().unwrap();
+                    let feature_name = iter.next().unwrap();
+                    for (i_dep_name, i_dep_detail) in all_deps.iter() {
+                        if i_dep_name == dep_name {
+                            return match i_dep_detail {
+                                MaybeWorkspace::Defined(defined) => match defined {
+                                    TomlDependency::Simple(_) => false,
+                                    TomlDependency::Detailed(detail) => detail
+                                        .features
+                                        .as_ref()
+                                        .map(|v| v.contains(&feature_name.to_string()))
+                                        .is_some_and(|v| v),
+                                },
+                                MaybeWorkspace::Workspace(workspace) => workspace
+                                    .features
+                                    .as_ref()
+                                    .map(|v| v.contains(&feature_name.to_string()))
+                                    .is_some_and(|v| v),
+                            };
+                        }
+                    }
+                    false
+                })
+            });
+            Some(features)
+        }
+
         fn map_deps(
             config: &Config,
             deps: Option<&BTreeMap<String, MaybeWorkspaceDependency>>,

tests/testsuite/publish.rs

@@ -1614,6 +1614,127 @@ repository = "foo"
     );
 }
 
+// This test case have a feature `foo_feature = [byte-unit/alloc]` which is owned by `dev-dependencies`,
+// `cargo publish` should strip it to `foo_feature = []`.
+#[cargo_test]
+fn publish_strip_feature_which_is_owned_by_dev_deps() {
+    let registry = RegistryBuilder::new().http_api().http_index().build();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            authors = []
+            license = "MIT"
+            description = "foo"
+            documentation = "foo"
+            homepage = "foo"
+            repository = "foo"
+
+            [dependencies]
+
+            [dev-dependencies]
+            byte-unit = {version = "4.0.19", features = ["alloc"]}
+
+           [features]
+           foo_feature = ["byte-unit/alloc"]
+
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .file("bar/Cargo.toml", &basic_manifest("bar", "0.0.1"))
+        .file("bar/src/lib.rs", "")
+        .build();
+
+    p.cargo("publish --no-verify")
+        .replace_crates_io(registry.index_url())
+        .with_stderr(
+            "\
+[UPDATING] [..]
+[PACKAGING] foo v0.1.0 [..]
+[PACKAGED] [..] files, [..] ([..] compressed)
+[UPLOADING] foo v0.1.0 [..]
+[UPLOADED] foo v0.1.0 [..]
+note: Waiting [..]
+You may press ctrl-c [..]
+[PUBLISHED] foo v0.1.0 [..]
+",
+        )
+        .run();
+
+    publish::validate_upload_with_contents(
+        r#"
+        {
+          "authors": [],
+          "badges": {},
+          "categories": [],
+          "deps": [
+            {
+              "default_features": true,
+              "features": [
+                "alloc"
+              ],
+              "kind": "dev",
+              "name": "byte-unit",
+              "optional": false,
+              "target": null,
+              "version_req": "^4.0.19"
+            }
+          ],
+          "description": "foo",
+          "documentation": "foo",
+          "features": {
+            "foo_feature": [
+              "byte-unit/alloc"
+            ]
+          },
+          "homepage": "foo",
+          "keywords": [],
+          "license": "MIT",
+          "license_file": null,
+          "links": null,
+          "name": "foo",
+          "readme": null,
+          "readme_file": null,
+          "repository": "foo",
+          "rust_version": null,
+          "vers": "0.1.0"
+        }
+        "#,
+        "foo-0.1.0.crate",
+        &["Cargo.toml", "Cargo.toml.orig", "src/lib.rs"],
+        &[(
+            "Cargo.toml",
+            &format!(
+                r#"{}
+[package]
+name = "foo"
+version = "0.1.0"
+authors = []
+description = "foo"
+homepage = "foo"
+documentation = "foo"
+license = "MIT"
+repository = "foo"
+
+[dependencies]
+
+[dev-dependencies.byte-unit]
+version = "4.0.19"
+features = ["alloc"]
+
+[features]
+foo_feature = []
+"#,
+                cargo::core::package::MANIFEST_PREAMBLE
+            ),
+        )],
+    );
+}
+
 #[cargo_test]
 fn credentials_ambiguous_filename() {
     // `publish` generally requires a remote registry