Prepare block2 for future breaking changes

I plan to convert `Block<dyn Fn() + '_>` to `Block<'_, fn()>` to allow
for parameters with lifetimes (the Fn trait is invariant, while fn()
types have variance).

Doing this will require breaking changes in block2, so to prepare for
that, we introduce the helper `DynBlock`, which should allow converting
`DynBlock<dyn Fn() + '_>` to `Block<'_, fn()>` in the next version.

Author: madsmtm

crates/block2/src/lib.rs

@@ -449,3 +449,9 @@ pub type ConcreteBlock<A, R, Closure> = StackBlock<'static, A, R, Closure>;
 // just using `Box`, `Rc` or `Arc`, and since `__block` variables are
 // basically never exposed as part of a (public) function's API, we won't
 // implement such a thing yet.
+
+/// Helper type to allow changing [`Block`] in the future without affecting
+/// framework crates.
+///
+/// Tracked in [#572](https://github.com/madsmtm/objc2/issues/572).
+pub type DynBlock<F> = crate::Block<F>;

crates/header-translator/src/id.rs

@@ -433,7 +433,7 @@ impl ItemIdentifier {
                 match self.0.location.library_name() {
                     "__bitflags__" => write!(f, "bitflags::{}", self.0.name),
                     "__libc__" => write!(f, "libc::{}", self.0.name),
-                    "block" => write!(f, "block2::{}", self.0.name),
+                    "block" => write!(f, "block2::Dyn{}", self.0.name),
                     _ => write!(f, "{}", self.0.name),
                 }
             }

crates/header-translator/src/rust_type.rs

@@ -1988,7 +1988,7 @@ impl Ty {
                     arguments,
                     result_type,
                 } => {
-                    write!(f, "block2::Block<dyn Fn(")?;
+                    write!(f, "block2::DynBlock<dyn Fn(")?;
                     for arg in arguments {
                         write!(f, "{}, ", arg.plain())?;
                     }

framework-crates/objc2-foundation/src/data.rs

@@ -326,15 +326,15 @@ impl RetainedFromIterator<u8> for NSMutableData {
 unsafe fn with_vec<T: objc2::Message>(obj: objc2::rc::Allocated<T>, bytes: Vec<u8>) -> Retained<T> {
     use core::mem::ManuallyDrop;
 
-    use block2::{Block, RcBlock};
+    use block2::{DynBlock, RcBlock};
 
     let capacity = bytes.capacity();
 
     let dealloc = RcBlock::new(move |bytes: *mut c_void, len: usize| {
         // Recreate the Vec and let it drop
         let _ = unsafe { <Vec<u8>>::from_raw_parts(bytes.cast(), len, capacity) };
     });
-    let dealloc: &Block<dyn Fn(*mut c_void, usize) + 'static> = &dealloc;
+    let dealloc: &DynBlock<dyn Fn(*mut c_void, usize) + 'static> = &dealloc;
 
     let mut bytes = ManuallyDrop::new(bytes);
     // We intentionally extract the length before we access the