Generalize NamespaceEntries to generic Hierarchy builder

#382

Author: dtolnay

gen/src/mod.rs

@@ -10,7 +10,6 @@ pub(super) mod fs;
 mod ifndef;
 pub(super) mod include;
 mod namespace;
-mod nested;
 pub(super) mod out;
 mod write;
 

gen/src/nested.rs

@@ -1,8 +1,8 @@
 use crate::gen::block::Block;
-use crate::gen::nested::NamespaceEntries;
 use crate::gen::out::OutFile;
 use crate::gen::{builtin, include, Opt};
 use crate::syntax::atom::Atom::{self, *};
+use crate::syntax::hierarchy::Hierarchy;
 use crate::syntax::instantiate::ImplKey;
 use crate::syntax::map::UnorderedMap as Map;
 use crate::syntax::set::UnorderedSet;
@@ -39,12 +39,12 @@ fn write_forward_declarations(out: &mut OutFile, apis: &[Api]) {
         _ => false,
     };
 
-    let apis_by_namespace =
-        NamespaceEntries::new(apis.iter().filter(needs_forward_declaration).collect());
+    let forward_apis = apis.iter().filter(needs_forward_declaration).collect();
+    let apis_by_namespace = Hierarchy::new(forward_apis, Api::namespace);
 
     write(out, &apis_by_namespace, 0);
 
-    fn write(out: &mut OutFile, ns_entries: &NamespaceEntries, indent: usize) {
+    fn write(out: &mut OutFile, ns_entries: &Hierarchy<Ident, Api>, indent: usize) {
         let apis = ns_entries.direct_content();
 
         for api in apis {

gen/src/write.rs

@@ -0,0 +1,58 @@
+use crate::syntax::map::UnorderedMap as Map;
+use std::hash::Hash;
+
+pub struct Hierarchy<'a, K, T> {
+    direct: Vec<&'a T>,
+    nested: Vec<(&'a K, Hierarchy<'a, K, T>)>,
+}
+
+impl<'a, K, T> Hierarchy<'a, K, T> {
+    pub fn new<F, I>(items: Vec<&'a T>, keyfn: F) -> Self
+    where
+        K: Hash + Eq,
+        F: Fn(&'a T) -> I,
+        I: IntoIterator<Item = &'a K>,
+    {
+        sort_by_level(items, &keyfn, 0)
+    }
+
+    pub fn direct_content(&self) -> &[&'a T] {
+        &self.direct
+    }
+
+    pub fn nested_content(&self) -> impl Iterator<Item = (&'a K, &Hierarchy<'a, K, T>)> {
+        self.nested.iter().map(|(k, entries)| (*k, entries))
+    }
+}
+
+fn sort_by_level<'a, K, T, F, I>(items: Vec<&'a T>, keyfn: &F, depth: usize) -> Hierarchy<'a, K, T>
+where
+    K: Hash + Eq,
+    F: Fn(&'a T) -> I,
+    I: IntoIterator<Item = &'a K>,
+{
+    let mut direct = Vec::new();
+    let mut nested_levels = Vec::new();
+    let mut index_of_levels = Map::new();
+
+    for item in items {
+        if let Some(elem) = keyfn(item).into_iter().nth(depth) {
+            match index_of_levels.get(elem) {
+                None => {
+                    index_of_levels.insert(elem, nested_levels.len());
+                    nested_levels.push((elem, vec![item]));
+                }
+                Some(&index) => nested_levels[index].1.push(item),
+            }
+            continue;
+        }
+        direct.push(item);
+    }
+
+    let nested = nested_levels
+        .into_iter()
+        .map(|(k, items)| (k, sort_by_level(items, keyfn, depth + 1)))
+        .collect();
+
+    Hierarchy { direct, nested }
+}

syntax/hierarchy.rs

@@ -8,6 +8,7 @@ mod discriminant;
 mod doc;
 pub mod error;
 pub mod file;
+pub mod hierarchy;
 pub mod ident;
 mod impls;
 mod improper;