Add capture with custom destructor test

Author: lucic71

tests/unit/lambda_capture_copy_ctor.cpp

@@ -11,6 +11,15 @@ struct Counted {
   Counted(Counted &&o) : copies(o.copies), moves(o.moves + 1) {}
 };
 
+int drops = 0;
+
+struct Dropped {
+  Dropped() {}
+  Dropped(const Dropped &) {}
+  Dropped(Dropped &&) {}
+  ~Dropped() { drops++; }
+};
+
 int main() {
   Counted c;
   auto f = [c]() { return c.copies * 10 + c.moves; };
@@ -33,5 +42,17 @@ int main() {
   auto a2 = a;
   assert(a2() == 4);
 
+  {
+    auto m = [d = Dropped()]() {};
+    auto m2 = std::move(m);
+  }
+  assert(drops == 2);
+
+  {
+    auto k = [d = Dropped()]() {};
+    auto k2 = k;
+  }
+  assert(drops == 4);
+
   return 0;
 }

tests/unit/out/unsafe/lambda_capture_copy_ctor.rs

@@ -45,6 +45,37 @@ impl Default for Counted {
         unsafe { Counted::new() }
     }
 }
+pub static mut drops_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
+#[repr(C)]
+#[derive()]
+pub struct Dropped {}
+impl Dropped {
+    pub unsafe fn new() -> Self {
+        let mut this = Self {};
+        this
+    }
+    pub unsafe fn copy_from(_a0: *const Dropped) -> Self {
+        let mut this = Self {};
+        this
+    }
+    pub unsafe fn move_from(_a0: *mut Dropped) -> Self {
+        let mut this = Self {};
+        this
+    }
+    pub unsafe fn destructor(&mut self) {
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut drops_0)).postfix_inc();
+    }
+}
+impl Clone for Dropped {
+    fn clone(&self) -> Self {
+        unsafe { Dropped::copy_from(self as *const Dropped) }
+    }
+}
+impl Default for Dropped {
+    fn default() -> Self {
+        unsafe { Dropped::new() }
+    }
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
@@ -96,6 +127,16 @@ unsafe fn main_0() -> i32 {
     })
     .clone();
     assert!(((unsafe { a2() }) == (4)));
+    {
+        let mut m2: _ = (|| {});
+    }
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut drops_0)) == (2)));
+    {
+        let mut k2: _ = (|| {}).clone();
+    }
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut drops_0)) == (4)));
     return 0;
 }
-pub unsafe fn __cpp2rust_init_globals() {}
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const drops_0);
+}