Allow namespace override.

This change allows a

 #[namespace (namespace = A::B)]

attribute for each item in a cxx::bridge.

We now have a fair number of different types of name floating
around:
* C++ identifiers
* C++ fully-qualified names
* Rust identifiers
* Rust fully-qualified names (future, when we support sub-modules)
* Items with both a Rust and C++ name (a 'Pair')
* Types with only a known Rust name, which can be resolved to a
  C++ name.

This change attempts to put some sensible names for all these
things in syntax/mod.rs, and so that would be a good place to start
review.

At the moment, the Namespace (included in each CppName)
is ruthlessly cloned all over the place. As a given namespace is
likely to be applicable to many types and functions, it may
save significant memory in future to use Rc<> here. But let's not
optimise too early.

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;
 
@@ -109,22 +110,22 @@ pub(super) fn generate(syntax: File, opt: &Opt) -> Result<GeneratedCode> {
         .ok_or(Error::NoBridgeMod)?;
     let ref namespace = bridge.namespace;
     let trusted = bridge.unsafety.is_some();
-    let ref apis = syntax::parse_items(errors, bridge.content, trusted);
+    let ref apis = syntax::parse_items(errors, bridge.content, trusted, namespace);
     let ref types = Types::collect(errors, apis);
     errors.propagate()?;
-    check::typecheck(errors, namespace, apis, types);
+    check::typecheck(errors, apis, types);
     errors.propagate()?;
     // Some callers may wish to generate both header and C++
     // from the same token stream to avoid parsing twice. But others
     // 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::BTreeMap;
+
+pub(crate) struct NamespaceEntries<'a> {
+    pub(crate) entries: Vec<&'a Api>,
+    pub(crate) children: BTreeMap<&'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: BTreeMap::new(),
+    };
+
+    let mut kids_by_child_ns = BTreeMap::new();
+    for api in apis {
+        if let Some(ns) = api.get_namespace() {
+            let first_ns_elem = ns.iter().nth(depth);
+            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(),