Prevent emission of type aliases in root module for inner types

 * Emit aliases in the nearest ancestor module if the parent is not a
   module, rather than in the root module
 * If an alias would refer to itself, don't emit it (this is really a
   workaround for the fact that names are sometimes not unique enough,
   e.g. the header in rust-lang#2056 produces two items called f_iterator)

Author: jbg

bindgen-tests/tests/expectations/tests/opaque-template-instantiation-namespaced.rs

@@ -499,6 +499,36 @@ impl Item {
             return false;
         }
 
+        // Skip duplicate type aliases.
+        // If this item is a type alias or resolved ref, and its ultimate target
+        // has the same canonical path and will also be generated, skip this one.
+        if let ItemKind::Type(ty) = self.kind() {
+            match ty.kind() {
+                TypeKind::Alias(target_id) |
+                TypeKind::ResolvedTypeRef(target_id) => {
+                    let direct_target = ctx.resolve_item(*target_id);
+                    // Check if the direct target has the same path and will be generated.
+                    // If so, skip generating this alias/ref because the direct target
+                    // will either be generated or skipped in favour of its target.
+                    if direct_target.id() != self.id() &&
+                        direct_target.canonical_path(ctx) ==
+                            self.canonical_path(ctx) &&
+                        ctx.codegen_items().contains(&direct_target.id())
+                    {
+                        debug!(
+                            "<Item as CodeGenerator>::process_before_codegen: Skipping duplicate alias {:?} because its direct target {:?} has the same path and will be generated",
+                            self.id(),
+                            direct_target.id()
+                        );
+                        // Mark as seen so we don't process it again if reachable through another path
+                        result.set_seen(self.id());
+                        return false;
+                    }
+                }
+                _ => {}
+            }
+        }
+
         if !ctx.codegen_items().contains(&self.id()) {
             // TODO(emilio, #453): Figure out what to do when this happens
             // legitimately, we could track the opaque stuff and disable the

bindgen/codegen/mod.rs

@@ -783,16 +783,31 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         assert_ne!(item.id(), self.root_module);
         assert!(self.resolve_item_fallible(item.id()).is_none());
 
-        if let Some(ref mut parent) = self.items[item.parent_id().0] {
-            if let Some(module) = parent.as_module_mut() {
-                debug!(
-                    "add_item_to_module: adding {:?} as child of parent module {:?}",
-                    item.id(),
-                    item.parent_id()
-                );
+        if let Some(parent_item) = self.resolve_item_fallible(item.parent_id())
+        {
+            let ancestor_module_id = if parent_item.is_module() {
+                Some(item.parent_id())
+            } else {
+                item.parent_id().ancestors(self).find(|id| {
+                    let ancestor_item = self.resolve_item_fallible(*id);
+                    ancestor_item.map_or(false, |i| i.is_module())
+                })
+            };
 
-                module.children_mut().insert(item.id());
-                return;
+            if let Some(ancestor_module_id) = ancestor_module_id {
+                if let Some(ref mut ancestor) = self.items[ancestor_module_id.0]
+                {
+                    if let Some(module) = ancestor.as_module_mut() {
+                        debug!(
+                            "add_item_to_module: adding {:?} as child of ancestor module {:?}",
+                            item.id(),
+                            ancestor_module_id
+                        );
+
+                        module.children_mut().insert(item.id());
+                        return;
+                    }
+                }
             }
         }
 

bindgen/ir/context.rs

@@ -1071,7 +1071,7 @@ impl Type {
                 CXType_Typedef => {
                     let inner = cursor.typedef_type().expect("Not valid Type?");
                     let inner_id =
-                        Item::from_ty_or_ref(inner, location, None, ctx);
+                        Item::from_ty_or_ref(inner, location, parent_id, ctx);
                     if inner_id == potential_id {
                         warn!(
                             "Generating opaque type instead of self-referential \