Test(ui): Extend block tests for with_encoding

Signed-off-by: Paul Mabileau <paul.mabileau@harfanglab.fr>

crates/test-ui/ui/block_lifetimes_independent.rs

@@ -1,7 +1,9 @@
 //! Test that lifetimes in blocks are not bound to each other.
 //!
 //! These tests will succeed if there are `'a: 'b`-like bounds on the closure.
-use block2::RcBlock;
+use block2::{ManualBlockEncoding, RcBlock};
+use std::ffi::CStr;
+use std::marker::PhantomData;
 
 fn args<'a, 'b>(
  f: impl Fn(&'a i32, &'b i32) + 'static,
@@ -23,4 +25,50 @@ fn return_entire<'a, 'b>(f: impl Fn() -> &'a i32 + 'b) -> RcBlock<dyn Fn() -> &'
  RcBlock::new(f)
 }
 
+fn args_with_encoding<'a, 'b>(
+ f: impl Fn(&'a i32, &'b i32) + 'static,
+) -> RcBlock<dyn Fn(&'b i32, &'a i32) + 'static> {
+ struct Enc<'a, 'b>(PhantomData<&'a i32>, PhantomData<&'b i32>);
+ unsafe impl<'a, 'b> ManualBlockEncoding for Enc<'a, 'b> {
+ type Arguments = (&'a i32, &'b i32);
+ type Return = ();
+ const ENCODING_CSTR: &'static CStr = c"v24@?0^i8^i16";
+ }
+ unsafe { RcBlock::with_encoding::<_, _, _, Enc<'a, 'b>>(f) }
+}
+
+fn args_return_with_encoding<'a, 'b>(
+ f: impl Fn(&'a i32) -> &'b i32 + 'static,
+) -> RcBlock<dyn Fn(&'b i32) -> &'a i32 + 'static> {
+ struct Enc<'a, 'b>(PhantomData<&'a i32>, PhantomData<&'b i32>);
+ unsafe impl<'a, 'b> ManualBlockEncoding for Enc<'a, 'b> {
+ type Arguments = (&'a i32,);
+ type Return = &'b i32;
+ const ENCODING_CSTR: &'static CStr = c"^i816@?0^i8";
+ }
+ unsafe { RcBlock::with_encoding::<_, _, _, Enc<'a, 'b>>(f) }
+}
+
+fn args_entire_with_encoding<'a, 'b>(f: impl Fn(&'a i32) + 'b) -> RcBlock<dyn Fn(&'b i32) + 'a> {
+ struct Enc<'a>(PhantomData<&'a i32>);
+ unsafe impl<'a> ManualBlockEncoding for Enc<'a> {
+ type Arguments = (&'a i32,);
+ type Return = ();
+ const ENCODING_CSTR: &'static CStr = c"v16@?0^i8";
+ }
+ unsafe { RcBlock::with_encoding::<_, _, _, Enc<'a>>(f) }
+}
+
+fn return_entire_with_encoding<'a, 'b>(
+ f: impl Fn() -> &'a i32 + 'b,
+) -> RcBlock<dyn Fn() -> &'b i32 + 'a> {
+ struct Enc<'a>(PhantomData<&'a i32>);
+ unsafe impl<'a> ManualBlockEncoding for Enc<'a> {
+ type Arguments = ();
+ type Return = &'a i32;
+ const ENCODING_CSTR: &'static CStr = c"^i8@?0";
+ }
+ unsafe { RcBlock::with_encoding::<_, _, _, Enc<'a>>(f) }
+}
+
 fn main() {}

crates/test-ui/ui/lifetime_of_closure_tied_to_block.rs

@@ -1,4 +1,12 @@
-use block2::{RcBlock, StackBlock};
+use block2::{ManualBlockEncoding, RcBlock, StackBlock};
+use std::ffi::CStr;
+
+struct VoidToI32;
+unsafe impl ManualBlockEncoding for VoidToI32 {
+ type Arguments = ();
+ type Return = i32;
+ const ENCODING_CSTR: &'static CStr = c"i8@?0";
+}
 
 fn main() {
  let _ = {
@@ -11,6 +19,16 @@ fn main() {
  RcBlock::new(|| x + 2).clone()
  };
 
+ let _ = {
+ let x = 2;
+ unsafe { RcBlock::with_encoding::<_, _, _, VoidToI32>(|| x + 2) }
+ };
+
+ let _ = {
+ let x = 2;
+ unsafe { RcBlock::with_encoding::<_, _, _, VoidToI32>(|| x + 2).clone() }
+ };
+
  let _ = {
  let x = 2;
  StackBlock::new(|| x + 2)
@@ -20,4 +38,14 @@ fn main() {
  let x = 2;
  StackBlock::new(|| x + 2).copy()
  };
+
+ let _ = {
+ let x = 2;
+ unsafe { StackBlock::with_encoding::<VoidToI32>(|| x + 2) }
+ };
+
+ let _ = {
+ let x = 2;
+ unsafe { StackBlock::with_encoding::<VoidToI32>(|| x + 2).copy() }
+ };
 }

crates/test-ui/ui/stack_block_with_encoding_requires_clone.rs

@@ -0,0 +1,20 @@
+use block2::{ManualBlockEncoding, StackBlock};
+use std::ffi::CStr;
+
+struct Foo;
+
+fn main() {
+ struct FooBlockEncoding;
+ unsafe impl ManualBlockEncoding for FooBlockEncoding {
+ type Arguments = ();
+ type Return = ();
+ const ENCODING_CSTR: &'static CStr = c"v8@?0";
+ }
+
+ let foo = Foo;
+ let _ = unsafe {
+ StackBlock::with_encoding::<FooBlockEncoding>(move || {
+ let _ = &foo;
+ })
+ };
+}