Add support for 'unsafe fields'

.travis.yml

@@ -42,6 +42,7 @@ script:
   - cargo build --verbose --features llvm_stable
   - make test
   - git add -A
+  - git diff @
   - git diff-index --quiet HEAD
 
 notifications:

Makefile

@@ -9,7 +9,7 @@ BINDGEN := ./target/debug/bindgen
 
 .PHONY: $(BINDGEN)
 $(BINDGEN):
-	[ -f $@ ] || cargo build
+	[ -f $@ ] || cargo build --features llvm_stable
 
 .PHONY: test
 test: regen-tests

src/gen.rs

@@ -19,6 +19,7 @@ use syntax::print::pprust::tts_to_string;
 
 use super::BindgenOptions;
 use super::LinkType;
+use parser::Accessor;
 use types::*;
 use aster;
 
@@ -840,6 +841,52 @@ fn comp_attrs(ctx: &GenCtx, ci: &CompInfo, name: &str, extra: &mut Vec<P<ast::It
     attrs
 }
 
+fn gen_accessors(ctx: &mut GenCtx, name: &str, ty: &ast::Ty, accessor: Accessor,
+                 methods: &mut Vec<ast::ImplItem>) {
+    if accessor == Accessor::None {
+        return;
+    }
+    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 = match accessor {
+        Accessor::Regular => quote_item!(&ctx.ext_cx,
+            impl X {
+                #[inline]
+                pub fn $getter_name(&self) -> & $ty {
+                    & self.$ident
+                }
+                pub fn $mutable_getter_name(&mut self) -> &mut $ty {
+                    &mut self.$ident
+                }
+            }
+        ),
+        Accessor::Unsafe => 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
+                }
+            }
+        ),
+        Accessor::Immutable => quote_item!(&ctx.ext_cx,
+            impl X {
+                #[inline]
+                pub fn $getter_name(&self) -> & $ty {
+                    & self.$ident
+                }
+            }
+        ),
+        _ => return
+    };
+    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;
@@ -878,14 +925,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() {
@@ -1052,15 +1100,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 {
+                ast::Visibility::Inherited
+            } else {
+                ast::Visibility::Public
+            };
+            gen_accessors(ctx, &f_name, &rust_ty, f.accessor, &mut methods);
+            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

@@ -122,6 +122,7 @@ fn decl_name(ctx: &mut ClangParserCtx, cursor: &Cursor) -> Global {
             CXCursor_ClassTemplate |
             CXCursor_ClassDecl |
             CXCursor_StructDecl => {
+                let anno = Annotations::new(&cursor);
                 let kind = if cursor.kind() == CXCursor_UnionDecl {
                     CompKind::Union
                 } else {
@@ -159,7 +160,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);
+                let mut ci = CompInfo::new(spelling, ctx.current_module_id, filename, comment, kind, vec![], layout, anno);
                 ci.parser_cursor = Some(cursor);
 
                 // If it's an instantiation of another template,
@@ -538,12 +539,34 @@ fn opaque_ty(ctx: &mut ClangParserCtx, ty: &cx::Type) {
     }
 }
 
-struct Annotations {
+#[derive(Copy, PartialEq, Clone, Debug)]
+pub enum Accessor {
+    None,
+    Regular,
+    Unsafe,
+    Immutable,
+}
+
+#[derive(Clone, PartialEq, Debug)]
+pub struct Annotations {
     opaque: bool,
     hide: bool,
     use_as: Option<String>,
     /// Disable deriving copy/clone on this struct.
     no_copy: bool,
+    // In the None case we fall back to the value specified
+    // in the enclosing decl
+    private: Option<bool>,
+    accessor: Option<Accessor>,
+}
+
+fn parse_accessor(s: &str) -> Accessor {
+    match s {
+        "false" => Accessor::None,
+        "unsafe" => Accessor::Unsafe,
+        "immutable" => Accessor::Immutable,
+        _ => Accessor::Regular,
+    }
 }
 
 impl Annotations {
@@ -553,6 +576,8 @@ impl Annotations {
             hide: false,
             use_as: None,
             no_copy: false,
+            private: None,
+            accessor: None
         };
 
         anno.parse(&cursor.comment());
@@ -571,6 +596,10 @@ 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 = Some(comment.get_tag_attr_value(i) != "false"),
+                    "accessor" => {
+                        self.accessor = Some(parse_accessor(&comment.get_tag_attr_value(i)))
+                    },
                     _ => (),
                 }
             }
@@ -792,12 +821,16 @@ fn visit_composite(cursor: &Cursor, parent: &Cursor,
 
                     if should_replace {
                         *info = FieldInfo::new(name, ty, comment, bitfields, mutable);
+                        info.private = anno.private.unwrap_or(ci.anno.private.unwrap_or(false));
+                        info.accessor = anno.accessor.unwrap_or(ci.anno.accessor.unwrap_or(Accessor::None));
                         return CXChildVisit_Continue;
                     }
                 }
             }
 
-            let field = FieldInfo::new(name, ty, comment, bitfields, mutable);
+            let mut field = FieldInfo::new(name, ty, comment, bitfields, mutable);
+            field.private = anno.private.unwrap_or(ci.anno.private.unwrap_or(false));
+            field.accessor = anno.accessor.unwrap_or(ci.anno.accessor.unwrap_or(Accessor::None));
             ci.members.push(CompMember::Field(field));
         }
         CXCursor_StructDecl |

src/types.rs

@@ -13,6 +13,8 @@ pub use self::IKind::*;
 pub use self::FKind::*;
 use clang::Cursor;
 
+use parser::{Annotations, Accessor};
+
 static NEXT_MODULE_ID: AtomicUsize = ATOMIC_USIZE_INIT;
 
 #[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
@@ -446,6 +448,9 @@ 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>,
+
+    /// Annotations on the decl
+    pub anno: Annotations,
 }
 
 static mut UNNAMED_COUNTER: u32 = 0;
@@ -466,7 +471,8 @@ impl CompInfo {
                comment: String,
                kind: CompKind,
                members: Vec<CompMember>,
-               layout: Layout) -> CompInfo {
+               layout: Layout,
+               anno: Annotations) -> CompInfo {
         let was_unnamed = name.is_empty();
         CompInfo {
             kind: kind,
@@ -494,6 +500,7 @@ impl CompInfo {
             was_unnamed: was_unnamed,
             detect_derive_debug_cycle: Cell::new(false),
             detect_has_destructor_cycle: Cell::new(false),
+            anno: anno,
         }
     }
 
@@ -640,6 +647,12 @@ pub struct FieldInfo {
     pub bitfields: Option<Vec<(String, u32)>>,
     /// If the C++ field is marked as `mutable`
     pub mutable: bool,
+    /// True when field or enclosing struct
+    /// has a `<div rust-bindgen private>` annotation
+    pub private: bool,
+    /// Set by the `<div rust-bindgen accessor="..">`
+    /// annotation on a field or enclosing struct
+    pub accessor: Accessor,
 }
 
 impl FieldInfo {
@@ -654,6 +667,8 @@ impl FieldInfo {
             comment: comment,
             bitfields: bitfields,
             mutable: mutable,
+            private: false,
+            accessor: Accessor::None,
         }
     }
 }