Copy should not be derived if blacklisted type is included

[upsuper]

Input C/C++ Header

struct Bar {
};

struct Foo {
  Bar a;
};

Bindgen Invocation

$ bindgen test.hpp --blacklist-type Bar

Actual Results

#[repr(C)]
#[derive(Debug, Copy)]
pub struct Foo {
    pub a: Bar,
}
#[test]
fn bindgen_test_layout_Foo() {
    assert_eq!(::std::mem::size_of::<Foo>() , 1usize , concat ! (
               "Size of: " , stringify ! ( Foo ) ));
    assert_eq! (::std::mem::align_of::<Foo>() , 1usize , concat ! (
                "Alignment of " , stringify ! ( Foo ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const Foo ) ) . a as * const _ as usize } ,
                0usize , concat ! (
                "Alignment of field: " , stringify ! ( Foo ) , "::" ,
                stringify ! ( a ) ));
}
impl Clone for Foo {
    fn clone(&self) -> Self { *self }
}

Expected Results

struct Foo should not have #[derive(Copy)] because it is unknown whether the blacklisted type is Copy at all. Actually a type being blacklisted is usually a strong indication that it is a complicated type and bindgen shouldn't put any assumption on it at all.

[upsuper]

I looked into the code for a bit, but failed to figure out the best way to fix. Type blacklisting is based on name path, while derive check is based on item. We probably need some higher level check to stop deriving things when any name in blacklist presents in type declaration.

[emilio]

Yeah, the problem is that the checks act in the whitelisted items, and since we store the types that can't be derived instead of the ones that can, effectively all non-whitelisted items end up deriving copy.

[fitzgen]

I'll whip up a fix for this.

[fitzgen]

Fix in #950