further fixes

Author: makspll

codegen/crates/crate_feature_graph/Cargo.toml

@@ -26,6 +26,7 @@ clap = { workspace = true, features = ["derive"] }
 serde = { workspace = true, features = ["derive"], optional = true }
 serde_json = { workspace = true, optional = true }
 pretty_env_logger = { workspace = true }
+indexmap = { workspace = true, features = ["serde"] }
 
 [dev-dependencies]
 petgraph = { workspace = true, features = ["dot_parser"] }

codegen/crates/crate_feature_graph/README.md

@@ -7,4 +7,22 @@ A tool for visualising feature flow in a rust workspace, from the perspective of
 ## Features
 - Compute feature flow throughout your workspace
 - Filter out crates you don't want to see from the graph, but retain the connections
-- Output as a dot graph or if the `dot_parser` feature is disabled as a text representation
+- Output as a dot graph or if the `dot_parser` feature is disabled as a text representation
+
+## Usage
+You can either filter the output or generate the entire graph.
+If you filter out any crates, the edges will be "collapsed" at the edges of the filtered crates, so you can still see how features propagate through the graph.
+
+For larger workspaces it is recommended to generate an svg so you can properly view the entire graph.
+
+features obey the following syntax:
+- `feature1` - enable feature1 in the root crate
+- `crate/feature2` - enable feature2 in the crate crate (and implicitly enable crate as a dependency)
+- `crate/default` - enable the default feature for the crate
+- `default` - enable the default feature for the root crate
+
+```bash
+cargo install crate_feature_graph --features dot_parser
+
+RUST_LOG=info cargo_feature_graph --manifest-path path/to/Cargo.toml --features="feature1,feature2" --only-show-crates="maybe_crate1,maybe_crate2"
+```

codegen/crates/crate_feature_graph/src/feature.rs

@@ -1,17 +1,18 @@
 use std::{
     borrow::{Borrow, Cow},
-    collections::{HashMap, HashSet, VecDeque},
+    collections::VecDeque,
     fmt::Display,
 };
 
 use cargo_metadata::{
     Metadata, Package,
     semver::{Version, VersionReq},
 };
+use indexmap::{IndexMap, IndexSet};
 use itertools::{Either, Itertools};
 use log::error;
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct CrateName(pub(crate) String);
 
