Parse annotations.

Author: emilio

src/ir/annotations.rs

@@ -0,0 +1,96 @@
+use clang;
+
+#[derive(Copy, PartialEq, Clone, Debug)]
+pub enum FieldAccessorKind {
+    None,
+    Regular,
+    Unsafe,
+    Immutable,
+}
+
+/// Annotations for a given item, or a field.
+#[derive(Clone, PartialEq, Debug)]
+pub struct Annotations {
+    /// Whether this item is marked as opaque. Only applies to types.
+    opaque: bool,
+    /// Whether this item should be hidden from the output. Only applies to
+    /// types.
+    hide: bool,
+    /// Whether this type should be replaced by another. The name must be the
+    /// canonical name that that type would get.
+    use_as: Option<String>,
+    /// Manually disable deriving copy/clone on this type. Only applies to
+    /// struct or union types.
+    no_copy: bool,
+    /// Whether fields should be marked as private or not. You can set this on
+    /// structs (it will apply to all the fields), or individual fields.
+    private_fields: Option<bool>,
+    /// The kind of accessor this field will have. Also can be applied to
+    /// structs so all the fields inside share it by default.
+    accessor_kind: Option<FieldAccessorKind>,
+}
+
+fn parse_accessor(s: &str) -> FieldAccessorKind {
+    match s {
+        "false" => FieldAccessorKind::None,
+        "unsafe" => FieldAccessorKind::Unsafe,
+        "immutable" => FieldAccessorKind::Immutable,
+        _ => FieldAccessorKind::Regular,
+    }
+}
+
+impl Default for Annotations {
+    fn default() -> Self {
+        Annotations {
+            opaque: false,
+            hide: false,
+            use_as: None,
+            no_copy: false,
+            private_fields: None,
+            accessor_kind: None
+        }
+    }
+}
+
+impl Annotations {
+    pub fn new(cursor: &clang::Cursor) -> Option<Annotations> {
+        let mut anno = Annotations::default();
+        let mut matched_one = false;
+        anno.parse(&cursor.comment(), &mut matched_one);
+
+        if matched_one {
+            Some(anno)
+        } else {
+            None
+        }
+    }
+
+    fn parse(&mut self, comment: &clang::Comment, matched: &mut bool) {
+        use clangll::CXComment_HTMLStartTag;
+        if comment.kind() == CXComment_HTMLStartTag &&
+           comment.get_tag_name() == "div" &&
+           comment.get_num_tag_attrs() > 1 &&
+           comment.get_tag_attr_name(0) == "rustbindgen" {
+            *matched = true;
+            for i in 0..comment.get_num_tag_attrs() {
+                let value = comment.get_tag_attr_value(i);
+                let name = comment.get_tag_attr_name(i);
+                match name.as_str() {
+                    "opaque" => self.opaque = true,
+                    "hide" => self.hide = true,
+                    "nocopy" => self.no_copy = true,
+                    "replaces" => self.use_as = Some(value),
+                    "private" => self.private_fields = Some(value != "false"),
+                    "accessor"
+                        => self.accessor_kind = Some(parse_accessor(&value)),
+                    _ => {},
+                }
+            }
+        }
+
+        for i in 0..comment.num_children() {
+            self.parse(&comment.get_child(i), matched);
+        }
+    }
+}
+

src/ir/comp.rs

@@ -1,3 +1,4 @@
+use super::annotations::Annotations;
 use super::context::BindgenContext;
 use super::context::TypeResolver;
 use super::layout::Layout;
