ir: Don't parse non-semantic-children cursor as inner structs.

Fixes: rust-lang#482

Author: emilio

src/codegen/mod.rs

@@ -519,8 +519,8 @@ impl CodeGenerator for Type {
             TypeKind::BlockPointer |
             TypeKind::Reference(..) |
             TypeKind::TemplateRef(..) |
-            TypeKind::Function(..) |
             TypeKind::ResolvedTypeRef(..) |
+            TypeKind::Function(..) |
             TypeKind::Named => {
                 // These items don't need code generation, they only need to be
                 // converted to rust types in fields, arguments, and such.
@@ -2057,7 +2057,7 @@ impl ToRustTy for Type {
                         .map(|arg| arg.to_rust_ty(ctx))
                         .collect::<Vec<_>>();
 
-                    path.segments.last_mut().unwrap().parameters = if 
+                    path.segments.last_mut().unwrap().parameters = if
                         template_args.is_empty() {
                         None
                     } else {

src/ir/comp.rs

@@ -605,11 +605,17 @@ impl CompInfo {
                 CXCursor_UnionDecl |
                 CXCursor_ClassTemplate |
                 CXCursor_ClassDecl => {
+                    // We can find non-semantic children here, see:
+                    // https://github.com/servo/rust-bindgen/issues/482
+                    if cur.semantic_parent() != cursor {
+                        return CXChildVisit_Continue;
+                    }
+
                     let inner = Item::parse(cur, Some(potential_id), ctx)
                         .expect("Inner ClassDecl");
-                    if !ci.inner_types.contains(&inner) {
-                        ci.inner_types.push(inner);
-                    }
+
+                    ci.inner_types.push(inner);
+
                     // A declaration of an union or a struct without name could
                     // also be an unnamed field, unfortunately.
                     if cur.spelling().is_empty() &&

tests/expectations/tests/class_nested.rs

@@ -22,6 +22,24 @@ fn bindgen_test_layout_A_B() {
 impl Clone for A_B {
     fn clone(&self) -> Self { *self }
 }
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct A_C {
+    pub baz: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_A_C() {
+    assert_eq!(::std::mem::size_of::<A_C>() , 4usize);
+    assert_eq!(::std::mem::align_of::<A_C>() , 4usize);
+}
+impl Clone for A_C {
+    fn clone(&self) -> Self { *self }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct A_D<T> {
+    pub foo: T,
+}
 #[test]
 fn bindgen_test_layout_A() {
     assert_eq!(::std::mem::size_of::<A>() , 4usize);
@@ -34,6 +52,15 @@ extern "C" {
     #[link_name = "var"]
     pub static mut var: A_B;
 }
+#[test]
+fn __bindgen_test_layout_template_1() {
+    assert_eq!(::std::mem::size_of::<A_D<::std::os::raw::c_int>>() , 4usize);
+    assert_eq!(::std::mem::align_of::<A_D<::std::os::raw::c_int>>() , 4usize);
+}
+extern "C" {
+    #[link_name = "baz"]
+    pub static mut baz: A_D<::std::os::raw::c_int>;
+}
 #[repr(C)]
 #[derive(Debug, Copy)]
 pub struct D {

tests/expectations/tests/struct_containing_forward_declared_struct.rs

@@ -7,20 +7,7 @@
 #[repr(C)]
 #[derive(Debug, Copy)]
 pub struct a {
-    pub val_a: *mut a_b,
-}
-#[repr(C)]
-#[derive(Debug, Copy)]
-pub struct a_b {
-    pub val_b: ::std::os::raw::c_int,
-}
-#[test]
-fn bindgen_test_layout_a_b() {
-    assert_eq!(::std::mem::size_of::<a_b>() , 4usize);
-    assert_eq!(::std::mem::align_of::<a_b>() , 4usize);
-}
-impl Clone for a_b {
-    fn clone(&self) -> Self { *self }
+    pub val_a: *mut b,
 }
 #[test]
 fn bindgen_test_layout_a() {
@@ -30,3 +17,16 @@ fn bindgen_test_layout_a() {
 impl Clone for a {
     fn clone(&self) -> Self { *self }
 }
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct b {
+    pub val_b: ::std::os::raw::c_int,
+}
+#[test]
+fn bindgen_test_layout_b() {
+    assert_eq!(::std::mem::size_of::<b>() , 4usize);
+    assert_eq!(::std::mem::align_of::<b>() , 4usize);
+}
+impl Clone for b {
+    fn clone(&self) -> Self { *self }
+}

tests/headers/class_nested.hpp

@@ -4,9 +4,21 @@ class A {
     class B {
         int member_b;
     };
+
+    class C;
+
+    template<typename T>
+    class D {
+      T foo;
+    };
+};
+
+class A::C {
+  int baz;
 };
 
 A::B var;
+A::D<int> baz;
 
 class D {
     A::B member;