Whitelisting codegen, v1

Author: emilio

src/bin/bindgen.rs

@@ -28,6 +28,7 @@ Usage:
         [--dtor-attr=<attr>...] \
         [--opaque-type=<type>...] \
         [--blacklist-type=<type>...] \
+        [--whitelist-type=<type>...] \
         <input-header> \
         [-- <clang-args>...]
 
@@ -92,6 +93,9 @@ Options:
     --ignore-methods              Avoid generating all kind of methods.
     --opaque-type=<type>          Mark a type as opaque.
     --blacklist-type=<type>       Mark a type as hidden.
+    --whitelist-type=<type>       Whitelist the type. If this set is not empty,
+                                  then all the non-whitelisted types (or
+                                  dependant) won't be generated.
 
     <clang-args>                  Options other than stated above are passed
                                   directly through to clang.
@@ -122,6 +126,7 @@ struct Args {
     flag_ignore_methods: bool,
     flag_opaque_type: Vec<String>,
     flag_blacklist_type: Vec<String>,
+    flag_whitelist_type: Vec<String>,
     arg_clang_args: Vec<String>,
 }
 
@@ -171,6 +176,7 @@ impl Into<ParseResult<(BindgenOptions, Box<io::Write>)>> for Args {
         options.ignore_methods = self.flag_ignore_methods;
         options.opaque_types.extend(self.flag_opaque_type.drain(..));
         options.hidden_types.extend(self.flag_blacklist_type.drain(..));
+        options.whitelisted_types.extend(self.flag_whitelist_type.drain(..));
         options.clang_args.extend(self.arg_clang_args.drain(..));
         options.clang_args.push(self.arg_input_header);
 

src/codegen/mod.rs

@@ -12,6 +12,7 @@ use ir::layout::Layout;
 
 use std::ops;
 use std::mem;
+use std::collections::BTreeSet;
 use std::collections::hash_map::{HashMap, Entry};
 
 use syntax::abi::Abi;
@@ -489,26 +490,6 @@ impl<'a> Bitfield<'a> {
         }
     }
 
-    fn type_for_bitfield_width(ctx: &BindgenContext, width: u32, is_arg: bool) -> P<ast::Ty> {
-        let input_type = if width > 16 {
-            "u32"
-        } else if width > 8 {
-            "u16"
-        } else if width > 1 {
-            "u8"
-        } else {
-            if is_arg {
-                "bool"
-            } else {
-                "u8"
-            }
-        };
-
-        let ident = ctx.rust_ident_raw(input_type);
-        quote_ty!(ctx.ext_cx(), $ident)
-    }
-
-
     fn codegen_fields(self,
                       ctx: &BindgenContext,
                       fields: &mut Vec<ast::StructField>,
@@ -1400,14 +1381,173 @@ impl CodeGenerator for Function {
     }
 }
 
