Output fully-qualified names.

This change:
* Outputs fully-qualified C++ names wherever possible
  or appropriate;
* Supports outputting content belonging to different
  namespaces.

This change should have no functional effect, because
at the moment the only way to set up a namespace is still
to configure the overall [cxx::bridge] with a namespace
attribute. However, in theory, it should allow finer-grained
namespaces to be supported in subsequent commits. In theory,
it should be possible for items in one namespace to correctly
reference another thanks to the fully qualified names.

Author: adetaylor

gen/src/mod.rs

@@ -5,6 +5,7 @@ pub(super) mod error;
 mod file;
 pub(super) mod fs;
 pub(super) mod include;
+mod namespace_organizer;
 pub(super) mod out;
 mod write;
 
@@ -119,12 +120,12 @@ pub(super) fn generate(syntax: File, opt: &Opt) -> Result<GeneratedCode> {
     // only need to generate one or the other.
     Ok(GeneratedCode {
         header: if opt.gen_header {
-            write::gen(namespace, apis, types, opt, true).content()
+            write::gen(apis, types, opt, true).content()
         } else {
             Vec::new()
         },
         implementation: if opt.gen_implementation {
-            write::gen(namespace, apis, types, opt, false).content()
+            write::gen(apis, types, opt, false).content()
         } else {
             Vec::new()
         },

gen/src/namespace_organizer.rs

@@ -0,0 +1,40 @@
+use crate::syntax::Api;
+use proc_macro2::Ident;
+use std::collections::HashMap;
+
+pub(crate) struct NamespaceEntries<'a> {
+    pub(crate) entries: Vec<&'a Api>,
+    pub(crate) children: HashMap<&'a Ident, NamespaceEntries<'a>>,
+}
+
+pub(crate) fn sort_by_namespace(apis: &[Api]) -> NamespaceEntries {
+    let api_refs = apis.iter().collect::<Vec<_>>();
+    sort_by_inner_namespace(api_refs, 0)
+}
+
+fn sort_by_inner_namespace(apis: Vec<&Api>, depth: usize) -> NamespaceEntries {
+    let mut root = NamespaceEntries {
+        entries: Vec::new(),
+        children: HashMap::new(),
+    };
+
+    let mut kids_by_child_ns = HashMap::new();
+    for api in apis {
+        if let Some(ns) = api.get_namespace() {
+            let first_ns_elem = ns.iter().skip(depth).next();
+            if let Some(first_ns_elem) = first_ns_elem {
+                let list = kids_by_child_ns.entry(first_ns_elem).or_insert(Vec::new());
+                list.push(api);
+                continue;
+            }
+        }
+        root.entries.push(api);
+    }
+
+    for (k, v) in kids_by_child_ns.into_iter() {
+        root.children
+            .insert(k, sort_by_inner_namespace(v, depth + 1));
+    }
+
+    root
+}

gen/src/out.rs

@@ -1,10 +1,8 @@
 use crate::gen::include::Includes;
-use crate::syntax::namespace::Namespace;
 use std::cell::RefCell;
 use std::fmt::{self, Arguments, Write};
 
 pub(crate) struct OutFile {
-    pub namespace: Namespace,
     pub header: bool,
     pub include: Includes,
     pub front: Content,
@@ -18,9 +16,8 @@ pub struct Content {
 }
 
 impl OutFile {
-    pub fn new(namespace: Namespace, header: bool) -> Self {
+    pub fn new(header: bool) -> Self {
         OutFile {
-            namespace,
             header,
             include: Includes::new(),
             front: Content::new(),