Ensure that every item is in some module's children list

Previously, if an item's parent was not a module (eg a nested class definition
whose parent it the outer class definition) and the parent was not whitelisted
but the item was transitively whitelisted, then we could generate uses of the
item without emitting any definition for it. This could happen because we were
relying on the outer type calling for code generation on its inner types, but
that relies on us doing code generation for the outer type, which won't happen
if the outer type is not whitelisted.

This commit avoids this gotcha by ensuring that all items end up in a module's
children list, and so will be code generated even if their parent is not
whitelisted.

Fixes rust-lang#769

src/codegen/mod.rs

@@ -435,6 +435,16 @@ impl CodeGenerator for Var {
         }
         result.saw_var(&canonical_name);
 
+        // We can't generate bindings to static variables of templates. The
+        // number of actual variables for a single declaration are open ended
+        // and we don't know what instantiations do or don't exist.
+        let type_params = item.all_template_params(ctx);
+        if let Some(params) = type_params {
+            if !params.is_empty() {
+                return;
+            }
+        }
+
         let ty = self.ty().to_rust_ty_or_opaque(ctx, &());
 
         if let Some(val) = self.val() {
@@ -759,8 +769,11 @@ impl CodeGenerator for TemplateInstantiation {
             let align = layout.align;
 
             let name = item.canonical_name(ctx);
-            let fn_name = format!("__bindgen_test_layout_{}_instantiation_{}",
-                                  name, item.exposed_id(ctx));
+            let mut fn_name = format!("__bindgen_test_layout_{}_instantiation", name);
+            let times_seen = result.overload_number(&fn_name);
+            if times_seen > 0 {
+                write!(&mut fn_name, "_{}", times_seen).unwrap();
+            }
 
             let fn_name = ctx.rust_ident_raw(&fn_name);
 

src/ir/context.rs

@@ -348,14 +348,31 @@ impl<'ctx> BindgenContext<'ctx> {
         let is_template_instantiation =
             is_type && item.expect_type().is_template_instantiation();
 
-        // Be sure to track all the generated children under namespace, even
-        // those generated after resolving typerefs, etc.
+        // Ensure that every item (other than the root module) is in a module's
+        // children list.
         if item.id() != item.parent_id() {
+            let mut added_as_child = false;
+
             if let Some(mut parent) = self.items.get_mut(&item.parent_id()) {
                 if let Some(mut module) = parent.as_module_mut() {
                     module.children_mut().push(item.id());
+                    added_as_child = true;
                 }
             }
+
+            if !added_as_child {
+                if let Some(mut current_module) = self.items.get_mut(&self.current_module) {
+                    current_module.as_module_mut()
+                        .expect("self.current_module should always be a module")
+                        .children_mut()
+                        .push(item.id());
+                    added_as_child = true;
+                }
+            }
+
+            assert!(added_as_child,
+                    "We should have added the item as a child of its parent \
+                     module or the current module");
         }
 
         if is_type && item.expect_type().is_comp() {

tests/expectations/tests/16-byte-alignment.rs

@@ -30,20 +30,6 @@ impl <T> ::std::fmt::Debug for __BindgenUnionField<T> {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy)]
-pub struct rte_ipv4_tuple {
-    pub src_addr: u32,
-    pub dst_addr: u32,
-    pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy)]
-pub struct rte_ipv4_tuple__bindgen_ty_1 {
-    pub __bindgen_anon_1: __BindgenUnionField<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>,
-    pub sctp_tag: __BindgenUnionField<u32>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy)]
 pub struct rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1 {
     pub dport: u16,
     pub sport: u16,
@@ -76,6 +62,13 @@ fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1() {
 impl Clone for rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1 {
     fn clone(&self) -> Self { *self }
 }
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct rte_ipv4_tuple__bindgen_ty_1 {
+    pub __bindgen_anon_1: __BindgenUnionField<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>,
+    pub sctp_tag: __BindgenUnionField<u32>,
+    pub bindgen_union_field: u32,
+}
 #[test]
 fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1() {
     assert_eq!(::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1>() , 4usize
@@ -95,6 +88,13 @@ fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1() {
 impl Clone for rte_ipv4_tuple__bindgen_ty_1 {
     fn clone(&self) -> Self { *self }
 }
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct rte_ipv4_tuple {
+    pub src_addr: u32,
+    pub dst_addr: u32,
+    pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1,
+}
 #[test]
 fn bindgen_test_layout_rte_ipv4_tuple() {
     assert_eq!(::std::mem::size_of::<rte_ipv4_tuple>() , 12usize , concat ! (
@@ -117,20 +117,6 @@ impl Clone for rte_ipv4_tuple {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy)]
-pub struct rte_ipv6_tuple {
-    pub src_addr: [u8; 16usize],
-    pub dst_addr: [u8; 16usize],
-    pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy)]
-pub struct rte_ipv6_tuple__bindgen_ty_1 {
-    pub __bindgen_anon_1: __BindgenUnionField<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>,
-    pub sctp_tag: __BindgenUnionField<u32>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy)]
 pub struct rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1 {
     pub dport: u16,
     pub sport: u16,
@@ -163,6 +149,13 @@ fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1() {
 impl Clone for rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1 {
     fn clone(&self) -> Self { *self }
 }
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct rte_ipv6_tuple__bindgen_ty_1 {
+    pub __bindgen_anon_1: __BindgenUnionField<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>,
+    pub sctp_tag: __BindgenUnionField<u32>,
+    pub bindgen_union_field: u32,
+}
 #[test]
 fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1() {
     assert_eq!(::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1>() , 4usize
@@ -182,6 +175,13 @@ fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1() {
 impl Clone for rte_ipv6_tuple__bindgen_ty_1 {
     fn clone(&self) -> Self { *self }
 }
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct rte_ipv6_tuple {
+    pub src_addr: [u8; 16usize],
+    pub dst_addr: [u8; 16usize],
+    pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1,
+}
 #[test]
 fn bindgen_test_layout_rte_ipv6_tuple() {
     assert_eq!(::std::mem::size_of::<rte_ipv6_tuple>() , 36usize , concat ! (

tests/expectations/tests/381-decltype-alias.rs

@@ -4,9 +4,9 @@
 #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
 
 
+pub type std_allocator_traits___size_type<_Alloc> = _Alloc;
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct std_allocator_traits {
     pub _address: u8,
 }
-pub type std_allocator_traits___size_type<_Alloc> = _Alloc;

tests/expectations/tests/anon_enum.rs

@@ -4,16 +4,16 @@
 #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
 
 
+pub const Test_T_NONE: Test__bindgen_ty_1 = Test__bindgen_ty_1::T_NONE;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum Test__bindgen_ty_1 { T_NONE = 0, }
 #[repr(C)]
 #[derive(Debug, Default, Copy)]
 pub struct Test {
     pub foo: ::std::os::raw::c_int,
     pub bar: f32,
 }
-pub const Test_T_NONE: Test__bindgen_ty_1 = Test__bindgen_ty_1::T_NONE;
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub enum Test__bindgen_ty_1 { T_NONE = 0, }
 #[test]
 fn bindgen_test_layout_Test() {
     assert_eq!(::std::mem::size_of::<Test>() , 8usize , concat ! (

tests/expectations/tests/anon_enum_trait.rs

@@ -4,11 +4,6 @@
 #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
 
 
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct DataType {
-    pub _address: u8,
-}
 pub type DataType_value_type<_Tp> = _Tp;
 pub type DataType_work_type<_Tp> = DataType_value_type<_Tp>;
 pub type DataType_channel_type<_Tp> = DataType_value_type<_Tp>;
@@ -27,15 +22,20 @@ pub const DataType_type_: DataType__bindgen_ty_1 =
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum DataType__bindgen_ty_1 { generic_type = 0, }
 #[repr(C)]
-#[derive(Debug, Default, Copy)]
-pub struct Foo {
+#[derive(Debug, Default, Copy, Clone)]
+pub struct DataType {
     pub _address: u8,
 }
 pub const Foo_Bar: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar;
 pub const Foo_Baz: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar;
 #[repr(u32)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Foo__bindgen_ty_1 { Bar = 0, }
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct Foo {
+    pub _address: u8,
+}
 #[test]
 fn bindgen_test_layout_Foo() {
     assert_eq!(::std::mem::size_of::<Foo>() , 1usize , concat ! (

tests/expectations/tests/anon_struct_in_union.rs

@@ -30,17 +30,6 @@ impl <T> ::std::fmt::Debug for __BindgenUnionField<T> {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy)]
-pub struct s {
-    pub u: s__bindgen_ty_1,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy)]
-pub struct s__bindgen_ty_1 {
-    pub field: __BindgenUnionField<s__bindgen_ty_1_inner>,
-    pub bindgen_union_field: u32,
-}
-#[repr(C)]
-#[derive(Debug, Default, Copy)]
 pub struct s__bindgen_ty_1_inner {
     pub b: ::std::os::raw::c_int,
 }
@@ -61,6 +50,12 @@ fn bindgen_test_layout_s__bindgen_ty_1_inner() {
 impl Clone for s__bindgen_ty_1_inner {
     fn clone(&self) -> Self { *self }
 }
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct s__bindgen_ty_1 {
+    pub field: __BindgenUnionField<s__bindgen_ty_1_inner>,
+    pub bindgen_union_field: u32,
+}
 #[test]
 fn bindgen_test_layout_s__bindgen_ty_1() {
     assert_eq!(::std::mem::size_of::<s__bindgen_ty_1>() , 4usize , concat ! (
@@ -76,6 +71,11 @@ fn bindgen_test_layout_s__bindgen_ty_1() {
 impl Clone for s__bindgen_ty_1 {
     fn clone(&self) -> Self { *self }
 }
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct s {
+    pub u: s__bindgen_ty_1,
+}
 #[test]
 fn bindgen_test_layout_s() {
     assert_eq!(::std::mem::size_of::<s>() , 4usize , concat ! (

tests/expectations/tests/anon_union.rs

@@ -28,14 +28,6 @@ impl <T> ::std::fmt::Debug for __BindgenUnionField<T> {
         fmt.write_str("__BindgenUnionField")
     }
 }
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct TErrorResult {
-    pub mResult: ::std::os::raw::c_int,
-    pub __bindgen_anon_1: TErrorResult__bindgen_ty_1,
-    pub mMightHaveUnreported: bool,
-    pub mUnionState: TErrorResult_UnionState,
-}
 pub const TErrorResult_UnionState_HasException: TErrorResult_UnionState =
     TErrorResult_UnionState::HasMessage;
 #[repr(i32)]
@@ -58,6 +50,14 @@ pub struct TErrorResult__bindgen_ty_1 {
     pub mDOMExceptionInfo: __BindgenUnionField<*mut TErrorResult_DOMExceptionInfo>,
     pub bindgen_union_field: u64,
 }
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct TErrorResult {
+    pub mResult: ::std::os::raw::c_int,
+    pub __bindgen_anon_1: TErrorResult__bindgen_ty_1,
+    pub mMightHaveUnreported: bool,
+    pub mUnionState: TErrorResult_UnionState,
+}
 impl Default for TErrorResult {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
@@ -80,7 +80,7 @@ impl Default for ErrorResult {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
 #[test]
-fn __bindgen_test_layout_TErrorResult_instantiation_1() {
+fn __bindgen_test_layout_TErrorResult_instantiation() {
     assert_eq!(::std::mem::size_of::<TErrorResult>() , 24usize , concat ! (
                "Size of template specialization: " , stringify ! (
                TErrorResult ) ));

tests/expectations/tests/bitfield-enum-basic.rs

@@ -95,11 +95,6 @@ impl ::std::ops::BitAndAssign for _bindgen_ty_1 {
 #[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct _bindgen_ty_1(pub ::std::os::raw::c_uint);
-#[repr(C)]
-#[derive(Debug, Default, Copy)]
-pub struct Dummy {
-    pub _address: u8,
-}
 pub const Dummy_DUMMY_FOO: Dummy__bindgen_ty_1 = Dummy__bindgen_ty_1(1);
 pub const Dummy_DUMMY_BAR: Dummy__bindgen_ty_1 = Dummy__bindgen_ty_1(2);
 impl ::std::ops::BitOr<Dummy__bindgen_ty_1> for Dummy__bindgen_ty_1 {
@@ -133,6 +128,11 @@ impl ::std::ops::BitAndAssign for Dummy__bindgen_ty_1 {
 #[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct Dummy__bindgen_ty_1(pub ::std::os::raw::c_uint);
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct Dummy {
+    pub _address: u8,
+}
 #[test]
 fn bindgen_test_layout_Dummy() {
     assert_eq!(::std::mem::size_of::<Dummy>() , 1usize , concat ! (

tests/expectations/tests/bitfield-method-same-name.rs

@@ -4,6 +4,18 @@
 #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
 
 
+extern "C" {
+    #[link_name = "_ZN3Foo4typeEv"]
+    pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_char;
+}
+extern "C" {
+    #[link_name = "_ZN3Foo9set_type_Ec"]
+    pub fn Foo_set_type_(this: *mut Foo, c: ::std::os::raw::c_char);
+}
+extern "C" {
+    #[link_name = "_ZN3Foo8set_typeEc"]
+    pub fn Foo_set_type(this: *mut Foo, c: ::std::os::raw::c_char);
+}
 #[repr(C)]
 #[derive(Debug, Default, Copy)]
 pub struct Foo {
@@ -17,18 +29,6 @@ fn bindgen_test_layout_Foo() {
     assert_eq! (::std::mem::align_of::<Foo>() , 1usize , concat ! (
                 "Alignment of " , stringify ! ( Foo ) ));
 }
-extern "C" {
-    #[link_name = "_ZN3Foo4typeEv"]
-    pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_char;
-}
-extern "C" {
-    #[link_name = "_ZN3Foo9set_type_Ec"]
-    pub fn Foo_set_type_(this: *mut Foo, c: ::std::os::raw::c_char);
-}
-extern "C" {
-    #[link_name = "_ZN3Foo8set_typeEc"]
-    pub fn Foo_set_type(this: *mut Foo, c: ::std::os::raw::c_char);
-}
 impl Clone for Foo {
     fn clone(&self) -> Self { *self }
 }