Implements Debug trait for types which do not support derive Debug

For types that do not support derive Debug be implemented automatically by rust,
we know can generate implementations of the Debug trait. This code generation is
hidden behind the '--force-derive-debug' command-line flag.

10 files changed, 304 insertions, 0 deletions

diff --git a/tests/expectations/tests/derive-debug-bitfield.rs b/tests/expectations/tests/derive-debug-bitfield.rs
new file mode 100644
index 00000000..62e941e4
--- /dev/null
+++ b/tests/expectations/tests/derive-debug-bitfield.rs
@@ -0,0 +1,119 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[repr(C)]
+#[derive(Copy)]
+pub struct C {
+    pub _bitfield_1: u8,
+    pub large_array: [::std::os::raw::c_int; 50usize],
+}
+#[test]
+fn bindgen_test_layout_C() {
+    assert_eq!(::std::mem::size_of::<C>() , 204usize , concat ! (
+               "Size of: " , stringify ! ( C ) ));
+    assert_eq! (::std::mem::align_of::<C>() , 4usize , concat ! (
+                "Alignment of " , stringify ! ( C ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const C ) ) . large_array as * const _ as usize
+                } , 4usize , concat ! (
+                "Alignment of field: " , stringify ! ( C ) , "::" , stringify
+                ! ( large_array ) ));
+}
+impl Clone for C {
+    fn clone(&self) -> Self { *self }
+}
+impl Default for C {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+impl ::std::fmt::Debug for C {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f , "C {{ a : {:?}, b : {:?}, large_array: [{}] }}" , self . a
+               (  ) , self . b (  ) , self . large_array . iter (  ) .
+               enumerate (  ) . map (
+               | ( i , v ) | format ! (
+               "{}{:?}" , if i > 0 { ", " } else { "" } , v ) ) . collect :: <
+               String > (  ))
+    }
+}
+impl C {
+    #[inline]
+    pub fn a(&self) -> bool {
+        let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+        unsafe {
+            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+                                                *const u8,
+                                            &mut unit_field_val as *mut u8 as
+                                                *mut u8,
+                                            ::std::mem::size_of::<u8>())
+        };
+        let mask = 1u64 as u8;
+        let val = (unit_field_val & mask) >> 0usize;
+        unsafe { ::std::mem::transmute(val as u8) }
+    }
+    #[inline]
+    pub fn set_a(&mut self, val: bool) {
+        let mask = 1u64 as u8;
+        let val = val as u8 as u8;
+        let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+        unsafe {
+            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+                                                *const u8,
+                                            &mut unit_field_val as *mut u8 as
+                                                *mut u8,
+                                            ::std::mem::size_of::<u8>())
+        };
+        unit_field_val &= !mask;
+        unit_field_val |= (val << 0usize) & mask;
+        unsafe {
+            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                *const u8,
+                                            &mut self._bitfield_1 as *mut _ as
+                                                *mut u8,
+                                            ::std::mem::size_of::<u8>());
+        }
+    }
+    #[inline]
+    pub fn b(&self) -> bool {
+        let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+        unsafe {
+            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+                                                *const u8,
+                                            &mut unit_field_val as *mut u8 as
+                                                *mut u8,
+                                            ::std::mem::size_of::<u8>())
+        };
+        let mask = 254u64 as u8;
+        let val = (unit_field_val & mask) >> 1usize;
+        unsafe { ::std::mem::transmute(val as u8) }
+    }
+    #[inline]
+    pub fn set_b(&mut self, val: bool) {
+        let mask = 254u64 as u8;
+        let val = val as u8 as u8;
+        let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+        unsafe {
+            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+                                                *const u8,
+                                            &mut unit_field_val as *mut u8 as
+                                                *mut u8,
+                                            ::std::mem::size_of::<u8>())
+        };
+        unit_field_val &= !mask;
+        unit_field_val |= (val << 1usize) & mask;
+        unsafe {
+            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                *const u8,
+                                            &mut self._bitfield_1 as *mut _ as
+                                                *mut u8,
+                                            ::std::mem::size_of::<u8>());
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(a: bool, b: bool) -> u8 {
+        ({ ({ 0 } | ((a as u8 as u8) << 0usize) & (1u64 as u8)) } |
+             ((b as u8 as u8) << 1usize) & (254u64 as u8))
+    }
+}
diff --git a/tests/expectations/tests/derive-debug-function-pointer.rs b/tests/expectations/tests/derive-debug-function-pointer.rs
new file mode 100644
index 00000000..03cafe97
--- /dev/null
+++ b/tests/expectations/tests/derive-debug-function-pointer.rs
@@ -0,0 +1,47 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[repr(C)]
+#[derive(Copy)]
+pub struct Nice {
+    pub pointer: Nice_Function,
+    pub large_array: [::std::os::raw::c_int; 34usize],
+}
+pub type Nice_Function =
+    ::std::option::Option<unsafe extern "C" fn(data: ::std::os::raw::c_int)>;
+#[test]
+fn bindgen_test_layout_Nice() {
+    assert_eq!(::std::mem::size_of::<Nice>() , 144usize , concat ! (
+               "Size of: " , stringify ! ( Nice ) ));
+    assert_eq! (::std::mem::align_of::<Nice>() , 8usize , concat ! (
+                "Alignment of " , stringify ! ( Nice ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Nice ) ) . pointer as * const _ as usize
+                } , 0usize , concat ! (
+                "Alignment of field: " , stringify ! ( Nice ) , "::" ,
+                stringify ! ( pointer ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Nice ) ) . large_array as * const _ as
+                usize } , 8usize , concat ! (
+                "Alignment of field: " , stringify ! ( Nice ) , "::" ,
+                stringify ! ( large_array ) ));
+}
+impl Clone for Nice {
+    fn clone(&self) -> Self { *self }
+}
+impl Default for Nice {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+impl ::std::fmt::Debug for Nice {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f , "Nice {{ pointer: {:?}, large_array: [{}] }}" , self .
+               pointer , self . large_array . iter (  ) . enumerate (  ) . map
+               (
+               | ( i , v ) | format ! (
+               "{}{:?}" , if i > 0 { ", " } else { "" } , v ) ) . collect :: <
+               String > (  ))
+    }
+}
diff --git a/tests/expectations/tests/derive-debug-generic.rs b/tests/expectations/tests/derive-debug-generic.rs
new file mode 100644
index 00000000..f238234a
--- /dev/null
+++ b/tests/expectations/tests/derive-debug-generic.rs
@@ -0,0 +1,19 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[repr(C)]
+pub struct Generic<T> {
+    pub t: [T; 40usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl <T> Default for Generic<T> {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+impl <T> ::std::fmt::Debug for Generic<T> {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f , "Generic {{ t: Array with length 40 }}")
+    }
+}
diff --git a/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs b/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs
new file mode 100644
index 00000000..e5529255
--- /dev/null
+++ b/tests/expectations/tests/derive-debug-opaque-template-instantiation.rs
@@ -0,0 +1,30 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[repr(C)]
+pub struct Instance {
+    pub val: [u32; 50usize],
+}
+#[test]
+fn bindgen_test_layout_Instance() {
+    assert_eq!(::std::mem::size_of::<Instance>() , 200usize , concat ! (
+               "Size of: " , stringify ! ( Instance ) ));
+    assert_eq! (::std::mem::align_of::<Instance>() , 4usize , concat ! (
+                "Alignment of " , stringify ! ( Instance ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Instance ) ) . val as * const _ as usize
+                } , 0usize , concat ! (
+                "Alignment of field: " , stringify ! ( Instance ) , "::" ,
+                stringify ! ( val ) ));
+}
+impl Default for Instance {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+impl ::std::fmt::Debug for Instance {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f , "Instance {{ val: opaque }}")
+    }
+}
diff --git a/tests/expectations/tests/derive-debug-opaque.rs b/tests/expectations/tests/derive-debug-opaque.rs
new file mode 100644
index 00000000..267aca11
--- /dev/null
+++ b/tests/expectations/tests/derive-debug-opaque.rs
@@ -0,0 +1,49 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[repr(C)]
+pub struct Opaque {
+    pub _bindgen_opaque_blob: [u32; 41usize],
+}
+#[test]
+fn bindgen_test_layout_Opaque() {
+    assert_eq!(::std::mem::size_of::<Opaque>() , 164usize , concat ! (
+               "Size of: " , stringify ! ( Opaque ) ));
+    assert_eq! (::std::mem::align_of::<Opaque>() , 4usize , concat ! (
+                "Alignment of " , stringify ! ( Opaque ) ));
+}
+impl Default for Opaque {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+impl ::std::fmt::Debug for Opaque {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f , "Opaque {{ opaque }}")
+    }
+}
+#[repr(C)]
+pub struct OpaqueUser {
+    pub opaque: Opaque,
+}
+#[test]
+fn bindgen_test_layout_OpaqueUser() {
+    assert_eq!(::std::mem::size_of::<OpaqueUser>() , 164usize , concat ! (
+               "Size of: " , stringify ! ( OpaqueUser ) ));
+    assert_eq! (::std::mem::align_of::<OpaqueUser>() , 4usize , concat ! (
+                "Alignment of " , stringify ! ( OpaqueUser ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const OpaqueUser ) ) . opaque as * const _ as
+                usize } , 0usize , concat ! (
+                "Alignment of field: " , stringify ! ( OpaqueUser ) , "::" ,
+                stringify ! ( opaque ) ));
+}
+impl Default for OpaqueUser {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+impl ::std::fmt::Debug for OpaqueUser {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f , "OpaqueUser {{ opaque: {:?} }}" , self . opaque)
+    }
+}
diff --git a/tests/headers/derive-debug-bitfield.hpp b/tests/headers/derive-debug-bitfield.hpp
new file mode 100644
index 00000000..4d8c3771
--- /dev/null
+++ b/tests/headers/derive-debug-bitfield.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --opaque-type "Opaque" --force-derive-debug
+
+class C {
+  bool a: 1;
+  bool b: 7;
+  int large_array[50];
+};
diff --git a/tests/headers/derive-debug-function-pointer.hpp b/tests/headers/derive-debug-function-pointer.hpp
new file mode 100644
index 00000000..df746da5
--- /dev/null
+++ b/tests/headers/derive-debug-function-pointer.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: --force-derive-debug
+
+class Nice {
+  typedef void (*Function) (int data);
+  Function pointer;
+  int large_array[34];
+};
diff --git a/tests/headers/derive-debug-generic.hpp b/tests/headers/derive-debug-generic.hpp
new file mode 100644
index 00000000..58afac45
--- /dev/null
+++ b/tests/headers/derive-debug-generic.hpp
@@ -0,0 +1,6 @@
+// bindgen-flags: --force-derive-debug
+
+template<typename T>
+class Generic {
+  T t[40];
+};
diff --git a/tests/headers/derive-debug-opaque-template-instantiation.hpp b/tests/headers/derive-debug-opaque-template-instantiation.hpp
new file mode 100644
index 00000000..555ba826
--- /dev/null
+++ b/tests/headers/derive-debug-opaque-template-instantiation.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --force-derive-debug
+
+template<typename T, int N>
+class Opaque {
+  T array[N];
+};
+
+class Instance {
+  Opaque<int, 50> val;
+};
diff --git a/tests/headers/derive-debug-opaque.hpp b/tests/headers/derive-debug-opaque.hpp
new file mode 100644
index 00000000..05c504a9
--- /dev/null
+++ b/tests/headers/derive-debug-opaque.hpp
@@ -0,0 +1,10 @@
+// bindgen-flags: --opaque-type "Opaque" --force-derive-debug
+
+class Opaque {
+  int i;
+  int not_debug[40];
+};
+
+class OpaqueUser {
+  Opaque opaque;
+};