Add support for 'unsafe fields'

Author: Manishearth

src/gen.rs

@@ -841,6 +841,26 @@ fn comp_attrs(ctx: &GenCtx, ci: &CompInfo, name: &str, extra: &mut Vec<P<ast::It
     attrs
 }
 
+fn gen_unsafe_field_accessors(ctx: &mut GenCtx, name: &str, ty: &ast::Ty, methods: &mut Vec<ast::ImplItem>) {
+    let ident =  ctx.ext_cx.ident_of(&format!("{}", name));
+    let mutable_getter_name = ctx.ext_cx.ident_of(&format!("get_{}_mut", name));
+    let getter_name = ctx.ext_cx.ident_of(&format!("get_{}", name));
+    let imp = quote_item!(&ctx.ext_cx,
+        impl X {
+            #[inline]
+            pub unsafe fn $getter_name(&self) -> & $ty {
+                & self.$ident
+            }
+            pub unsafe fn $mutable_getter_name(&mut self) -> &mut $ty {
+                &mut self.$ident
+            }
+        }
+    );
+    match imp.unwrap().node {
+        ast::ItemKind::Impl(_, _, _, _, _, ref items) => methods.extend(items.clone()),
+        _ => unreachable!()
+    }
+}
 
 fn cstruct_to_rs(ctx: &mut GenCtx, name: &str, ci: CompInfo) -> Vec<P<ast::Item>> {
     let layout = ci.layout;
@@ -879,14 +899,15 @@ fn cstruct_to_rs(ctx: &mut GenCtx, name: &str, ci: CompInfo) -> Vec<P<ast::Item>
         };
 
         if let Some(ref base) = base_vftable {
-            vffields.push(ast::StructField {
+            let field = ast::StructField {
                 span: ctx.span,
                 vis: ast::Visibility::Public,
                 ident: Some(ctx.ext_cx.ident_of("_base")),
                 id: ast::DUMMY_NODE_ID,
                 ty: P(mk_ty(ctx, false, &[base.clone()])),
                 attrs: vec![],
-            });
+            };
+            vffields.push(field);
         }
 
         for vm in ci.vmethods.iter() {
@@ -1053,15 +1074,22 @@ fn cstruct_to_rs(ctx: &mut GenCtx, name: &str, ci: CompInfo) -> Vec<P<ast::Item>
             } else {
                 rust_ty
             };
-
-            fields.push(ast::StructField {
+            let vis = if f.private {
+                gen_unsafe_field_accessors(ctx, &f_name, &rust_ty, &mut methods);
+                ast::Visibility::Inherited
+            } else {
+                ast::Visibility::Public
+            };
+            let field = ast::StructField {
                 span: ctx.span,
                 ident: Some(ctx.ext_cx.ident_of(&f_name)),
-                vis: ast::Visibility::Public,
+                vis: vis,
                 id: ast::DUMMY_NODE_ID,
                 ty: rust_ty,
                 attrs: mk_doc_attr(ctx, &f.comment)
-            });
+            };
+            fields.push(field);
+            
             if bypass {
                 continue;
             }

src/parser.rs

@@ -544,6 +544,7 @@ struct Annotations {
     use_as: Option<String>,
     /// Disable deriving copy/clone on this struct.
     no_copy: bool,
+    private: bool,
 }
 
 impl Annotations {
@@ -553,6 +554,7 @@ impl Annotations {
             hide: false,
             use_as: None,
             no_copy: false,
+            private: false,
         };
 
         anno.parse(&cursor.comment());
@@ -571,6 +573,7 @@ impl Annotations {
                     "hide" => self.hide = true,
                     "replaces" => self.use_as = Some(comment.get_tag_attr_value(i)),
                     "nocopy" => self.no_copy = true,
+                    "private" => self.private = true,
                     _ => (),
                 }
             }
@@ -791,13 +794,13 @@ fn visit_composite(cursor: &Cursor, parent: &Cursor,
                     };
 
                     if should_replace {
-                        *info = FieldInfo::new(name, ty, comment, bitfields, mutable);
+                        *info = FieldInfo::new(name, ty, comment, bitfields, mutable, anno.private);
                         return CXChildVisit_Continue;
                     }
                 }
             }
 
-            let field = FieldInfo::new(name, ty, comment, bitfields, mutable);
+            let field = FieldInfo::new(name, ty, comment, bitfields, mutable, anno.private);
             ci.members.push(CompMember::Field(field));
         }
         CXCursor_StructDecl |
@@ -837,7 +840,7 @@ fn visit_composite(cursor: &Cursor, parent: &Cursor,
                 // Anonymous structs are legal in both C++ and C11
                 if ci2.borrow().was_unnamed {
                     let ci2b = ci2.borrow();
-                    let field = FieldInfo::new(ci2b.name.clone(), TComp(ci2.clone()), ci2b.comment.clone(), None, false);
+                    let field = FieldInfo::new(ci2b.name.clone(), TComp(ci2.clone()), ci2b.comment.clone(), None, false, false);
                     ci.members.push(CompMember::Field(field));
                 }
             });
@@ -893,7 +896,7 @@ fn visit_composite(cursor: &Cursor, parent: &Cursor,
                 ci.typedefs.extend(info.borrow().typedefs.clone().into_iter());
             }
 
-            let field = FieldInfo::new(fieldname, ty, "".to_owned(), None, false);
+            let field = FieldInfo::new(fieldname, ty, "".to_owned(), None, false, false);
             if !found_virtual_base && cursor.is_virtual_base() {
                 ci.members.insert(0, CompMember::Field(field));
                 ci.has_vtable = true;

src/types.rs

@@ -624,20 +624,23 @@ pub struct FieldInfo {
     pub bitfields: Option<Vec<(String, u32)>>,
     /// If the C++ field is marked as `mutable`
     pub mutable: bool,
+    pub private: bool,
 }
 
 impl FieldInfo {
     pub fn new(name: String,
                ty: Type,
                comment: String,
                bitfields: Option<Vec<(String, u32)>>,
-               mutable: bool) -> FieldInfo {
+               mutable: bool,
+               private: bool) -> FieldInfo {
         FieldInfo {
             name: name,
             ty: ty,
             comment: comment,
             bitfields: bitfields,
             mutable: mutable,
+            private: private,
         }
     }
 }