@@ -70,6 +71,7 @@ impl Field {
     pub fn new(name: String,
                ty: ItemId,
                comment: Option<String>,
+               annotations: Option<Annotations>,
                bitfield: Option<u32>,
                mutable: bool) -> Field {
         Field {
@@ -391,12 +393,17 @@ impl CompInfo {
                     let field_type = Item::from_ty(&cur.cur_type(), Some(*cur), Some(potential_id), ctx)
                                         .expect("FieldDecl?");
                     let comment = cur.raw_comment();
+                    let annotations = Annotations::new(cur);
                     let name = cur.spelling();
                     let is_mutable = cursor.is_mutable_field();
+
                     // Name can be empty if there are bitfields, for example,
                     // see tests/headers/struct_with_bitfields.h
-                    assert!(!name.is_empty() || bit_width.is_some(), "Empty field name?");
-                    let field = Field::new(name, field_type, comment, bit_width, is_mutable);
+                    assert!(!name.is_empty() || bit_width.is_some(),
+                            "Empty field name?");
+
+                    let field = Field::new(name, field_type, comment,
+                                           annotations, bit_width, is_mutable);
                     ci.fields.push(field)
                 }
                 CXCursor_EnumDecl |

src/ir/context.rs

@@ -238,7 +238,7 @@ impl<'ctx> BindgenContext<'ctx> {
     fn build_root_module() -> Item {
         let module = Module::new(None, None);
         let id = ItemId::next();
-        Item::new(id, None, id, ItemKind::Module(module))
+        Item::new(id, None, None, id, ItemKind::Module(module))
     }
 
     pub fn root_module(&self) -> ItemId {
@@ -343,7 +343,7 @@ impl<'ctx> BindgenContext<'ctx> {
             let name = ty.spelling();
             let name = if name.is_empty() { None } else { Some(name) };
             let ty = Type::new(name, ty.fallible_layout().ok(), type_kind, ty.is_const());
-            Item::new(self_id, None, parent_id, ItemKind::Type(ty))
+            Item::new(self_id, None, None, parent_id, ItemKind::Type(ty))
         };
 
         // Bypass all the validations in add_item explicitly.
@@ -433,7 +433,7 @@ impl<'ctx> BindgenContext<'ctx> {
         let layout = ty.fallible_layout().ok();
         let ty = Type::new(Some(spelling), layout, type_kind, is_const);
         let id = ItemId::next();
-        let item = Item::new(id, None, self.root_module, ItemKind::Type(ty));
+        let item = Item::new(id, None, None, self.root_module, ItemKind::Type(ty));
         self.add_builtin_item(item);
         Some(id)
     }

src/ir/function.rs

@@ -16,14 +16,20 @@ pub struct Function {
     mangled_name: Option<String>,
     /// The id pointing to the current function signature.
     signature: ItemId,
+    /// The doc comment on the function, if any.
+    comment: Option<String>,
 }
 
 impl Function {
-    pub fn new(name: String, mangled_name: Option<String>, sig: ItemId) -> Self {
+    pub fn new(name: String,
+               mangled_name: Option<String>,
+               sig: ItemId,
+               comment: Option<String>) -> Self {
         Function {
             name: name,
             mangled_name: mangled_name,
             signature: sig,
+            comment: comment,
         }
     }
 
@@ -180,7 +186,9 @@ impl ClangSubItemParser for Function {
             mangled_name = None;
         }
 
-        let function = Self::new(name, mangled_name, sig);
+        let comment = cursor.raw_comment();
+
+        let function = Self::new(name, mangled_name, sig, comment);
         Ok(ParseResult::New(function, Some(cursor)))
     }
 }

src/ir/item.rs

@@ -1,6 +1,7 @@
 use super::context::BindgenContext;
 use super::item_kind::ItemKind;
 use super::ty::{Type, TypeKind};
+use super::annotations::Annotations;
 use std::fmt;
 use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
 use parse::{ClangItemParser, ClangSubItemParser, ParseError, ParseResult};
@@ -31,28 +32,33 @@ impl ItemId {
 pub struct Item {
     /// This item's id.
     id: ItemId,
+    /// A doc comment over the item, if any.
+    comment: Option<String>,
+    /// Annotations extracted from the doc comment, or the default ones
+    /// otherwise.
+    annotations: Annotations,
     /// An item's parent id. This will most likely be a class where this item
     /// was declared, or a module, etc.
     ///
     /// All the items have a parent, except the root module, in which case the
     /// parent id is its own id.
     parent_id: ItemId,
-    /// A doc comment over the item, if any.
-    comment: Option<String>,
     /// The item kind.
     kind: ItemKind,
 }
 
 impl Item {
     pub fn new(id: ItemId,
                comment: Option<String>,
+               annotations: Option<Annotations>,
                parent_id: ItemId,
                kind: ItemKind) -> Self {
         debug_assert!(id != parent_id || kind.is_module());
         Item {
             id: id,
             parent_id: parent_id,
             comment: comment,
+            annotations: annotations.unwrap_or_default(),
             kind: kind,
         }
     }
@@ -93,7 +99,7 @@ impl ClangItemParser for Item {
         let ty = Type::new(None, None, kind, is_const);
         let id = ItemId::next();
         let module = ctx.root_module();
-        ctx.add_item(Item::new(id, None, module, ItemKind::Type(ty)),
+        ctx.add_item(Item::new(id, None, None, module, ItemKind::Type(ty)),
                      None, None);
         id
     }
@@ -113,6 +119,7 @@ impl ClangItemParser for Item {
         }
 
         let comment = cursor.raw_comment();
+        let annotations = Annotations::new(&cursor);
 
         // FIXME: The current_module logic is not really accurate. We should be
         // able to index modules by their Cursor, and locate the proper module
@@ -126,7 +133,7 @@ impl ClangItemParser for Item {
                 match $what::parse(cursor, context) {
                     Ok(ParseResult::New(item, declaration)) => {
                         let id = ItemId::next();
-                        context.add_item(Item::new(id, comment,
+                        context.add_item(Item::new(id, comment, annotations,
                                                    parent_id.unwrap_or(current_module),
                                                    ItemKind::$what(item)),
                                          declaration,
@@ -193,6 +200,9 @@ impl ClangItemParser for Item {
         let comment =
             definition.raw_comment()
                       .or_else(|| location.as_ref().and_then(|l| l.raw_comment()));
+        let annotations =
+            Annotations::new(&definition)
+                      .or_else(|| location.as_ref().and_then(|l| Annotations::new(l)));
 
         if let Some(ty) = context.builtin_or_resolved_ty(parent_id, ty, location) {
             return Ok(ty);
@@ -228,7 +238,7 @@ impl ClangItemParser for Item {
         let ret = match result {
             Ok(ParseResult::AlreadyResolved(ty)) => Ok(ty),
             Ok(ParseResult::New(item, declaration)) => {
-                context.add_item(Item::new(id, comment,
+                context.add_item(Item::new(id, comment, annotations,
                                            parent_id.unwrap_or(current_module),
                                            ItemKind::Type(item)),
                                  declaration,
@@ -306,7 +316,7 @@ impl ClangItemParser for Item {
     {
         let name = name.into();
 
-        context.add_item(Item::new(id, None, parent_id,
+        context.add_item(Item::new(id, None, None, parent_id,
                                    ItemKind::Type(Type::named(name))),
                          None,
                          None);

src/ir/mod.rs

@@ -1,3 +1,4 @@
+pub mod annotations;
 pub mod comp;
 pub mod context;
 pub mod enum_ty;