Use the Default default implementation more often

Author: nunoplopes

cpp2rust/converter/converter.cpp

@@ -641,33 +641,35 @@ bool Converter::RecordDerivesDefault(const clang::RecordDecl *decl) {
   }
 
   for (auto f : decl->fields()) {
-    if (f->hasInClassInitializer()) {
+    if (f->hasInClassInitializer() || !TypeDerivesDefault(f->getType())) {
       return false;
     }
+  }
 
-    // Records that contain function pointer do not derive Default
-    if (auto ptr_ty = f->getType()->getAs<clang::PointerType>()) {
-      if (ptr_ty->getPointeeType()->isFunctionType()) {
-        return false;
-      }
-    }
+  return true;
+}
 
-    // Records that contain std::array do not derive Default
-    if (Printer::ToString(ctx_, f->getType()).contains("std::array")) {
-      return false;
-    }
+bool Converter::TypeDerivesDefault(clang::QualType qual_type) {
+  // Rust only implements Default for arrays of up to 32 elements
+  if (auto *array_type = ctx_.getAsConstantArrayType(qual_type)) {
+    return array_type->getSize().ule(32) &&
+           TypeDerivesDefault(array_type->getElementType());
+  }
+  if (qual_type->isArrayType()) {
+    return false;
+  }
 
-    // Records that contain C arrays do not derive Default
-    if (f->getType()->isArrayType()) {
-      return false;
-    }
+  // Types that need a custom array initializer (e.g., std::array, which is
+  // translated to Vec)
+  if (!GetArrayDefaultAsString(qual_type).empty()) {
+    return false;
+  }
 
-    // Records that contain libc types do not derive Default
-    if (auto record = f->getType()->getAsRecordDecl()) {
-      if (ctx_.getSourceManager().isInSystemHeader(record->getLocation()) &&
-          f->getType().isPODType(ctx_)) {
-        return false;
-      }
+  // libc types do not implement Default
+  if (auto record = qual_type->getAsRecordDecl()) {
+    if (ctx_.getSourceManager().isInSystemHeader(record->getLocation()) &&
+        qual_type.isPODType(ctx_)) {
+      return false;
     }
   }
 

cpp2rust/converter/converter.h

@@ -732,6 +732,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool RecordDerivesDefault(const clang::RecordDecl *decl);
 
+  virtual bool TypeDerivesDefault(clang::QualType qual_type);
+
   bool RecordDerivesCopy(const clang::RecordDecl *decl) const;
 
   bool IsPassThroughRule(clang::Expr *expr) const;

cpp2rust/converter/models/converter_refcount.cpp

@@ -2295,6 +2295,11 @@ ConverterRefCount::GetStructAttributes(const clang::RecordDecl *decl) {
   return attrs;
 }
 
+bool ConverterRefCount::TypeDerivesDefault(clang::QualType qual_type) {
+  // Arrays are translated to Value<Box<[T]>>, whose Default is empty
+  return !qual_type->isArrayType() && Converter::TypeDerivesDefault(qual_type);
+}
+
 std::string ConverterRefCount::ConvertVarInitValue(clang::QualType qual_type,
                                                    clang::Expr *expr) {
   if (auto lambda = clang::dyn_cast<clang::LambdaExpr>(

cpp2rust/converter/models/converter_refcount.h

@@ -229,6 +229,8 @@ class ConverterRefCount final : public Converter {
   std::vector<const char *>
   GetStructAttributes(const clang::RecordDecl *decl) override;
 
+  bool TypeDerivesDefault(clang::QualType qual_type) override;
+
   bool Convert(clang::QualType qual_type) override;
   bool
   Convert(clang::Expr *expr,

tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs

@@ -7,7 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive()]
+#[derive(Default)]
 pub struct S {
     pub v: Vec<i32>,
     pub n: [i32; 2],
@@ -42,14 +42,6 @@ impl S {
         return &mut (*(self as *mut S));
     }
 }
-impl Default for S {
-    fn default() -> Self {
-        S {
-            v: Default::default(),
-            n: [0_i32; 2],
-        }
-    }
-}
 pub unsafe fn sum_0(s: *const S) -> i32 {
     return ((((*s).v.len() as i32) + ((*s).n[(0) as usize])) + ((*s).n[(1) as usize]));
 }

tests/unit/default.cpp

@@ -6,8 +6,23 @@ struct Pointers {
   int x5;
 };
 
+struct SmallArrays {
+  int a[32];
+  int (*f)(int);
+  int (*fs[2])(int);
+  Pointers p[2];
+};
+
+struct BigArray {
+  int a[33];
+};
+
 int main() {
   Pointers *default_pointers = new Pointers[10];
   delete[] default_pointers;
+  SmallArrays *small = new SmallArrays[2];
+  delete[] small;
+  BigArray *big = new BigArray[2];
+  delete[] big;
   return 0;
 }

tests/unit/out/refcount/default.rs

@@ -43,6 +43,54 @@ impl Default for Pointers {
         }
     }
 }
+#[derive(DeepClone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[byte_size(440)]
+pub struct SmallArrays {
+    #[offset(0)]
+    #[byte_size(128)]
+    pub a: Value<Box<[i32]>>,
+    #[offset(128)]
+    #[byte_size(8)]
+    pub f: FnPtr<fn(i32) -> i32>,
+    #[offset(136)]
+    #[byte_size(16)]
+    pub fs: Value<Box<[FnPtr<fn(i32) -> i32>]>>,
+    #[offset(152)]
+    #[byte_size(288)]
+    pub p: Value<Box<[Pointers]>>,
+}
+impl Default for SmallArrays {
+    fn default() -> Self {
+        SmallArrays {
+            a: Rc::new(RefCell::new((0..32).map(|_| 0_i32).collect::<Box<[i32]>>())),
+            f: FnPtr::<fn(i32) -> i32>::null(),
+            fs: Rc::new(RefCell::new(
+                (0..2)
+                    .map(|_| FnPtr::<fn(i32) -> i32>::null())
+                    .collect::<Box<[FnPtr<fn(i32) -> i32>]>>(),
+            )),
+            p: Rc::new(RefCell::new(
+                (0..2)
+                    .map(|_| <Pointers>::default())
+                    .collect::<Box<[Pointers]>>(),
+            )),
+        }
+    }
+}
+#[derive(DeepClone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[byte_size(132)]
+pub struct BigArray {
+    #[offset(0)]
+    #[byte_size(132)]
+    pub a: Value<Box<[i32]>>,
+}
+impl Default for BigArray {
+    fn default() -> Self {
+        BigArray {
+            a: Rc::new(RefCell::new((0..33).map(|_| 0_i32).collect::<Box<[i32]>>())),
+        }
+    }
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -54,6 +102,18 @@ fn main_0() -> i32 {
             .collect::<Box<[Pointers]>>(),
     )));
     (*default_pointers.borrow()).delete();
+    let small: Value<Ptr<SmallArrays>> = Rc::new(RefCell::new(Ptr::alloc_array(
+        (0..2_usize)
+            .map(|_| <SmallArrays>::default())
+            .collect::<Box<[SmallArrays]>>(),
+    )));
+    (*small.borrow()).delete();
+    let big: Value<Ptr<BigArray>> = Rc::new(RefCell::new(Ptr::alloc_array(
+        (0..2_usize)
+            .map(|_| <BigArray>::default())
+            .collect::<Box<[BigArray]>>(),
+    )));
+    (*big.borrow()).delete();
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/default_in_statics.rs

@@ -60,7 +60,7 @@ impl Default for Outer {
         }
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
 #[byte_size(40)]
 pub struct Foo {
     #[offset(0)]
@@ -78,17 +78,6 @@ pub struct Foo {
     #[offset(32)]
     pub n: i32,
 }
-impl Default for Foo {
-    fn default() -> Self {
-        Foo {
-            s1: Ptr::<u8>::null(),
-            s2: Ptr::<u8>::null(),
-            fn1: FnPtr::<fn(i32) -> i32>::null(),
-            fn2: FnPtr::<fn(i32) -> i32>::null(),
-            n: 0_i32,
-        }
-    }
-}
 thread_local!(
     pub static static_fn_0: Value<FnPtr<fn(i32) -> i32>> =
         Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::null()));

tests/unit/out/refcount/fn_ptr_struct.rs

@@ -6,7 +6,7 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
 #[byte_size(16)]
 pub struct Handler {
     #[offset(0)]
@@ -15,14 +15,6 @@ pub struct Handler {
     #[byte_size(8)]
     pub cb: FnPtr<fn(i32) -> i32>,
 }
-impl Default for Handler {
-    fn default() -> Self {
-        Handler {
-            tag: 0_i32,
-            cb: FnPtr::<fn(i32) -> i32>::null(),
-        }
-    }
-}
 pub fn double_it_0(x: i32) -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(x));
     return ((*x.borrow()) * 2);

tests/unit/out/refcount/fn_ptr_vtable.rs

@@ -6,7 +6,7 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
 #[byte_size(24)]
 pub struct Vtable {
     #[offset(0)]
@@ -19,15 +19,6 @@ pub struct Vtable {
     #[byte_size(8)]
     pub destroy: FnPtr<fn(AnyPtr)>,
 }
-impl Default for Vtable {
-    fn default() -> Self {
-        Vtable {
-            create: FnPtr::<fn(i32) -> AnyPtr>::null(),
-            get: FnPtr::<fn(AnyPtr) -> i32>::null(),
-            destroy: FnPtr::<fn(AnyPtr)>::null(),
-        }
-    }
-}
 thread_local!(
     pub static storage_0: Value<i32> = Rc::new(RefCell::new(0_i32));
 );