c++: Detect an inner class declaration with the same name in a composite

Author: emilio

src/clang.rs

@@ -43,6 +43,12 @@ impl Cursor {
         mangling
     }
 
+    pub fn lexical_parent(&self) -> Cursor {
+        unsafe {
+            Cursor { x: clang_getCursorLexicalParent(self.x) }
+        }
+    }
+
     pub fn semantic_parent(&self) -> Cursor {
         unsafe {
             Cursor { x: clang_getCursorSemanticParent(self.x) }

src/lib.rs

@@ -1,6 +1,7 @@
 #![crate_name = "bindgen"]
 #![crate_type = "dylib"]
 #![feature(quote)]
+#![feature(borrow_state)]
 
 #![cfg_attr(feature = "clippy", feature(plugin))]
 #![cfg_attr(feature = "clippy", plugin(clippy))]

src/parser.rs

@@ -124,6 +124,7 @@ fn decl_name(ctx: &mut ClangParserCtx, cursor: &Cursor) -> Global {
                 };
 
                 let mut ci = CompInfo::new(spelling, ctx.current_module_id, filename, comment, kind, vec![], layout);
+                ci.parser_cursor = Some(cursor);
 
                 // If it's an instantiation of another template,
                 // find the canonical declaration to find the module
@@ -367,18 +368,18 @@ fn conv_decl_ty_resolving_typedefs(ctx: &mut ClangParserCtx,
             // it's important not to override
             if !args.is_empty() {
                 ci.borrow_mut().args = args;
+
                 // XXX: This is a super-dumb way to get the spesialisation,
                 // but it seems to be the only one that'd work here...
                 cursor.visit(|c, _: &Cursor| {
                     if c.kind() == CXCursor_TemplateRef {
-                    let decl = decl_name(ctx, &c.referenced());
+                        let decl = decl_name(ctx, &c.referenced());
                         ci.borrow_mut().ref_template = Some(decl.to_type());
                     }
                     CXChildVisit_Continue
                 });
             }
 
-
             TComp(ci)
         }
         CXCursor_EnumDecl => {
@@ -458,7 +459,9 @@ fn conv_ty_resolving_typedefs(ctx: &mut ClangParserCtx,
         CXType_Pointer => conv_ptr_ty_resolving_typedefs(ctx, &ty.pointee_type(), cursor, false, layout, resolve_typedefs),
         CXType_LValueReference => conv_ptr_ty_resolving_typedefs(ctx, &ty.pointee_type(), cursor, true, layout, resolve_typedefs),
         // XXX DependentSizedArray is wrong
-        CXType_VariableArray | CXType_DependentSizedArray | CXType_IncompleteArray => {
+        CXType_VariableArray |
+        CXType_DependentSizedArray |
+        CXType_IncompleteArray => {
             conv_ptr_ty_resolving_typedefs(ctx, &ty.elem_type(), cursor, false, layout, resolve_typedefs)
         }
         CXType_FunctionProto => TFuncProto(mk_fn_sig(ctx, ty, cursor)),
@@ -537,6 +540,7 @@ impl Annotations {
 fn visit_composite(cursor: &Cursor, parent: &Cursor,
                    ctx: &mut ClangParserCtx,
                    ci: &mut CompInfo) -> Enum_CXVisitorResult {
+    assert!(ci.parser_cursor.is_some());
     fn is_bitfield_continuation(field: &il::FieldInfo, _ty: &il::Type, width: u32) -> bool {
         match (&field.bitfields, field.ty.layout()) {
             (&Some(ref bitfields), Some(layout)) => {
@@ -560,8 +564,41 @@ fn visit_composite(cursor: &Cursor, parent: &Cursor,
             let is_class_typedef = cursor.cur_type().sanitized_spelling_in(&ci.typedefs);
             let mutable = cursor.is_mutable_field();
 
+            let cursor_ty = cursor.cur_type();
+
             // NB: Overwritten in the case of non-integer bitfield
-            let mut ty = conv_ty_resolving_typedefs(ctx, &cursor.cur_type(), cursor, is_class_typedef);
+            let mut ty = conv_ty_resolving_typedefs(ctx,
+                                                    &cursor.cur_type(),
+                                                    cursor,
+                                                    is_class_typedef);
+
+            use std::cell::BorrowState;
+            if let Some(child_ci) = ty.get_outermost_composite() {
+                if let BorrowState::Unused = child_ci.borrow_state() {
+                    let mut child_ci = child_ci.borrow_mut();
+                    let child_cursor = child_ci.parser_cursor.unwrap();
+
+                    // TODO: This is lame, ideally we should use cursors.
+                    // The problem this is trying to solve is
+                    // tests/headers/inner_template_self.hpp.
+                    //
+                    // The problem with this is that clang treats the *prev*
+                    // field as a Class Declaration instead of a Class Template,
+                    // so we have to check now for the name and the module id.
+                    //
+                    // Ideally, some method like `semantic_parent` or
+                    // `lexical_parent` should return the reference to the
+                    // class, but I've tried everything I could think about and
+                    // failed miserably.
+                    if child_cursor.kind() == CXCursor_ClassDecl &&
+                       child_ci.args.is_empty() &&
+                       child_ci.name == ci.name &&
+                       child_ci.module_id == ci.module_id {
+                            child_ci.args = ci.args.clone();
+                    }
+                }
+            }
+
             let comment = cursor.raw_comment();
 
             let (name, bitfields) = match (cursor.bit_width(), ci.members.last_mut()) {

src/types.rs

@@ -10,6 +10,7 @@ pub use self::Global::*;
 pub use self::Type::*;
 pub use self::IKind::*;
 pub use self::FKind::*;
+use clang::Cursor;
 
 static NEXT_MODULE_ID: AtomicUsize = ATOMIC_USIZE_INIT;
 
@@ -200,6 +201,15 @@ impl Type {
         }
     }
 
+    pub fn get_outermost_composite(&self) -> Option<Rc<RefCell<CompInfo>>> {
+        match *self {
+            TComp(ref ci) => Some(ci.clone()),
+            TArray(ref t, _, _) => t.get_outermost_composite(),
+            TPtr(ref t, _, _, _) => t.get_outermost_composite(),
+            _ => None,
+        }
+    }
+
     pub fn size(&self) -> usize {
         self.layout().map(|l| l.size).unwrap_or(0)
     }
@@ -401,6 +411,7 @@ pub struct CompInfo {
     pub has_destructor: bool,
     pub has_nonempty_base: bool,
     pub hide: bool,
+    pub parser_cursor: Option<Cursor>,
     /// If this struct should be replaced by an opaque blob.
     ///
     /// This is useful if for some reason we can't generate
@@ -431,7 +442,13 @@ fn unnamed_name(name: String, filename: &String) -> String {
 }
 
 impl CompInfo {
-    pub fn new(name: String, module_id: ModuleId, filename: String, comment: String, kind: CompKind, members: Vec<CompMember>, layout: Layout) -> CompInfo {
+    pub fn new(name: String,
+               module_id: ModuleId,
+               filename: String,
+               comment: String,
+               kind: CompKind,
+               members: Vec<CompMember>,
+               layout: Layout) -> CompInfo {
         let was_unnamed = name.is_empty();
         CompInfo {
             kind: kind,
@@ -448,6 +465,7 @@ impl CompInfo {
             has_destructor: false,
             has_nonempty_base: false,
             hide: false,
+            parser_cursor: None,
             opaque: false,
             base_members: 0,
             layout: layout,

tests/expectations/inner_template_self.rs

@@ -0,0 +1,27 @@
+/* automatically generated by rust-bindgen */
+
+
+#![feature(const_fn)]
+#![allow(non_snake_case)]
+
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Struct_LinkedList<T> {
+    pub next: *mut Struct_LinkedList<T>,
+    pub prev: *mut Struct_LinkedList<T>,
+    pub _phantom0: ::std::marker::PhantomData<T>,
+}
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct Struct_InstantiateIt {
+    pub m_list: Struct_LinkedList<::std::os::raw::c_int>,
+}
+impl ::std::clone::Clone for Struct_InstantiateIt {
+    fn clone(&self) -> Self { *self }
+}
+#[test]
+fn bindgen_test_layout_Struct_InstantiateIt() {
+    assert_eq!(::std::mem::size_of::<Struct_InstantiateIt>() , 16usize);
+    assert_eq!(::std::mem::align_of::<Struct_InstantiateIt>() , 8usize);
+}

tests/headers/inner_template_self.hpp

@@ -0,0 +1,10 @@
+
+template <typename T>
+class LinkedList {
+    LinkedList<T>* next;
+    LinkedList* prev;
+};
+
+class InstantiateIt {
+    LinkedList<int> m_list;
+};