Add support for 'unsafe fields'

Author: Manishearth

src/bin/bindgen.rs

@@ -109,6 +109,13 @@ fn parse_args(args: &[String]) -> ParseResult {
                     options.opaque_types.push(args[ix + 1].clone());
                     ix += 2;
                 }
+                "-unsafe-field-type" => {
+                    if ix + 1 >= args_len {
+                        return ParseResult::ParseErr("Missing unsafe field type name".to_string());
+                    }
+                    options.unsafe_field_types.push(args[ix + 1].clone());
+                    ix += 2;
+                }
                 "-builtins" => {
                     options.builtins = true;
                     ix += 1;

src/gen.rs

@@ -841,6 +841,59 @@ fn comp_attrs(ctx: &GenCtx, ci: &CompInfo, name: &str, extra: &mut Vec<P<ast::It
     attrs
 }
 
+fn gen_maybe_unsafe_field(ctx: &mut GenCtx, mut field: ast::StructField, methods: &mut Vec<ast::ImplItem>) -> ast::StructField {
+    use syntax::visit::{Visitor, walk_ty};
+    struct TyVisitor<'a> {
+        search: &'a [String],
+        found: bool
+    };
+    impl<'a> Visitor for TyVisitor<'a> {
+        fn visit_ty(&mut self, t: &ast::Ty) {
+            if let ast::TyKind::Path(_, ref p) = t.node {
+                if p.segments.len() == 1 {
+                    for name in self.search {
+                        if p.segments[0].identifier.name.as_str() == **name {
+                            self.found = true;
+                            return;
+                        }
+                    }
+                }
+            }
+            walk_ty(self, t)
+        }
+    }
+
+    if !ctx.options.unsafe_field_types.is_empty() {
+        let mut visit = TyVisitor {search: &ctx.options.unsafe_field_types, found: false};
+        walk_ty(&mut visit, &field.ty);
+        if visit.found {
+            field.vis = ast::Visibility::Inherited;
+            let ident = field.ident.unwrap();
+            let mutable_getter_name = ctx.ext_cx.ident_of(&format!("get_{}_mut", ident));
+            let getter_name = ctx.ext_cx.ident_of(&format!("get_{}", ident));
+            {
+                let ref ty = field.ty;
+                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!()
+                }
+            }
+            return field;
+        }
+    }
+    field
+}
 
 fn cstruct_to_rs(ctx: &mut GenCtx, name: &str, ci: CompInfo) -> Vec<P<ast::Item>> {
     let layout = ci.layout;
@@ -879,14 +932,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(gen_maybe_unsafe_field(ctx, field, &mut methods));
         }
 
         for vm in ci.vmethods.iter() {
@@ -1053,15 +1107,15 @@ fn cstruct_to_rs(ctx: &mut GenCtx, name: &str, ci: CompInfo) -> Vec<P<ast::Item>
             } else {
                 rust_ty
             };
-
-            fields.push(ast::StructField {
+            let field = ast::StructField {
                 span: ctx.span,
                 ident: Some(ctx.ext_cx.ident_of(&f_name)),
                 vis: ast::Visibility::Public,
                 id: ast::DUMMY_NODE_ID,
                 ty: rust_ty,
                 attrs: mk_doc_attr(ctx, &f.comment)
-            });
+            };
+            fields.push(gen_maybe_unsafe_field(ctx, field, &mut methods));
             if bypass {
                 continue;
             }

src/lib.rs

@@ -154,6 +154,7 @@ pub struct BindgenOptions {
     pub match_pat: Vec<String>,
     pub blacklist_type: Vec<String>,
     pub opaque_types: Vec<String>,
+    pub unsafe_field_types: Vec<String>,
     pub builtins: bool,
     pub rust_enums: bool,
     pub links: Vec<(String, LinkType)>,
@@ -185,6 +186,7 @@ impl Default for BindgenOptions {
             match_pat: vec![],
             blacklist_type: vec![],
             opaque_types: vec![],
+            unsafe_field_types: vec![],
             builtins: false,
             rust_enums: true,
             links: vec![],