Fixed logic error in codegen/mod.rs and updated tests

Author: hgallagher1993

src/codegen/mod.rs

@@ -1449,7 +1449,7 @@ impl CodeGenerator for CompInfo {
             ctx.options().derive_copy
         {
             derives.push("Copy");
-            if used_template_params.is_empty() {
+            if !used_template_params.is_empty() {
                 // FIXME: This requires extra logic if you have a big array in a
                 // templated struct. The reason for this is that the magic:
                 //     fn clone(&self) -> Self { *self }

tests/expectations/tests/381-decltype-alias.rs

@@ -5,8 +5,13 @@
 
 
 #[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
+#[derive(Debug, Default, Copy)]
 pub struct std_allocator_traits {
     pub _address: u8,
 }
 pub type std_allocator_traits___size_type<_Alloc> = _Alloc;
+impl Clone for std_allocator_traits {
+    fn clone(&self) -> Self {
+        *self
+    }
+}

tests/expectations/tests/anon_enum_trait.rs

@@ -5,27 +5,29 @@
 
 
 #[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
 pub struct DataType {
     pub _address: u8,
 }
 pub type DataType_value_type<_Tp> = _Tp;
 pub type DataType_work_type<_Tp> = DataType_value_type<_Tp>;
 pub type DataType_channel_type<_Tp> = DataType_value_type<_Tp>;
 pub type DataType_vec_type<_Tp> = DataType_value_type<_Tp>;
-pub const DataType_generic_type: DataType__bindgen_ty_1 =
-    DataType__bindgen_ty_1::generic_type;
-pub const DataType_depth: DataType__bindgen_ty_1 =
-    DataType__bindgen_ty_1::generic_type;
-pub const DataType_channels: DataType__bindgen_ty_1 =
-    DataType__bindgen_ty_1::generic_type;
-pub const DataType_fmt: DataType__bindgen_ty_1 =
-    DataType__bindgen_ty_1::generic_type;
-pub const DataType_type_: DataType__bindgen_ty_1 =
-    DataType__bindgen_ty_1::generic_type;
+pub const DataType_generic_type: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type;
+pub const DataType_depth: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type;
+pub const DataType_channels: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type;
+pub const DataType_fmt: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type;
+pub const DataType_type_: DataType__bindgen_ty_1 = DataType__bindgen_ty_1::generic_type;
 #[repr(i32)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub enum DataType__bindgen_ty_1 { generic_type = 0, }
+pub enum DataType__bindgen_ty_1 {
+    generic_type = 0,
+}
+impl Clone for DataType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
 #[repr(C)]
 #[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
 pub struct Foo {
@@ -35,14 +37,24 @@ pub const Foo_Bar: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar;
 pub const Foo_Baz: Foo__bindgen_ty_1 = Foo__bindgen_ty_1::Bar;
 #[repr(u32)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub enum Foo__bindgen_ty_1 { Bar = 0, }
+pub enum Foo__bindgen_ty_1 {
+    Bar = 0,
+}
 #[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!(
+        ::std::mem::size_of::<Foo>(),
+        1usize,
+        concat!("Size of: ", stringify!(Foo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Foo>(),
+        1usize,
+        concat!("Alignment of ", stringify!(Foo))
+    );
 }
 impl Clone for Foo {
-    fn clone(&self) -> Self { *self }
+    fn clone(&self) -> Self {
+        *self
+    }
 }

tests/expectations/tests/anon_union.rs

@@ -5,6 +5,7 @@
 
 
 #[repr(C)]
+#[derive(Copy)]
 pub struct TErrorResult {
     pub mResult: ::std::os::raw::c_int,
     pub __bindgen_anon_1: TErrorResult__bindgen_ty_1,
@@ -15,49 +16,103 @@ pub const TErrorResult_UnionState_HasException: TErrorResult_UnionState =
     TErrorResult_UnionState::HasMessage;
 #[repr(i32)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub enum TErrorResult_UnionState { HasMessage = 0, }
+pub enum TErrorResult_UnionState {
+    HasMessage = 0,
+}
 #[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone)]
 pub struct TErrorResult_Message {
-    pub _address: u8,
+    _unused: [u8; 0],
 }
 #[repr(C)]
-#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone)]
 pub struct TErrorResult_DOMExceptionInfo {
-    pub _address: u8,
+    _unused: [u8; 0],
 }
 #[repr(C)]
+#[derive(Copy)]
 pub union TErrorResult__bindgen_ty_1 {
     pub mMessage: *mut TErrorResult_Message,
     pub mDOMExceptionInfo: *mut TErrorResult_DOMExceptionInfo,
     _bindgen_union_align: u64,
 }
+#[test]
+fn bindgen_test_layout_TErrorResult__bindgen_ty_1() {
+    assert_eq!(
+        ::std::mem::size_of::<TErrorResult__bindgen_ty_1>(),
+        8usize,
+        concat!("Size of: ", stringify!(TErrorResult__bindgen_ty_1))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TErrorResult__bindgen_ty_1>(),
+        8usize,
+        concat!("Alignment of ", stringify!(TErrorResult__bindgen_ty_1))
+    );
+}
+impl Clone for TErrorResult__bindgen_ty_1 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
 impl Default for TErrorResult__bindgen_ty_1 {
-    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+    fn default() -> Self {
+        unsafe { ::std::mem::zeroed() }
+    }
+}
+impl Clone for TErrorResult {
+    fn clone(&self) -> Self {
+        *self
+    }
 }
 impl Default for TErrorResult {
-    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+    fn default() -> Self {
+        unsafe { ::std::mem::zeroed() }
+    }
 }
 #[repr(C)]
+#[derive(Copy)]
 pub struct ErrorResult {
     pub _base: TErrorResult,
 }
 #[test]
 fn bindgen_test_layout_ErrorResult() {
-    assert_eq!(::std::mem::size_of::<ErrorResult>() , 24usize , concat ! (
-               "Size of: " , stringify ! ( ErrorResult ) ));
-    assert_eq! (::std::mem::align_of::<ErrorResult>() , 8usize , concat ! (
-                "Alignment of " , stringify ! ( ErrorResult ) ));
+    assert_eq!(
+        ::std::mem::size_of::<ErrorResult>(),
+        24usize,
+        concat!("Size of: ", stringify!(ErrorResult))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ErrorResult>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ErrorResult))
+    );
+}
+impl Clone for ErrorResult {
+    fn clone(&self) -> Self {
+        *self
+    }
 }
 impl Default for ErrorResult {
-    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+    fn default() -> Self {
+        unsafe { ::std::mem::zeroed() }
+    }
 }
 #[test]
 fn __bindgen_test_layout_TErrorResult_open0_int_close0_instantiation() {
-    assert_eq!(::std::mem::size_of::<TErrorResult>() , 24usize , concat ! (
-               "Size of template specialization: " , stringify ! (
-               TErrorResult ) ));
-    assert_eq!(::std::mem::align_of::<TErrorResult>() , 8usize , concat ! (
-               "Alignment of template specialization: " , stringify ! (
-               TErrorResult ) ));
+    assert_eq!(
+        ::std::mem::size_of::<TErrorResult>(),
+        24usize,
+        concat!(
+            "Size of template specialization: ",
+            stringify!(TErrorResult)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<TErrorResult>(),
+        8usize,
+        concat!(
+            "Alignment of template specialization: ",
+            stringify!(TErrorResult)
+        )
+    );
 }