ir: Search for compound structures when we have unexposed type and base class cursor.

src/ir/comp.rs

@@ -635,7 +635,7 @@ impl CompInfo {
                         ci.has_vtable = cur.is_virtual_base();
                     }
                     let type_id =
-                        Item::from_ty(&cur.cur_type(), None, None, ctx)
+                        Item::from_ty(&cur.cur_type(), Some(cur), None, ctx)
                             .expect("BaseSpecifier");
                     ci.base_members.push(type_id);
                 }
@@ -763,6 +763,7 @@ impl CompInfo {
             CXCursor_UnionDecl => CompKind::Union,
             CXCursor_ClassDecl |
             CXCursor_StructDecl => CompKind::Struct,
+            CXCursor_CXXBaseSpecifier |
             CXCursor_ClassTemplatePartialSpecialization |
             CXCursor_ClassTemplate => {
                 match cursor.template_kind() {

src/ir/item.rs

@@ -1043,8 +1043,7 @@ impl ClangItemParser for Item {
                     }
                 }
                 // If we have recursed into the AST all we know, and we still
-                // haven't found what we've got, let's
-                // just make a named type.
+                // haven't found what we've got, let's just make a named type.
                 //
                 // This is what happens with some template members, for example.
                 //

src/ir/ty.rs

@@ -540,8 +540,56 @@ impl Type {
                 } else if let Some(location) = location {
                     match location.kind() {
                         CXCursor_ClassTemplatePartialSpecialization |
+                        CXCursor_CXXBaseSpecifier |
                         CXCursor_ClassTemplate => {
-                            name = location.spelling();
+                            if location.kind() == CXCursor_CXXBaseSpecifier {
+                                // In the case we're parsing a base specifier
+                                // inside an unexposed or invalid type, it means
+                                // that we're parsing one of two things:
+                                //
+                                //  * A template parameter.
+                                //  * A complex class that isn't exposed.
+                                //
+                                // This means, unfortunately, that there's no
+                                // good way to differentiate between them.
+                                //
+                                // Probably we could try to look at the
+                                // declaration and complicate more this logic,
+                                // but we'll keep it simple... if it's a valid
+                                // C++ identifier, we'll consider it as a
+                                // template parameter.
+                                //
+                                // This is because:
+                                //
+                                //  * We expect every other base that is a
+                                //    proper identifier (that is, a simple
+                                //    struct/union declaration), to be exposed,
+                                //    so this path can't be reached in that
+                                //    case.
+                                //
+                                //  * Quite conveniently, complex base
+                                //    specifiers preserve their full names (that
+                                //    is: Foo<T> instead of Foo). We can take
+                                //    advantage of this.
+                                //
+                                // If we find some edge case where this doesn't
+                                // work (which I guess is unlikely, see the
+                                // different test cases[1][2][3][4]), we'd need
+                                // to find more creative ways of differentiating
+                                // these two cases.
+                                //
+                                // [1]: inherit_named.hpp
+                                // [2]: forward-inherit-struct-with-fields.hpp
+                                // [3]: forward-inherit-struct.hpp
+                                // [4]: inherit-namespaced.hpp
+                                if location.spelling()
+                                    .chars()
+                                    .all(|c| c.is_alphanumeric() || c == '_') {
+                                    return Err(ParseError::Recurse);
+                                }
+                            } else {
+                                name = location.spelling();
+                            }
                             let complex = CompInfo::from_ty(potential_id,
                                                             ty,
                                                             Some(location),

tests/expectations/tests/forward-inherit-struct-with-fields.rs

@@ -0,0 +1,17 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Rooted<T> {
+    pub _base: RootedBase<T>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct RootedBase<T> {
+    pub foo: *mut T,
+    pub next: *mut Rooted<T>,
+}

tests/expectations/tests/forward-inherit-struct.rs

@@ -0,0 +1,18 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Rooted<T> {
+    pub _address: u8,
+    pub _phantom_0: ::std::marker::PhantomData<T>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct RootedBase<T> {
+    pub _address: u8,
+    pub _phantom_0: ::std::marker::PhantomData<T>,
+}

tests/expectations/tests/inherit-namespaced.rs

@@ -0,0 +1,18 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct RootedBase<T> {
+    pub _address: u8,
+    pub _phantom_0: ::std::marker::PhantomData<T>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Rooted<T> {
+    pub _address: u8,
+    pub _phantom_0: ::std::marker::PhantomData<T>,
+}

tests/expectations/tests/multiple-inherit-empty-correct-layout.rs

@@ -0,0 +1,45 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(::std::mem::size_of::<Foo>() , 1usize);
+    assert_eq!(::std::mem::align_of::<Foo>() , 1usize);
+}
+impl Clone for Foo {
+    fn clone(&self) -> Self { *self }
+}
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct Bar {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    assert_eq!(::std::mem::size_of::<Bar>() , 1usize);
+    assert_eq!(::std::mem::align_of::<Bar>() , 1usize);
+}
+impl Clone for Bar {
+    fn clone(&self) -> Self { *self }
+}
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct Baz {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Baz() {
+    assert_eq!(::std::mem::size_of::<Baz>() , 1usize);
+    assert_eq!(::std::mem::align_of::<Baz>() , 1usize);
+}
+impl Clone for Baz {
+    fn clone(&self) -> Self { *self }
+}

tests/headers/forward-inherit-struct-with-fields.hpp

@@ -0,0 +1,8 @@
+template <typename> class Rooted;
+namespace js {
+    template <typename T> class RootedBase {
+      T* foo;
+      Rooted<T>* next;
+    };
+}
+template <typename T> class Rooted : js::RootedBase<T> {};

tests/headers/forward-inherit-struct.hpp

@@ -0,0 +1,5 @@
+template <typename> class Rooted;
+namespace js {
+    template <typename T> class RootedBase {};
+}
+template <typename T> class Rooted : js::RootedBase<T> {};

tests/headers/inherit-namespaced.hpp

@@ -0,0 +1,4 @@
+namespace js {
+    template <typename T> class RootedBase {};
+}
+template <typename T> class Rooted : js::RootedBase<T> {};

tests/headers/multiple-inherit-empty-correct-layout.hpp

@@ -0,0 +1,3 @@
+struct Foo {};
+struct Bar {};
+struct Baz : public Foo, public Bar {};