Let Rust derive everything but Default for large arrays in 1.47 and later

Fixes #1977 as of rust-lang/rust#74060 is available since Rust 1.47
Fixes #2041.
Closes #2070.

Author: Ian P. Cooke

src/codegen/impl_debug.rs

@@ -181,7 +181,9 @@ impl<'a> ImplDebug<'a> for Item {
                         format!("{}: Array with length {}", name, len),
                         vec![],
                     ))
-                } else if len < RUST_DERIVE_IN_ARRAY_LIMIT {
+                } else if len < RUST_DERIVE_IN_ARRAY_LIMIT ||
+                    ctx.options().rust_features().larger_arrays
+                {
                     // The simple case
                     debug_print(name, quote! { #name_ident })
                 } else {

src/codegen/impl_partialeq.rs

@@ -114,7 +114,9 @@ fn gen_field(
         }
 
         TypeKind::Array(_, len) => {
-            if len <= RUST_DERIVE_IN_ARRAY_LIMIT {
+            if len <= RUST_DERIVE_IN_ARRAY_LIMIT ||
+                ctx.options().rust_features().larger_arrays
+            {
                 quote_equals(name_ident)
             } else {
                 quote! {

src/codegen/mod.rs

@@ -1503,7 +1503,8 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
 
         // We cannot generate any constructor if the underlying storage can't
         // implement AsRef<[u8]> / AsMut<[u8]> / etc.
-        let mut generate_ctor = layout.size <= RUST_DERIVE_IN_ARRAY_LIMIT;
+        let mut generate_ctor = layout.size <= RUST_DERIVE_IN_ARRAY_LIMIT ||
+            ctx.options().rust_features().larger_arrays;
 
         let mut access_spec = !fields_should_be_private;
         for bf in self.bitfields() {
@@ -1512,7 +1513,9 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
                 continue;
             }
 
-            if layout.size > RUST_DERIVE_IN_ARRAY_LIMIT {
+            if layout.size > RUST_DERIVE_IN_ARRAY_LIMIT &&
+                !ctx.options().rust_features().larger_arrays
+            {
                 continue;
             }
 

src/features.rs

@@ -123,6 +123,9 @@ macro_rules! rust_target_base {
             /// Rust stable 1.40
             /// * `non_exhaustive` enums/structs ([Tracking issue](https://github.com/rust-lang/rust/issues/44109))
             => Stable_1_40 => 1.40;
+            /// Rust stable 1.47
+            /// * `larger_arrays` ([Tracking issue](https://github.com/rust-lang/rust/pull/74060))
+            => Stable_1_47 => 1.47;
             /// Nightly rust
             ///  * `thiscall` calling convention ([Tracking issue](https://github.com/rust-lang/rust/issues/42202))
             => Nightly => nightly;
@@ -134,7 +137,7 @@ rust_target_base!(rust_target_def);
 rust_target_base!(rust_target_values_def);
 
 /// Latest stable release of Rust
-pub const LATEST_STABLE_RUST: RustTarget = RustTarget::Stable_1_40;
+pub const LATEST_STABLE_RUST: RustTarget = RustTarget::Stable_1_47;
 
 /// Create RustFeatures struct definition, new(), and a getter for each field
 macro_rules! rust_feature_def {
@@ -222,6 +225,9 @@ rust_feature_def!(
     Stable_1_40 {
         => non_exhaustive;
     }
+    Stable_1_47 {
+        => larger_arrays;
+    }
     Nightly {
         => thiscall_abi;
     }

src/ir/analysis/derive.rs

@@ -255,7 +255,7 @@ impl<'ctx> CannotDerive<'ctx> {
                     return CanDerive::No;
                 }
 
-                if self.derive_trait.can_derive_large_array() {
+                if self.derive_trait.can_derive_large_array(&self.ctx) {
                     trace!("    array can derive {}", self.derive_trait);
                     return CanDerive::Yes;
                 }
@@ -377,7 +377,7 @@ impl<'ctx> CannotDerive<'ctx> {
                 // Bitfield units are always represented as arrays of u8, but
                 // they're not traced as arrays, so we need to check here
                 // instead.
-                if !self.derive_trait.can_derive_large_array() &&
+                if !self.derive_trait.can_derive_large_array(&self.ctx) &&
                     info.has_too_large_bitfield_unit() &&
                     !item.is_opaque(self.ctx, &())
                 {
@@ -496,10 +496,17 @@ impl DeriveTrait {
         }
     }
 
-    fn can_derive_large_array(&self) -> bool {
-        match self {
-            DeriveTrait::Copy => true,
-            _ => false,
+    fn can_derive_large_array(&self, ctx: &BindgenContext) -> bool {
+        if ctx.options().rust_features().larger_arrays {
+            match self {
+                DeriveTrait::Default => false,
+                _ => true,
+            }
+        } else {
+            match self {
+                DeriveTrait::Copy => true,
+                _ => false,
+            }
         }
     }
 
@@ -686,7 +693,7 @@ impl<'ctx> MonotoneFramework for CannotDerive<'ctx> {
             Some(ty) => {
                 let mut can_derive = self.constrain_type(item, ty);
                 if let CanDerive::Yes = can_derive {
-                    if !self.derive_trait.can_derive_large_array() &&
+                    if !self.derive_trait.can_derive_large_array(&self.ctx) &&
                         ty.layout(self.ctx).map_or(false, |l| {
                             l.align > RUST_DERIVE_IN_ARRAY_LIMIT
                         })

src/ir/ty.rs

@@ -39,7 +39,6 @@ pub struct Type {
 /// traits, and so if we have a type containing an array with more than this
 /// many items, we won't be able to derive common traits on that type.
 ///
-/// We need type-level integers yesterday :'(
 pub const RUST_DERIVE_IN_ARRAY_LIMIT: usize = 32;
 
 impl Type {

tests/expectations/tests/issue-1977-larger-arrays.rs

@@ -0,0 +1,61 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct S {
+    pub large_array: [::std::os::raw::c_char; 33usize],
+}
+#[test]
+fn bindgen_test_layout_S() {
+    assert_eq!(
+        ::std::mem::size_of::<S>(),
+        33usize,
+        concat!("Size of: ", stringify!(S))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<S>(),
+        1usize,
+        concat!("Alignment of ", stringify!(S))
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<S>())).large_array as *const _ as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(S),
+            "::",
+            stringify!(large_array)
+        )
+    );
+}
+impl Default for S {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub struct ST<T> {
+    pub large_array: [T; 33usize],
+    pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl<T> Default for ST<T> {
+    fn default() -> Self {
+        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
+        unsafe {
+            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
+            s.assume_init()
+        }
+    }
+}

tests/expectations/tests/issue-648-derive-debug-with-padding.rs

@@ -6,9 +6,7 @@
 )]
 
 /// We emit a `[u8; 63usize]` padding field for this struct, which cannot derive
-/// Debug/Hash because 63 is over the hard coded limit. (Yes, this struct doesn't end
-/// up with the reight alignment, we're waiting on `#[repr(align="N")]` to land
-/// in rustc).
+/// Debug/Hash because 63 is over the hard coded limit.
 #[repr(C)]
 #[repr(align(64))]
 #[derive(Copy, Clone)]
@@ -55,7 +53,7 @@ impl ::std::cmp::PartialEq for NoDebug {
 /// This should derive Debug/Hash/PartialEq/Eq because the padding size is less than the max derive
 /// Debug/Hash/PartialEq/Eq impl for arrays. However, we conservatively don't derive Debug/Hash because
 /// we determine Debug derive-ability before we compute padding, which happens at
-/// codegen. (Again, we expect to get the alignment wrong for similar reasons.)
+/// codegen.
 #[repr(C)]
 #[repr(align(64))]
 #[derive(Copy, Clone)]

tests/headers/class.hpp

@@ -1,4 +1,4 @@
-// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --with-derive-partialord --with-derive-ord
+// bindgen-flags: --with-derive-hash --with-derive-partialeq --with-derive-eq --with-derive-partialord --with-derive-ord --rust-target 1.40
 //
 class C {
     int a;

tests/headers/derive-bitfield-method-same-name.hpp

@@ -1,4 +1,4 @@
-// bindgen-flags: --with-derive-partialeq --impl-partialeq --impl-debug
+// bindgen-flags: --with-derive-partialeq --impl-partialeq --impl-debug --rust-target 1.40
 
 /// Because this struct have array larger than 32 items 
 /// and --with-derive-partialeq --impl-partialeq --impl-debug is provided,