+type ItemSet = BTreeSet<ItemId>;
+
+trait TypeCollector {
+    type Extra;
+
+    fn collect_types(&self,
+                     context: &BindgenContext,
+                     types: &mut ItemSet,
+                     extra: &Self::Extra);
+}
+
+impl TypeCollector for ItemId {
+    type Extra = ();
+
+    fn collect_types(&self,
+                     context: &BindgenContext,
+                     types: &mut ItemSet,
+                     extra: &()) {
+        context.resolve_item(*self).collect_types(context, types, extra);
+    }
+}
+
+impl TypeCollector for Item {
+    type Extra = ();
+
+    fn collect_types(&self,
+                     context: &BindgenContext,
+                     types: &mut ItemSet,
+                     _extra: &()) {
+        if self.hidden(context) || types.contains(&self.id()) {
+            return;
+        }
+
+        println!("Collecting: {:?}", self.id());
+
+        match *self.kind() {
+            ItemKind::Type(ref ty) => {
+                types.insert(self.id());
+                if !self.opaque(context) {
+                    ty.collect_types(context, types, self);
+                }
+            }
+            _ => {}, // FIXME.
+        }
+    }
+}
+
+impl TypeCollector for Type {
+    type Extra = Item;
+
+    fn collect_types(&self,
+                     context: &BindgenContext,
+                     types: &mut ItemSet,
+                     item: &Item) {
+        match *self.kind() {
+            TypeKind::Pointer(inner) |
+            TypeKind::Reference(inner) |
+            TypeKind::Array(inner, _) |
+            TypeKind::Alias(_, inner) |
+            TypeKind::Named(_, Some(inner))
+                => inner.collect_types(context, types, &()),
+
+            TypeKind::TemplateRef(inner, ref template_args) => {
+                inner.collect_types(context, types, &());
+                for item in template_args {
+                    item.collect_types(context, types, &());
+                }
+            }
+            TypeKind::Comp(ref ci) => ci.collect_types(context, types, item),
+            // FIXME: Pending types!
+            ref other @ _ => {
+                println!("Ignoring: {:?}", other);
+            },
+        }
+    }
+}
+
+impl TypeCollector for CompInfo {
+    type Extra = Item;
+
+    fn collect_types(&self,
+                     context: &BindgenContext,
+                     types: &mut ItemSet,
+                     item: &Item) {
+        if let Some(template) = self.specialized_template() {
+            template.collect_types(context, types, &());
+        }
+
+        let applicable_template_args = item.applicable_template_args(context);
+        for arg in applicable_template_args {
+            arg.collect_types(context, types, &());
+        }
+
+        for base in self.base_members() {
+            base.collect_types(context, types, &());
+        }
+
+        for field in self.fields() {
+            field.ty().collect_types(context, types, &());
+        }
+
+        for ty in self.inner_types() {
+            ty.collect_types(context, types, &());
+        }
+
+        // FIXME(emilio): Methods, VTable?
+    }
+}
+
 pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
     context.gen(|context| {
         let mut result = CodegenResult::new();
-        for (_item_id, item) in context.items() {
-            // Non-toplevel item parents are the responsible one for generating
-            // them.
-            if item.is_toplevel(context) {
-                item.codegen(context, &mut result, &());
+
+        debug!("codegen: {:?}", context.options());
+
+        // If the whitelisted types set is empty, just generate everything.
+        if context.options().whitelisted_types.is_empty() {
+            for (_item_id, item) in context.items() {
+                // Non-toplevel item parents are the responsible one for generating
+                // them.
+                if item.is_toplevel(context) {
+                    item.codegen(context, &mut result, &());
+                }
+            }
+        } else {
+            // Recursively collect all the types dependent on the whitelisted
+            // types, then generate them.
+            //
+            // FIXME(emilio): This pass is probably slow, but it can't be faster
+            // than docopt anyway :)
+            let mut types = ItemSet::new();
+            for (_item_id, item) in context.items() {
+                // FIXME(emilio): This only works for types, but we need to
+                // eventually come with a coherent history for functions...
+                //
+                // Whitelisting any type touched by a function seems overkill,
+                // maybe another pass whitelisting functions that only contain
+                // whitelisted types?
+                if item.kind().is_type() && item.is_toplevel(context) {
+                    let name = item.canonical_name(context);
+                    if context.options().whitelisted_types.contains(&name) {
+                        item.collect_types(context, &mut types, &());
+                    }
+                }
+            }
+
+            fn contains_parent(ctx: &BindgenContext, types: &ItemSet, id: ItemId) -> bool {
+                let item = ctx.resolve_item(id);
+                let mut last = id;
+                let mut current = item.parent_id();
+
+                while last != current {
+                    if types.contains(&current) {
+                        return true;
+                    }
+                    last = current;
+                    current = ctx.resolve_item(current).parent_id();
+                }
+
+                false
+            }
+
+            for item_id in types.iter() {
+                let item = context.resolve_item(*item_id);
+                if item.is_toplevel(context) || !contains_parent(context, &types, *item_id) {
+                    item.codegen(context, &mut result, &());
+                }
             }
         }
         let saw_union = result.saw_union;

src/ir/context.rs

@@ -372,7 +372,7 @@ impl<'ctx> BindgenContext<'ctx> {
                                   ty: &clang::Type,
                                   location: Option<clang::Cursor>) -> Option<ItemId> {
         use clangll::{CXCursor_ClassTemplate, CXCursor_ClassTemplatePartialSpecialization};
-        debug!("builtin_or_resolved_ty: {:?}, {:?}", ty, location);
+        debug!("builtin_or_resolved_ty: {:?}, {:?}, {:?}", ty, location, parent_id);
         let mut declaration = ty.declaration();
         if !declaration.is_valid() {
             if let Some(location) = location {

src/ir/item.rs

@@ -410,19 +410,21 @@ impl ClangItemParser for Item {
                context: &mut BindgenContext) -> Result<ItemId, ParseError> {
         use clangll::*;
 
-        let decl = ty.declaration();
-        let definition = decl.definition();
-        let decl = if definition.is_valid() {
-            definition
-        } else {
-            decl
+        let decl = {
+            let decl = ty.declaration();
+            let definition = decl.definition();
+            if definition.is_valid() {
+                definition
+            } else {
+                decl
+            }
         };
 
         let comment =
-            definition.raw_comment()
-                      .or_else(|| location.as_ref().and_then(|l| l.raw_comment()));
+            decl.raw_comment()
+                .or_else(|| location.as_ref().and_then(|l| l.raw_comment()));
         let annotations =
-            Annotations::new(&definition)
+            Annotations::new(&decl)
                       .or_else(|| location.as_ref().and_then(|l| Annotations::new(l)));
 
         if let Some(ty) = context.builtin_or_resolved_ty(parent_id, ty, location) {

src/ir/module.rs

@@ -2,6 +2,7 @@ use super::context::BindgenContext;
 use super::item::{ItemId, Item};
 use clang;
 use parse::{ClangItemParser, ClangSubItemParser, ParseError, ParseResult};
+use parse_one;
 
 /// A module, as in, a C++ namespace.
 #[derive(Clone, Debug)]
@@ -38,26 +39,9 @@ impl ClangSubItemParser for Module {
         use clangll::*;
         match cursor.kind() {
             CXCursor_Namespace => {
-                // FIXME: This shouldn't be at parse time, but at codegen time,
-                // move there once we have enough confidence in our namespace
-                // parsing implementation.
-                if !ctx.options().enable_cxx_namespaces {
-                    return Err(ParseError::Recurse)
-                }
-
                 let module_id = ctx.module(cursor);
                 ctx.with_module(module_id, |ctx, children| {
-                    // FIXME: deduplicate this and src/lib.rs
-                    cursor.visit(|cur, _| {
-                        match Item::parse(*cur, None, ctx) {
-                            Ok(id) => {
-                                children.push(id);
-                                CXChildVisit_Continue
-                            }
-                            Err(ParseError::Continue) => CXChildVisit_Continue,
-                            Err(ParseError::Recurse) => CXChildVisit_Recurse,
-                        }
-                    });
+                    cursor.visit(|cursor, _| parse_one(ctx, *cursor, Some(module_id), children))
                 });
 
                 Ok(ParseResult::AlreadyResolved(module_id))