Use BindgenContext::whitelisted_items in code generation

This replaces the manual gathering and traversal of the transitive closure of
whitelisted items with the new canonical method.

Author: fitzgen

src/codegen/mod.rs

@@ -14,7 +14,7 @@ use ir::item_kind::ItemKind;
 use ir::layout::Layout;
 use ir::module::Module;
 use ir::ty::{Type, TypeKind};
-use ir::type_collector::{ItemSet, TypeCollector};
+use ir::type_collector::ItemSet;
 use ir::var::Var;
 use self::helpers::{BlobTyBuilder, attributes};
 
@@ -1692,108 +1692,48 @@ impl CodeGenerator for Function {
     }
 }
 
+// Return true if any of the ancestors of `id` are in the whitelisted items set,
+// false otherwise.
+fn ancestor_is_whitelisted(ctx: &BindgenContext,
+                           whitelisted_items: &ItemSet,
+                           id: ItemId)
+                           -> bool {
+    let item = ctx.resolve_item(id);
+    let mut last = id;
+    let mut current = item.parent_id();
+
+    while last != current {
+        if whitelisted_items.contains(&current) {
+            return true;
+        }
+        last = current;
+        current = ctx.resolve_item(current).parent_id();
+    }
+
+    false
+}
+
 pub fn codegen(context: &mut BindgenContext) -> Vec<P<ast::Item>> {
     context.gen(|context| {
         let mut result = CodegenResult::new();
 
         debug!("codegen: {:?}", context.options());
 
-        // If the whitelisted types and functions sets are empty, just generate
-        // everything.
-        if context.options().whitelisted_types.is_empty() &&
-           context.options().whitelisted_functions.is_empty() &&
-           context.options().whitelisted_vars.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 items = ItemSet::new();
-            for (_item_id, item) in context.items() {
-                // FIXME(emilio): This probably should look only at whether the
-                // parent is a module.
-                if !item.is_toplevel(context) {
-                    continue;
-                }
-
-                let name = item.canonical_name(context);
-                match *item.kind() {
-                    ItemKind::Type(ref ty) => {
-                        if context.options().whitelisted_types.matches(&name) {
-                            item.collect_types(context, &mut items, &());
-                        }
-                        // Unnamed top-level enums are special and we whitelist
-                        // them via the whitelisted_vars filter, since they're
-                        // effectively top-level constants, and there's no way
-                        // for them to be referenced consistently.
-                        if let TypeKind::Enum(ref enum_) = *ty.kind() {
-                            if ty.name().is_none() {
-                                if enum_.variants().iter().any(|variant| {
-                                    context.options()
-                                        .whitelisted_vars
-                                        .matches(&variant.name())
-                                }) {
-                                    item.collect_types(context,
-                                                       &mut items,
-                                                       &());
-                                }
-                            }
-                        }
-                    }
-                    ItemKind::Function(ref fun) => {
-                        if context.options()
-                            .whitelisted_functions
-                            .matches(&name) {
-                            items.insert(item.id());
-                            fun.signature()
-                                .collect_types(context, &mut items, &());
-                        }
-                    }
-                    ItemKind::Var(ref var) => {
-                        if context.options().whitelisted_vars.matches(&name) {
-                            items.insert(item.id());
-                            var.ty().collect_types(context, &mut items, &());
-                        }
-                    }
-                    ItemKind::Module(..) => {}
-                }
-            }
-
-            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();
-                }
+        let whitelisted_items: ItemSet = context.whitelisted_items().collect();
 
-                false
-            }
+        for &id in whitelisted_items.iter() {
+            let item = context.resolve_item(id);
 
-            for item_id in items.iter() {
-                let item = context.resolve_item(*item_id);
-                if item.is_toplevel(context) ||
-                   !contains_parent(context, &items, *item_id) {
-                    item.codegen(context, &mut result, &());
-                }
+            // Non-toplevel items' parents are responsible one for generating
+            // their children. However, if we find an orphaned reference to a
+            // non-toplevel item whose parent is not in our whitelisted set, we
+            // need to take responsibility for generating it.
+            if item.is_toplevel(context) ||
+               !ancestor_is_whitelisted(context, &whitelisted_items, id) {
+                item.codegen(context, &mut result, &());
             }
         }
+
         let saw_union = result.saw_union;
         let mut result = result.items;
         if saw_union && !context.options().unstable_rust {

tests/expectations/class_with_inner_struct.rs

@@ -28,8 +28,8 @@ impl <T> ::std::marker::Copy for __BindgenUnionField<T> { }
 #[derive(Debug, Copy)]
 pub struct A {
     pub c: ::std::os::raw::c_uint,
-    pub named_union: A__bindgen_ty_1,
-    pub __bindgen_anon_1: A__bindgen_ty_2,
+    pub named_union: A__bindgen_ty_2,
+    pub __bindgen_anon_1: A__bindgen_ty_1,
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
@@ -47,30 +47,30 @@ impl Clone for A_Segment {
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct A__bindgen_ty_1 {
+pub struct A__bindgen_ty_2 {
     pub f: __BindgenUnionField<::std::os::raw::c_int>,
     pub bindgen_union_field: u32,
 }
 #[test]
-fn bindgen_test_layout_A__bindgen_ty_1() {
-    assert_eq!(::std::mem::size_of::<A__bindgen_ty_1>() , 4usize);
-    assert_eq!(::std::mem::align_of::<A__bindgen_ty_1>() , 4usize);
+fn bindgen_test_layout_A__bindgen_ty_2() {
+    assert_eq!(::std::mem::size_of::<A__bindgen_ty_2>() , 4usize);
+    assert_eq!(::std::mem::align_of::<A__bindgen_ty_2>() , 4usize);
 }
-impl Clone for A__bindgen_ty_1 {
+impl Clone for A__bindgen_ty_2 {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct A__bindgen_ty_2 {
+pub struct A__bindgen_ty_1 {
     pub d: __BindgenUnionField<::std::os::raw::c_int>,
     pub bindgen_union_field: u32,
 }
 #[test]
-fn bindgen_test_layout_A__bindgen_ty_2() {
-    assert_eq!(::std::mem::size_of::<A__bindgen_ty_2>() , 4usize);
-    assert_eq!(::std::mem::align_of::<A__bindgen_ty_2>() , 4usize);
+fn bindgen_test_layout_A__bindgen_ty_1() {
+    assert_eq!(::std::mem::size_of::<A__bindgen_ty_1>() , 4usize);
+    assert_eq!(::std::mem::align_of::<A__bindgen_ty_1>() , 4usize);
 }
-impl Clone for A__bindgen_ty_2 {
+impl Clone for A__bindgen_ty_1 {
     fn clone(&self) -> Self { *self }
 }
 #[test]
@@ -125,38 +125,38 @@ pub struct C {
 #[repr(C)]
 #[derive(Debug, Copy)]
 pub struct C__bindgen_ty_1 {
-    pub mFunc: __BindgenUnionField<C__bindgen_ty_1_1>,
-    pub __bindgen_anon_1: __BindgenUnionField<C__bindgen_ty_1_2>,
+    pub mFunc: __BindgenUnionField<C__bindgen_ty_1_2>,
+    pub __bindgen_anon_1: __BindgenUnionField<C__bindgen_ty_1_1>,
     pub bindgen_union_field: [u32; 4usize],
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct C__bindgen_ty_1_1 {
+pub struct C__bindgen_ty_1_2 {
     pub mX1: f32,
     pub mY1: f32,
     pub mX2: f32,
     pub mY2: f32,
 }
 #[test]
-fn bindgen_test_layout_C__bindgen_ty_1_1() {
-    assert_eq!(::std::mem::size_of::<C__bindgen_ty_1_1>() , 16usize);
-    assert_eq!(::std::mem::align_of::<C__bindgen_ty_1_1>() , 4usize);
+fn bindgen_test_layout_C__bindgen_ty_1_2() {
+    assert_eq!(::std::mem::size_of::<C__bindgen_ty_1_2>() , 16usize);
+    assert_eq!(::std::mem::align_of::<C__bindgen_ty_1_2>() , 4usize);
 }
-impl Clone for C__bindgen_ty_1_1 {
+impl Clone for C__bindgen_ty_1_2 {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct C__bindgen_ty_1_2 {
+pub struct C__bindgen_ty_1_1 {
     pub mStepSyntax: StepSyntax,
     pub mSteps: ::std::os::raw::c_uint,
 }
 #[test]
-fn bindgen_test_layout_C__bindgen_ty_1_2() {
-    assert_eq!(::std::mem::size_of::<C__bindgen_ty_1_2>() , 8usize);
-    assert_eq!(::std::mem::align_of::<C__bindgen_ty_1_2>() , 4usize);
+fn bindgen_test_layout_C__bindgen_ty_1_1() {
+    assert_eq!(::std::mem::size_of::<C__bindgen_ty_1_1>() , 8usize);
+    assert_eq!(::std::mem::align_of::<C__bindgen_ty_1_1>() , 4usize);
 }
-impl Clone for C__bindgen_ty_1_2 {
+impl Clone for C__bindgen_ty_1_1 {
     fn clone(&self) -> Self { *self }
 }
 #[test]

tests/expectations/struct_with_anon_struct_array.rs

@@ -7,35 +7,35 @@
 #[repr(C)]
 #[derive(Debug, Copy)]
 pub struct foo {
-    pub bar: [foo__bindgen_ty_1; 2usize],
-    pub baz: [[[foo__bindgen_ty_2; 4usize]; 3usize]; 2usize],
+    pub bar: [foo__bindgen_ty_2; 2usize],
+    pub baz: [[[foo__bindgen_ty_1; 4usize]; 3usize]; 2usize],
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct foo__bindgen_ty_1 {
+pub struct foo__bindgen_ty_2 {
     pub a: ::std::os::raw::c_int,
     pub b: ::std::os::raw::c_int,
 }
 #[test]
-fn bindgen_test_layout_foo__bindgen_ty_1() {
-    assert_eq!(::std::mem::size_of::<foo__bindgen_ty_1>() , 8usize);
-    assert_eq!(::std::mem::align_of::<foo__bindgen_ty_1>() , 4usize);
+fn bindgen_test_layout_foo__bindgen_ty_2() {
+    assert_eq!(::std::mem::size_of::<foo__bindgen_ty_2>() , 8usize);
+    assert_eq!(::std::mem::align_of::<foo__bindgen_ty_2>() , 4usize);
 }
-impl Clone for foo__bindgen_ty_1 {
+impl Clone for foo__bindgen_ty_2 {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct foo__bindgen_ty_2 {
+pub struct foo__bindgen_ty_1 {
     pub a: ::std::os::raw::c_int,
     pub b: ::std::os::raw::c_int,
 }
 #[test]
-fn bindgen_test_layout_foo__bindgen_ty_2() {
-    assert_eq!(::std::mem::size_of::<foo__bindgen_ty_2>() , 8usize);
-    assert_eq!(::std::mem::align_of::<foo__bindgen_ty_2>() , 4usize);
+fn bindgen_test_layout_foo__bindgen_ty_1() {
+    assert_eq!(::std::mem::size_of::<foo__bindgen_ty_1>() , 8usize);
+    assert_eq!(::std::mem::align_of::<foo__bindgen_ty_1>() , 4usize);
 }
-impl Clone for foo__bindgen_ty_2 {
+impl Clone for foo__bindgen_ty_1 {
     fn clone(&self) -> Self { *self }
 }
 #[test]

tests/expectations/struct_with_nesting.rs

@@ -34,38 +34,38 @@ pub struct foo {
 #[derive(Debug, Copy)]
 pub struct foo__bindgen_ty_1 {
     pub b: __BindgenUnionField<::std::os::raw::c_uint>,
-    pub __bindgen_anon_1: __BindgenUnionField<foo__bindgen_ty_1_1>,
-    pub __bindgen_anon_2: __BindgenUnionField<foo__bindgen_ty_1_2>,
+    pub __bindgen_anon_1: __BindgenUnionField<foo__bindgen_ty_1_2>,
+    pub __bindgen_anon_2: __BindgenUnionField<foo__bindgen_ty_1_1>,
     pub bindgen_union_field: u32,
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct foo__bindgen_ty_1_1 {
+pub struct foo__bindgen_ty_1_2 {
     pub c1: ::std::os::raw::c_ushort,
     pub c2: ::std::os::raw::c_ushort,
 }
 #[test]
-fn bindgen_test_layout_foo__bindgen_ty_1_1() {
-    assert_eq!(::std::mem::size_of::<foo__bindgen_ty_1_1>() , 4usize);
-    assert_eq!(::std::mem::align_of::<foo__bindgen_ty_1_1>() , 2usize);
+fn bindgen_test_layout_foo__bindgen_ty_1_2() {
+    assert_eq!(::std::mem::size_of::<foo__bindgen_ty_1_2>() , 4usize);
+    assert_eq!(::std::mem::align_of::<foo__bindgen_ty_1_2>() , 2usize);
 }
-impl Clone for foo__bindgen_ty_1_1 {
+impl Clone for foo__bindgen_ty_1_2 {
     fn clone(&self) -> Self { *self }
 }
 #[repr(C)]
 #[derive(Debug, Copy)]
-pub struct foo__bindgen_ty_1_2 {
+pub struct foo__bindgen_ty_1_1 {
     pub d1: ::std::os::raw::c_uchar,
     pub d2: ::std::os::raw::c_uchar,
     pub d3: ::std::os::raw::c_uchar,
     pub d4: ::std::os::raw::c_uchar,
 }
 #[test]
-fn bindgen_test_layout_foo__bindgen_ty_1_2() {
-    assert_eq!(::std::mem::size_of::<foo__bindgen_ty_1_2>() , 4usize);
-    assert_eq!(::std::mem::align_of::<foo__bindgen_ty_1_2>() , 1usize);
+fn bindgen_test_layout_foo__bindgen_ty_1_1() {
+    assert_eq!(::std::mem::size_of::<foo__bindgen_ty_1_1>() , 4usize);
+    assert_eq!(::std::mem::align_of::<foo__bindgen_ty_1_1>() , 1usize);
 }
-impl Clone for foo__bindgen_ty_1_2 {
+impl Clone for foo__bindgen_ty_1_1 {
     fn clone(&self) -> Self { *self }
 }
 #[test]

tests/expectations/type_alias_empty.rs

@@ -4,4 +4,4 @@
 #![allow(non_snake_case)]
 
 
-
+pub type bool_constant = ();

tests/expectations/union_template.rs

@@ -28,21 +28,21 @@ impl <T> ::std::marker::Copy for __BindgenUnionField<T> { }
 #[derive(Debug, Copy, Clone)]
 pub struct NastyStruct<T> {
     pub mIsSome: bool,
-    pub mStorage: NastyStruct__bindgen_ty_1<T>,
-    pub __bindgen_anon_1: NastyStruct__bindgen_ty_2<T>,
+    pub mStorage: NastyStruct__bindgen_ty_2<T>,
+    pub __bindgen_anon_1: NastyStruct__bindgen_ty_1<T>,
     pub _phantom_0: ::std::marker::PhantomData<T>,
 }
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
-pub struct NastyStruct__bindgen_ty_1<T> {
+pub struct NastyStruct__bindgen_ty_2<T> {
     pub mFoo: __BindgenUnionField<*mut ::std::os::raw::c_void>,
     pub mDummy: __BindgenUnionField<::std::os::raw::c_ulong>,
     pub bindgen_union_field: u64,
     pub _phantom_0: ::std::marker::PhantomData<T>,
 }
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
-pub struct NastyStruct__bindgen_ty_2<T> {
+pub struct NastyStruct__bindgen_ty_1<T> {
     pub wat: __BindgenUnionField<::std::os::raw::c_short>,
     pub wut: __BindgenUnionField<*mut ::std::os::raw::c_int>,
     pub bindgen_union_field: u64,