ir: consider all nested definitions inside structs to be inner types.

Fixes rust-lang#643

Author: emilio

src/ir/comp.rs

@@ -588,21 +588,19 @@ impl CompInfo {
                 CXCursor_ClassTemplate |
                 CXCursor_ClassDecl => {
                     // We can find non-semantic children here, clang uses a
-                    // StructDecl to note incomplete structs that hasn't been
-                    // forward-declared before, see:
+                    // StructDecl to note incomplete structs that haven't been
+                    // forward-declared before, see [1].
                     //
                     // Also, clang seems to scope struct definitions inside
-                    // unions to the whole translation unit. Since those are
-                    // anonymous, let's just assume that if the cursor we've
-                    // found is a definition it's a valid inner type.
+                    // unions, and other named struct definitions inside other
+                    // structs to the whole translation unit.
                     //
-                    // Note that doing this could be always ok, but let's just
-                    // keep the union check for now.
+                    // Let's just assume that if the cursor we've found is a
+                    // definition, it's a valid inner type.
                     //
-                    // https://github.com/servo/rust-bindgen/issues/482
+                    // [1]: https://github.com/servo/rust-bindgen/issues/482
                     let is_inner_struct = cur.semantic_parent() == cursor ||
-                                          (kind == CompKind::Union &&
-                                           cur.is_definition());
+                                          cur.is_definition();
                     if !is_inner_struct {
                         return CXChildVisit_Continue;
                     }

tests/expectations/tests/issue-643-inner-struct.rs

@@ -0,0 +1,182 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>);
+impl <T> __IncompleteArrayField<T> {
+    #[inline]
+    pub fn new() -> Self {
+        __IncompleteArrayField(::std::marker::PhantomData)
+    }
+    #[inline]
+    pub unsafe fn as_ptr(&self) -> *const T { ::std::mem::transmute(self) }
+    #[inline]
+    pub unsafe fn as_mut_ptr(&mut self) -> *mut T {
+        ::std::mem::transmute(self)
+    }
+    #[inline]
+    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+        ::std::slice::from_raw_parts(self.as_ptr(), len)
+    }
+    #[inline]
+    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+    }
+}
+impl <T> ::std::fmt::Debug for __IncompleteArrayField<T> {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        fmt.write_str("__IncompleteArrayField")
+    }
+}
+impl <T> ::std::clone::Clone for __IncompleteArrayField<T> {
+    #[inline]
+    fn clone(&self) -> Self { Self::new() }
+}
+impl <T> ::std::marker::Copy for __IncompleteArrayField<T> { }
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct rte_ring {
+    /**< Name of the ring. */
+    pub name: [::std::os::raw::c_char; 4usize],
+    /**< Flags supplied at creation. */
+    pub flags: ::std::os::raw::c_int,
+    pub memzone: *mut rte_memzone,
+    pub prod: rte_ring_prod,
+    pub cons: rte_ring_cons,
+    /**< Memory space of ring starts here.
+                                             * not volatile so need to be careful
+                                             * about compiler re-ordering */
+    pub ring: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
+}
+/** Ring producer status. */
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct rte_ring_prod {
+    /**< Maximum items before EDQUOT. */
+    pub watermark: u32,
+    /**< True, if single producer. */
+    pub sp_enqueue: u32,
+    /**< Size of ring. */
+    pub size: u32,
+    /**< Mask (size-1) of ring. */
+    pub mask: u32,
+    /**< Producer head. */
+    pub head: u32,
+    /**< Producer tail. */
+    pub tail: u32,
+}
+#[test]
+fn bindgen_test_layout_rte_ring_prod() {
+    assert_eq!(::std::mem::size_of::<rte_ring_prod>() , 24usize , concat ! (
+               "Size of: " , stringify ! ( rte_ring_prod ) ));
+    assert_eq! (::std::mem::align_of::<rte_ring_prod>() , 4usize , concat ! (
+                "Alignment of " , stringify ! ( rte_ring_prod ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_prod ) ) . watermark as * const
+                _ as usize } , 0usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_prod ) , "::"
+                , stringify ! ( watermark ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_prod ) ) . sp_enqueue as * const
+                _ as usize } , 4usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_prod ) , "::"
+                , stringify ! ( sp_enqueue ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_prod ) ) . size as * const _ as
+                usize } , 8usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_prod ) , "::"
+                , stringify ! ( size ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_prod ) ) . mask as * const _ as
+                usize } , 12usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_prod ) , "::"
+                , stringify ! ( mask ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_prod ) ) . head as * const _ as
+                usize } , 16usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_prod ) , "::"
+                , stringify ! ( head ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_prod ) ) . tail as * const _ as
+                usize } , 20usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_prod ) , "::"
+                , stringify ! ( tail ) ));
+}
+impl Clone for rte_ring_prod {
+    fn clone(&self) -> Self { *self }
+}
+/** Ring consumer status. */
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct rte_ring_cons {
+    /**< True, if single consumer. */
+    pub sc_dequeue: u32,
+    /**< Size of the ring. */
+    pub size: u32,
+    /**< Mask (size-1) of ring. */
+    pub mask: u32,
+    /**< Consumer head. */
+    pub head: u32,
+    /**< Consumer tail. */
+    pub tail: u32,
+}
+#[test]
+fn bindgen_test_layout_rte_ring_cons() {
+    assert_eq!(::std::mem::size_of::<rte_ring_cons>() , 20usize , concat ! (
+               "Size of: " , stringify ! ( rte_ring_cons ) ));
+    assert_eq! (::std::mem::align_of::<rte_ring_cons>() , 4usize , concat ! (
+                "Alignment of " , stringify ! ( rte_ring_cons ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_cons ) ) . sc_dequeue as * const
+                _ as usize } , 0usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_cons ) , "::"
+                , stringify ! ( sc_dequeue ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_cons ) ) . size as * const _ as
+                usize } , 4usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_cons ) , "::"
+                , stringify ! ( size ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_cons ) ) . mask as * const _ as
+                usize } , 8usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_cons ) , "::"
+                , stringify ! ( mask ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_cons ) ) . head as * const _ as
+                usize } , 12usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_cons ) , "::"
+                , stringify ! ( head ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_ring_cons ) ) . tail as * const _ as
+                usize } , 16usize , concat ! (
+                "Alignment of field: " , stringify ! ( rte_ring_cons ) , "::"
+                , stringify ! ( tail ) ));
+}
+impl Clone for rte_ring_cons {
+    fn clone(&self) -> Self { *self }
+}
+#[test]
+fn bindgen_test_layout_rte_ring() {
+    assert_eq!(::std::mem::size_of::<rte_ring>() , 64usize , concat ! (
+               "Size of: " , stringify ! ( rte_ring ) ));
+    assert_eq! (::std::mem::align_of::<rte_ring>() , 8usize , concat ! (
+                "Alignment of " , stringify ! ( rte_ring ) ));
+}
+impl Clone for rte_ring {
+    fn clone(&self) -> Self { *self }
+}
+impl Default for rte_ring {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct rte_memzone {
+    pub _address: u8,
+}
+impl Clone for rte_memzone {
+    fn clone(&self) -> Self { *self }
+}

tests/headers/issue-643-inner-struct.h

@@ -0,0 +1,38 @@
+typedef unsigned uint32_t;
+#define __rte_cache_aligned
+
+// Insert your (minimal) C/C++ header here
+struct rte_ring {
+        /*
+         * Note: this field kept the RTE_MEMZONE_NAMESIZE size due to ABI
+         * compatibility requirements, it could be changed to RTE_RING_NAMESIZE
+         * next time the ABI changes
+         */
+        char name[4];    /**< Name of the ring. */
+        int flags;                       /**< Flags supplied at creation. */
+        const struct rte_memzone *memzone;
+                        /**< Memzone, if any, containing the rte_ring */
+
+        /** Ring producer status. */
+        struct prod {
+                uint32_t watermark;      /**< Maximum items before EDQUOT. */
+                uint32_t sp_enqueue;     /**< True, if single producer. */
+                uint32_t size;           /**< Size of ring. */
+                uint32_t mask;           /**< Mask (size-1) of ring. */
+                volatile uint32_t head;  /**< Producer head. */
+                volatile uint32_t tail;  /**< Producer tail. */
+        } prod __rte_cache_aligned;
+
+        /** Ring consumer status. */
+        struct cons {
+                uint32_t sc_dequeue;     /**< True, if single consumer. */
+                uint32_t size;           /**< Size of the ring. */
+                uint32_t mask;           /**< Mask (size-1) of ring. */
+                volatile uint32_t head;  /**< Consumer head. */
+                volatile uint32_t tail;  /**< Consumer tail. */
+        } cons;
+
+        void *ring[] __rte_cache_aligned;   /**< Memory space of ring starts here.
+                                             * not volatile so need to be careful
+                                             * about compiler re-ordering */
+};