Forward declared structs now generate opaque enums

Author: nikhilshagri

src/clang.rs

@@ -190,6 +190,11 @@ impl Cursor {
         unsafe { clang_getCursorKind(self.x) }
     }
 
+    /// Returns true is the cursor is a definition
+    pub fn is_definition(&self) -> bool {
+        unsafe { clang_isCursorDefinition(self.x) != 0 }
+    }
+
     /// Is the referent an anonymous record definition?
     pub fn is_anonymous(&self) -> bool {
         unsafe { clang_Cursor_isAnonymous(self.x) != 0 }

src/codegen/mod.rs

@@ -748,6 +748,20 @@ impl CodeGenerator for CompInfo {
             return;
         }
 
+        let applicable_template_args = item.applicable_template_args(ctx);
+
+        // generate an opaque enum if struct or union is a forward declaration,
+        // skip for now if template parameters are needed.
+        if self.is_forward_declaration() && applicable_template_args.is_empty(){
+            let name = item.canonical_name(ctx);
+            let builder = EnumBuilder::new(
+                                  aster::AstBuilder::new().item().pub_(),
+                                  &name, "name", true);
+            let enum_ = builder.build(ctx, item.to_rust_ty(ctx), result);
+            result.push(enum_);
+            return;
+        }
+
         if self.is_template_specialization() {
             let layout = item.kind().expect_type().layout(ctx);
 
@@ -775,8 +789,6 @@ impl CodeGenerator for CompInfo {
             return;
         }
 
-        let applicable_template_args = item.applicable_template_args(ctx);
-
         let mut attributes = vec![];
         let mut needs_clone_impl = false;
         if let Some(comment) = item.comment() {

src/ir/comp.rs

@@ -290,6 +290,10 @@ pub struct CompInfo {
     /// Used to detect if we've run in a has_destructor cycle while cycling
     /// around the template arguments.
     detect_has_destructor_cycle: Cell<bool>,
+
+    /// Used to indicate when a struct has been forward declared. Usually used
+    /// in headers so that APIs can't modify them directly.
+    is_forward_declaration: bool,
 }
 
 impl CompInfo {
@@ -314,6 +318,7 @@ impl CompInfo {
             found_unknown_attr: false,
             detect_derive_debug_cycle: Cell::new(false),
             detect_has_destructor_cycle: Cell::new(false),
+            is_forward_declaration: false,
         }
     }
 
@@ -481,6 +486,9 @@ impl CompInfo {
         debug!("CompInfo::from_ty({:?}, {:?})", kind, cursor);
 
         let mut ci = CompInfo::new(kind);
+        ci.is_forward_declaration = location.map_or(true, |cur|
+                                        (cur.kind() == CXCursor_StructDecl || cur.kind() == CXCursor_UnionDecl) &&
+                                         !cur.is_definition());
         ci.is_anonymous = cursor.is_anonymous();
         ci.template_args = match ty.template_args() {
             // In forward declarations and not specializations,
@@ -822,6 +830,11 @@ impl CompInfo {
                 .map_or(false, |ci| ci.has_vtable(ctx))
         })
     }
+
+    /// Returns true if compound type has been forward declared
+    pub fn is_forward_declaration(&self) -> bool {
+        self.is_forward_declaration
+    }
 }
 
 impl CanDeriveDebug for CompInfo {

tests/expectations/tests/same_struct_name_in_different_namespaces.rs

@@ -4,14 +4,7 @@
 #![allow(non_snake_case)]
 
 
-#[repr(C)]
-#[derive(Debug, Copy)]
-pub struct JS_Zone {
-    pub _address: u8,
-}
-impl Clone for JS_Zone {
-    fn clone(&self) -> Self { *self }
-}
+pub enum JS_Zone { }
 #[repr(C)]
 #[derive(Debug, Copy)]
 pub struct JS_shadow_Zone {