@@ -34,7 +35,7 @@ impl Display for CrateName {
 }
 
 /// A feature name
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FeatureName(Cow<'static, str>);
 
@@ -56,7 +57,7 @@ impl Display for FeatureName {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum FeatureEffect {
     /// I.e. `foo=["feature"]` is represented as `EnableFeature("feature")`
@@ -91,7 +92,7 @@ impl FeatureEffect {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Feature {
     pub name: FeatureName,
@@ -198,14 +199,26 @@ impl DependencyKind {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct CrateDependency {
     pub name: CrateName,
     pub version: VersionReq,
 }
 
-#[derive(Clone, Debug)]
+impl PartialOrd for CrateDependency {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for CrateDependency {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.name.cmp(&other.name)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Crate {
     pub name: CrateName,
@@ -214,11 +227,23 @@ pub struct Crate {
     pub optional_dependencies: Vec<CrateDependency>,
     pub version: Version,
     pub in_workspace: Option<bool>,
-    pub active_features: Option<HashSet<FeatureName>>,
-    pub active_dependency_features: Option<HashMap<CrateName, Vec<FeatureName>>>,
+    pub active_features: Option<IndexSet<FeatureName>>,
+    pub active_dependency_features: Option<IndexMap<CrateName, Vec<FeatureName>>>,
     pub is_enabled: Option<bool>,
 }
 
+impl PartialOrd for Crate {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Crate {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.name.cmp(&other.name)
+    }
+}
+
 struct DependencyIter<'a> {
     krate: &'a Crate,
     index: usize,
@@ -282,10 +307,10 @@ impl Crate {
     /// if `enable_default` is true, the "default" feature is considered enabled initially if it exists.
     pub fn compute_active_features(
         &mut self,
-        enabled_features: &HashSet<FeatureName>,
+        enabled_features: &IndexSet<FeatureName>,
         keep_trails: bool,
     ) {
-        let mut all_features = HashSet::default();
+        let mut all_features = IndexSet::default();
         let mut to_process = enabled_features
             .clone()
             .into_iter()
@@ -536,7 +561,7 @@ impl From<&Metadata> for Workspace {
             .workspace_packages()
             .iter()
             .map(CrateName::from)
-            .collect::<HashSet<_>>();
+            .collect::<IndexSet<_>>();
 
         let (mut workspace_crates, mut other_crates): (Vec<_>, Vec<_>) = meta
             .packages
@@ -638,7 +663,7 @@ mod tests {
             active_dependency_features: None,
         };
 
-        krate.compute_active_features(&HashSet::from([FeatureName("default".into())]), true);
+        krate.compute_active_features(&IndexSet::from([FeatureName("default".into())]), true);
 
         let active_features = krate.active_features.unwrap();
         assert!(active_features.contains(&FeatureName("default".into())));

codegen/crates/crate_feature_graph/src/graph.rs

@@ -1,5 +1,6 @@
 use std::collections::{HashMap, HashSet, VecDeque};
 
+use indexmap::{IndexMap, IndexSet};
 use log::error;
 use petgraph::Directed;
 
@@ -405,6 +406,27 @@ impl WorkspaceGraph {
         self.calculate_enabled_features_and_dependencies(features_map, false);
     }
 
+    pub fn stable_sort(&mut self) {
+        // sort everything
+        self.workspace.other_crates.sort();
+        self.workspace.workspace_crates.sort();
+        for krate in self.workspace.all_crates_mut() {
+            krate.features.sort();
+            krate.dependencies.sort_by(|a, b| a.name.cmp(&b.name));
+            krate
+                .optional_dependencies
+                .sort_by(|a, b| a.name.cmp(&b.name));
+            if let Some(f) = krate.active_features.as_mut() {
+                f.sort()
+            }
+            if let Some(m) = krate.active_dependency_features.as_mut() {
+                for v in m.values_mut() {
+                    v.sort();
+                }
+            }
+        }
+    }
+
     /// Calculate the enabled features and dependencies for the workspace
     /// The set of enabled feature/crate pairs is treated as the set of explicitly enabled crates
     /// For a workspace this should be the workspace root with the desired features enabled..
@@ -434,7 +456,7 @@ impl WorkspaceGraph {
             match enabled_crates.remove(&krate) {
                 Some((features, enable_default)) => {
                     // a top level enabled crate, process only explicitly enabled features, we know nothing else will be there to enable more
-                    let features = HashSet::from_iter(features.iter().cloned());
+                    let features = IndexSet::from_iter(features.iter().cloned());
                     if enable_default
                         && let Some(c) = self.workspace.find_crate_mut(&krate, || format!(
                             "package from workspace manifest: `{krate}` was not found in the parsed workspace list. This might lead to missing default features."))
@@ -477,7 +499,7 @@ impl WorkspaceGraph {
                                     .filter_map(|f| f.effects().find_map(|e| e.enables_feature_in_crate(&krate).cloned())))
                             })
                             .flatten()
-                            .collect::<HashSet<_>>();
+                            .collect::<IndexSet<_>>();
 
                     log::trace!(
                         "Crate `{krate}` is being enabled with parent features: {parent_features:?}"
@@ -586,7 +608,7 @@ impl WorkspaceGraph {
                         map.insert(dependency, features);
                     }
                     None => {
-                        let mut map = HashMap::new();
+                        let mut map = IndexMap::new();
                         map.insert(dependency, features);
                         krate.active_dependency_features = Some(map);
                     }
@@ -600,7 +622,7 @@ impl WorkspaceGraph {
     fn process_crate(
         &mut self,
         krate: &CrateName,
-        enable_features: HashSet<FeatureName>,
+        enable_features: IndexSet<FeatureName>,
         trace_features: bool,
     ) {
         // find all conditional features in this crate, only consider the crates in the open set.

codegen/crates/crate_feature_graph/src/lib.rs

@@ -6,11 +6,9 @@ pub use graph::*;
 
 #[cfg(test)]
 mod test {
-    use std::{
-        collections::{HashMap, HashSet},
-        path::PathBuf,
-    };
+    use std::{collections::HashMap, hash::RandomState, path::PathBuf};
 
+    use indexmap::IndexSet;
     use petgraph::dot::Dot;
 
     use super::*;
@@ -102,7 +100,7 @@ mod test {
         // assert features
         pretty_assertions::assert_eq!(
             root_crate.active_features.as_ref().unwrap(),
-            &HashSet::from_iter([
+            &IndexSet::<_, RandomState>::from_iter([
                 FeatureName::new("default"),
                 FeatureName::new("enable_crate_a"),
             ])
@@ -111,7 +109,7 @@ mod test {
 
         pretty_assertions::assert_eq!(
             crate_a.active_features.as_ref().unwrap(),
-            &HashSet::from_iter([
+            &IndexSet::<_, RandomState>::from_iter([
                 FeatureName::new("crate_a_default"),
                 FeatureName::new("default"),
             ])

codegen/src/modifying_file_loader.rs

@@ -1,8 +1,8 @@
 use std::{
     io,
     sync::{
-        atomic::{AtomicBool, Ordering},
         Arc,
+        atomic::{AtomicBool, Ordering},
     },
 };
 

codegen/src/passes/find_reflect_types.rs

@@ -1,7 +1,7 @@
 use log::{debug, info};
 use rustc_hir::def_id::LOCAL_CRATE;
 
-use crate::{Args, BevyCtxt, ReflectType, DEF_PATHS_REFLECT};
+use crate::{Args, BevyCtxt, DEF_PATHS_REFLECT, ReflectType};
 
 /// Finds all reflect types which we can wrap in the crate as well as sorts the final list.
 pub(crate) fn find_reflect_types(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bool {

codegen_bevy_features.txt

@@ -1 +1 @@
-bevy_asset,bevy_animation,bevy_core_pipeline,bevy_ui,bevy_pbr,bevy_render,bevy_text,bevy_sprite,file_watcher,multi_threaded,std,async_executor,bevy_reflect/glam,bevy_reflect/uuid,bevy_reflect/smol_str,bevy_sprite/bevy_sprite_picking_backend
+default,bevy_asset,bevy_animation,bevy_core_pipeline,bevy_ui,bevy_pbr,bevy_render,bevy_text,bevy_sprite,file_watcher,multi_threaded,std,async_executor,bevy_reflect/glam,bevy_reflect/uuid,bevy_reflect/smol_str,bevy_sprite/bevy_sprite_picking_backend