some improvements

Author: makspll

Cargo.toml

@@ -198,6 +198,7 @@ bevy_utils = { version = "0.17", default-features = false, features = ["std"] }
 glam = { version = "0.30.7", default-features = false }
 uuid = { version = "1.13", default-features = false }
 smol_str = { version = "0.2.0", default-features = false }
+nonmax = { version = "0.5.5", default-features = false, features = ["std"] }
 
 # other
 serde_json = { version = "1.0", default-features = false }

codegen/crates/crate_feature_graph/src/feature.rs

@@ -2,6 +2,7 @@ use std::{
     borrow::{Borrow, Cow},
     collections::VecDeque,
     fmt::Display,
+    hash::Hash,
 };
 
 use cargo_metadata::{
@@ -222,6 +223,43 @@ impl Ord for CrateDependency {
     }
 }
 
+/// A feature activation descriptor within a crate
+#[derive(Debug, Clone, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct LocalActivatedFeature {
+    pub feature: FeatureName,
+    pub activated_via_other_crate: bool,
+}
+
+impl PartialEq for LocalActivatedFeature {
+    fn eq(&self, other: &Self) -> bool {
+        self.feature == other.feature
+    }
+}
+
+impl Ord for LocalActivatedFeature {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        match self.feature.cmp(&other.feature) {
+            core::cmp::Ordering::Equal => {}
+            ord => return ord,
+        }
+        self.activated_via_other_crate
+            .cmp(&other.activated_via_other_crate)
+    }
+}
+
+impl PartialOrd for LocalActivatedFeature {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Hash for LocalActivatedFeature {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.feature.hash(state);
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Crate {
@@ -232,7 +270,7 @@ pub struct Crate {
     pub version: Version,
     pub in_workspace: Option<bool>,
     pub active_features: Option<IndexSet<FeatureName>>,
-    pub active_dependency_features: Option<IndexMap<CrateName, Vec<(FeatureName, bool)>>>,
+    pub active_dependency_features: Option<IndexMap<CrateName, Vec<LocalActivatedFeature>>>,
     pub is_enabled: Option<bool>,
 }
 

codegen/crates/crate_feature_graph/src/graph.rs

@@ -4,7 +4,7 @@ use indexmap::{IndexMap, IndexSet};
 use log::error;
 use petgraph::Directed;
 
-use crate::{CrateName, DependencyKind, Feature, FeatureName, Workspace};
+use crate::{CrateName, DependencyKind, Feature, FeatureName, LocalActivatedFeature, Workspace};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum DependsOn {
@@ -328,16 +328,7 @@ impl WorkspaceGraph {
                             .as_ref()
                             .map(|m| {
                                 m.iter()
-                                    .map(|(k, v)| {
-                                        (
-                                            k.to_string(),
-                                            v.iter()
-                                                .map(|(f, enabled_by_shared)| {
-                                                    (f.to_string(), enabled_by_shared)
-                                                })
-                                                .collect::<Vec<_>>(),
-                                        )
-                                    })
+                                    .map(|(k, v)| (k.to_string(), v.iter().collect::<Vec<_>>()))
                                     .collect()
                             })
                             .unwrap_or_default(),
@@ -353,12 +344,10 @@ impl WorkspaceGraph {
                             "{}: [{}]",
                             k,
                             v.iter()
-                                .map(|(f, enabled_by_shared)| format!(
+                                .map(|f| format!(
                                     "{}{}",
-                                    f,
-                                    enabled_by_shared
-                                        .then_some(String::from(" (*shared)"))
-                                        .unwrap_or_default()
+                                    f.feature,
+                                    if f.activated_via_other_crate { String::from(" (*shared)") } else { Default::default() }
                                 ))
                                 .collect::<Vec<_>>()
                                 .join(", ")
@@ -437,6 +426,7 @@ impl WorkspaceGraph {
                 f.sort()
             }
             if let Some(m) = krate.active_dependency_features.as_mut() {
+                m.sort_keys();
                 for v in m.values_mut() {
                     v.sort();
                 }
@@ -572,7 +562,7 @@ impl WorkspaceGraph {
         }
 
         // then compute the active dependency features for each crate
-        let mut active_dependency_features = HashMap::<_, Vec<(_, _)>>::new();
+        let mut active_dependency_features = HashMap::<_, Vec<_>>::new();
         for krate in self
             .workspace
             .all_crates()
@@ -602,7 +592,10 @@ impl WorkspaceGraph {
                             active_dependency_features
                                 .entry((krate.name.clone(), dependency.name.clone()))
                                 .or_default()
-                                .push((feature.clone(), false));
+                                .push(LocalActivatedFeature {
+                                    feature: feature.clone(),
+                                    activated_via_other_crate: false,
+                                });
                         }
                     }
                 }
@@ -620,11 +613,11 @@ impl WorkspaceGraph {
                         .filter(|f| !f.is_special_default_enabling_feature())
                     {
                         // meh
-                        let val = (feat.clone(), true);
-                        let false_val = (feat.clone(), false);
-                        if !entry.contains(&val) && !entry.contains(&false_val) {
-                            entry.push(val);
-                        }
+                        let val = LocalActivatedFeature {
+                            feature: feat.clone(),
+                            activated_via_other_crate: true,
+                        };
+                        entry.push(val);
                     }
                 }
             }
@@ -642,6 +635,16 @@ impl WorkspaceGraph {
             if let Some(krate) = self.workspace.find_crate_mut(&in_crate, || format!(
                 "package from workspace manifest: `{in_crate}` was not found in the parsed workspace list. While setting active dependency features."
             )) {
+                // remove duplicates, but keep the "lowest" activation level to show
+                let mut feature_set = HashSet::<LocalActivatedFeature>::with_capacity(features.len());
+                for mut feat in features.into_iter() {
+                    if let Some(existing) = feature_set.get(&feat) {
+                        feat.activated_via_other_crate = existing.activated_via_other_crate && feat.activated_via_other_crate;
+                    } 
+                    feature_set.insert(feat);
+                }
+                let features = feature_set.into_iter().collect();
+
                 match krate.active_dependency_features.as_mut() {
                     Some(map) => {
                         map.insert(dependency, features);

codegen/src/passes/write_meta.rs

@@ -51,10 +51,7 @@ pub(crate) fn write_meta(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
                     k.to_string(),
                     Dependency {
                         version: d.version.to_string(),
-                        features: features
-                            .iter()
-                            .map(|(feat_name, _)| feat_name.to_string())
-                            .collect(),
+                        features: features.iter().map(|f| f.feature.to_string()).collect(),
                     },
                 ),
                 None => todo!(),

crates/bevy_mod_scripting_bindings/Cargo.toml

@@ -32,6 +32,7 @@ profiling = { workspace = true }
 bevy_asset = { workspace = true }
 variadics_please = { workspace = true }
 serde = { workspace = true }
+nonmax = { workspace = true }
 
 [dev-dependencies]
 pretty_assertions = { workspace = true }

crates/bevy_mod_scripting_bindings/src/function/from.rs

@@ -5,6 +5,7 @@ use crate::{
 };
 use bevy_platform::collections::{HashMap, HashSet};
 use bevy_reflect::{FromReflect, Reflect};
+use nonmax::NonMaxU32;
 use std::{
     any::TypeId,
     ffi::OsString,
@@ -115,6 +116,28 @@ macro_rules! impl_from_stringlike {
 
 impl_from_stringlike!(String, PathBuf, OsString);
 
+impl FromScript for NonMaxU32 {
+    type This<'w> = Self;
+
+    fn from_script(
+        value: ScriptValue,
+        _world: WorldGuard<'_>,
+    ) -> Result<Self::This<'_>, InteropError>
+    where
+        Self: Sized,
+    {
+        match value {
+            ScriptValue::Integer(i) if i != 0 => Ok(unsafe { NonMaxU32::new_unchecked(i as u32) }),
+            ScriptValue::Float(f) if f != 0.0 => Ok(unsafe { NonMaxU32::new_unchecked(f as u32) }),
+            // ScriptValue::Reference(r) => r.downcast::<Self>(world),
+            _ => Err(InteropError::value_mismatch(
+                std::any::TypeId::of::<Self>(),
+                value,
+            )),
+        }
+    }
+}
+
 #[profiling::all_functions]
 impl FromScript for char {
     type This<'w> = Self;