Trace methods in CompInfo's TypeCollector impl

src/ir/comp.rs

@@ -957,6 +957,8 @@ impl TypeCollector for CompInfo {
             types.insert(var);
         }
 
-        // FIXME(emilio): Methods, VTable?
+        for method in self.methods() {
+            types.insert(method.signature);
+        }
     }
 }

src/ir/item.rs

@@ -205,7 +205,12 @@ impl TypeCollector for Item {
             ItemKind::Var(ref var) => {
                 types.insert(var.ty());
             }
-            _ => {} // FIXME.
+            ItemKind::Module(_) => {
+                // Module -> children edges are "weak", and we do not want to
+                // trace them. If we did, then whitelisting wouldn't work as
+                // expected: everything in every module would end up
+                // whitelisted.
+            }
         }
     }
 }

src/ir/ty.rs

@@ -914,13 +914,24 @@ impl TypeCollector for Type {
             TypeKind::Function(ref sig) => {
                 sig.collect_types(context, types, item)
             }
-            TypeKind::Named(_) => {}
-            // FIXME: Pending types!
-            ref other @ _ => {
-                debug!("<Type as TypeCollector>::collect_types: Ignoring: \
-                       {:?}",
-                       other);
+            TypeKind::Enum(ref en) => {
+                if let Some(repr) = en.repr() {
+                    types.insert(repr);
+                }
+            }
+            TypeKind::UnresolvedTypeRef(_, _, Some(id)) => {
+                types.insert(id);
             }
+
+            // None of these variants have edges to other items and types.
+            TypeKind::UnresolvedTypeRef(_, _, None) |
+            TypeKind::Named(_) |
+            TypeKind::Void |
+            TypeKind::NullPtr |
+            TypeKind::Int(_) |
+            TypeKind::Float(_) |
+            TypeKind::Complex(_) |
+            TypeKind::BlockPointer => {}
         }
     }
 }

tests/expectations/tests/issue-410.rs

@@ -0,0 +1,41 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+pub mod root {
+    #[allow(unused_imports)]
+    use self::super::root;
+    pub mod JS {
+        #[allow(unused_imports)]
+        use self::super::super::root;
+        pub use root::_bindgen_ty_1 as JSWhyMagic;
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct Value {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_Value() {
+            assert_eq!(::std::mem::size_of::<Value>() , 1usize);
+            assert_eq!(::std::mem::align_of::<Value>() , 1usize);
+        }
+        extern "C" {
+            #[link_name = "_ZN2JS5Value1aE10JSWhyMagic"]
+            pub fn Value_a(this: *mut root::JS::Value,
+                           arg1: root::JS::JSWhyMagic);
+        }
+        impl Clone for Value {
+            fn clone(&self) -> Self { *self }
+        }
+        impl Value {
+            #[inline]
+            pub unsafe fn a(&mut self, arg1: root::JS::JSWhyMagic) {
+                Value_a(&mut *self, arg1)
+            }
+        }
+    }
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum _bindgen_ty_1 { }
+}

tests/headers/issue-410.hpp

@@ -0,0 +1,12 @@
+// bindgen-flags: --enable-cxx-namespaces --whitelist-type JS::Value
+
+namespace JS {
+class Value;
+}
+typedef enum {} JSWhyMagic;
+namespace JS {
+class Value {
+public:
+  void a(JSWhyMagic);
+};
+}