Remove extra parentheses from Block::call

By having multiple Block::call methods, with different signatures
depending on the block's generics.

Fixes #575.

Author: madsmtm

crates/block2/CHANGELOG.md

@@ -6,11 +6,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## Unreleased - YYYY-MM-DD
 
+### Changed
+* **BREAKING**: Removed extra parentheses when invoking `Block::call`.
+
 
 ## [0.6.2] - 2025-10-04
 [0.6.2]: https://github.com/madsmtm/objc2/compare/block2-0.6.1...block2-0.6.2
 
-## Fixed
+### Fixed
 * Fixed documentation on docs.rs.
 
 

crates/block2/src/block.rs

@@ -96,24 +96,9 @@ impl<F: ?Sized> Block<F> {
         unsafe { RcBlock::copy(ptr) }.unwrap_or_else(|| block_copy_fail())
     }
 
-    /// Call the block.
-    ///
-    /// The arguments must be passed as a tuple. The return is the output of
-    /// the block.
-    #[doc(alias = "invoke")]
-    pub fn call(&self, args: F::Args) -> F::Output
-    where
-        F: BlockFn,
-    {
+    pub(crate) fn invoke_ptr(&self) -> unsafe extern "C-unwind" fn() {
         // TODO: Is `invoke` actually ever null?
-        let invoke = self.header().invoke.unwrap_or_else(|| unreachable!());
-
-        let ptr: NonNull<Self> = NonNull::from(self);
-        let ptr: *mut Self = ptr.as_ptr();
-
-        // SAFETY: The closure is an `Fn`, and as such is safe to call from an
-        // immutable reference.
-        unsafe { F::__call_block(invoke, ptr, args) }
+        self.header().invoke.unwrap_or_else(|| unreachable!())
     }
 }
 
@@ -138,15 +123,15 @@ mod tests {
     #[test]
     fn test_rust_dyn_lifetime_semantics() {
         fn takes_static(block: &Block<dyn Fn() + 'static>) {
-            block.call(());
+            block.call();
         }
 
         fn takes_elided(block: &Block<dyn Fn() + '_>) {
-            block.call(());
+            block.call();
         }
 
         fn takes_unspecified(block: &Block<dyn Fn()>) {
-            block.call(());
+            block.call();
         }
 
         // Static lifetime
@@ -188,7 +173,7 @@ mod tests {
 
     #[allow(dead_code)]
     fn lending_block<'b>(block: &Block<dyn Fn() -> &'b i32 + 'b>) {
-        let _ = *block.call(());
+        let _ = *block.call();
     }
 
     #[allow(dead_code)]

crates/block2/src/global.rs

@@ -77,7 +77,7 @@ impl<F: ?Sized> GlobalBlock<F> {
     // TODO: Add some constructor for when `F: Copy`.
 }
 
-impl<F: ?Sized + BlockFn> Deref for GlobalBlock<F> {
+impl<F: ?Sized> Deref for GlobalBlock<F> {
     type Target = Block<F>;
 
     #[inline]
@@ -119,7 +119,7 @@ impl<F: ?Sized> fmt::Debug for GlobalBlock<F> {
 ///         42
 ///     };
 /// }
-/// assert_eq!(MY_BLOCK.call(()), 42);
+/// assert_eq!(MY_BLOCK.call(), 42);
 /// ```
 ///
 /// ```
@@ -129,7 +129,7 @@ impl<F: ?Sized> fmt::Debug for GlobalBlock<F> {
 ///         x + y
 ///     };
 /// }
-/// assert_eq!(ADDER_BLOCK.call((5, 7)), 12);
+/// assert_eq!(ADDER_BLOCK.call(5, 7), 12);
 /// ```
 ///
 /// The following does not compile because [`Box`] is not [`EncodeArgument`]:
@@ -144,15 +144,15 @@ impl<F: ?Sized> fmt::Debug for GlobalBlock<F> {
 /// This also doesn't work (yet), as blocks are overly restrictive about the
 /// lifetimes involved.
 ///
-/// ```compile_fail
+/// ```compile_error
 /// use block2::global_block;
 /// global_block! {
 ///     pub static BLOCK_WITH_LIFETIME = |x: &i32| -> i32 {
 ///         *x + 42
 ///     };
 /// }
 /// let x = 5;
-/// let res = BLOCK_WITH_LIFETIME.call((&x,));
+/// let res = BLOCK_WITH_LIFETIME.call(&x);
 /// assert_eq!(res, 47);
 /// ```
 ///
@@ -228,15 +228,15 @@ mod tests {
 
     #[test]
     fn test_noop_block() {
-        NOOP_BLOCK.call(());
+        NOOP_BLOCK.call();
     }
 
     #[test]
     fn test_defined_in_function() {
         global_block!(static MY_BLOCK = || -> i32 {
             42
         });
-        assert_eq!(MY_BLOCK.call(()), 42);
+        assert_eq!(MY_BLOCK.call(), 42);
     }
 
     #[cfg(target_vendor = "apple")]

crates/block2/src/lib.rs

@@ -36,7 +36,7 @@
 //! #
 //! # impl ExampleObject {
 //! #     fn someMethod(&self, block: &block2::Block<dyn Fn(i32, i32) -> i32>) {
-//! #         assert_eq!(block.call((5, 8)), 18);
+//! #         assert_eq!(block.call(5, 8), 18);
 //! #     }
 //! # }
 //! #
@@ -140,8 +140,8 @@
 //! let b = RcBlock::new(fnmut_to_fn(|| {
 //!     x += 1;
 //! }));
-//! b.call(());
-//! b.call(());
+//! b.call();
+//! b.call();
 //! drop(b);
 //! assert_eq!(x, 2);
 //! ```
@@ -182,7 +182,7 @@
 //! let b = RcBlock::new(fnonce_to_fn(move || {
 //!     drop(v);
 //! }));
-//! b.call(());
+//! b.call();
 //! ```
 //!
 //!
@@ -258,13 +258,10 @@
 //!
 //! #[no_mangle]
 //! extern "C" fn check_addition(block: &Block<dyn Fn(i32, i32) -> i32>) {
-//!     assert_eq!(block.call((5, 8)), 13);
+//!     assert_eq!(block.call(5, 8), 13);
 //! }
 //! ```
 //!
-//! Note the extra parentheses in the `call` method, since the arguments must
-//! be passed as a tuple.
-//!
 //!
 //! ## Specifying a runtime
 //!

crates/block2/src/rc_block.rs

@@ -177,7 +177,7 @@ impl<F: ?Sized> RcBlock<F> {
     /// let my_block = RcBlock::with_encoding::<_, _, _, MyBlockEncoding>(|_err: *mut NSError| {
     ///     42i32
     /// });
-    /// assert_eq!(my_block.call((core::ptr::null_mut(),)), 42);
+    /// assert_eq!(my_block.call(core::ptr::null_mut()), 42);
     /// ```
     #[inline]
     pub fn with_encoding<'f, A, R, Closure, E>(closure: Closure) -> Self
@@ -300,8 +300,8 @@ mod tests {
         }
 
         let add2 = get_adder(2);
-        assert_eq!(add2.call((5,)), 7);
-        assert_eq!(add2.call((-1,)), 1);
+        assert_eq!(add2.call(5), 7);
+        assert_eq!(add2.call(-1), 1);
     }
 
     #[test]
@@ -350,16 +350,16 @@ mod tests {
             match n {
                 0 => 0,
                 1 => 1,
-                n => captured_fibonacci.call((n - 1,)) + captured_fibonacci.call((n - 2,)),
+                n => captured_fibonacci.call(n - 1) + captured_fibonacci.call(n - 2),
             }
         };
 
         let block = block.get_or_init(|| RcBlock::new(fibonacci));
 
-        assert_eq!(block.call((0,)), 0);
-        assert_eq!(block.call((1,)), 1);
-        assert_eq!(block.call((6,)), 8);
-        assert_eq!(block.call((10,)), 55);
-        assert_eq!(block.call((19,)), 4181);
+        assert_eq!(block.call(0), 0);
+        assert_eq!(block.call(1), 1);
+        assert_eq!(block.call(6), 8);
+        assert_eq!(block.call(10), 55);
+        assert_eq!(block.call(19), 4181);
     }
 }

crates/block2/src/stack.rs

@@ -176,7 +176,7 @@ where
     /// use block2::StackBlock;
     /// #
     /// # extern "C" fn check_addition(block: &block2::Block<dyn Fn(i32, i32) -> i32>) {
-    /// #     assert_eq!(block.call((5, 8)), 13);
+    /// #     assert_eq!(block.call(5, 8), 13);
     /// # }
     ///
     /// let block = StackBlock::new(|a, b| a + b);
@@ -246,7 +246,7 @@ where
     /// let my_block = StackBlock::with_encoding::<MyBlockEncoding>(|_err: *mut NSError| {
     ///     42i32
     /// });
-    /// assert_eq!(my_block.call((core::ptr::null_mut(),)), 42);
+    /// assert_eq!(my_block.call(core::ptr::null_mut()), 42);
     /// ```
     #[inline]
     pub fn with_encoding<E>(closure: Closure) -> Self

crates/block2/src/traits.rs

@@ -32,14 +32,6 @@ pub unsafe trait BlockFn: private::Sealed<Self::Args, Self::Output> {
 
     /// The return type of the block.
     type Output: EncodeReturn;
-
-    /// Calls the given invoke function with the block and arguments.
-    #[doc(hidden)]
-    unsafe fn __call_block(
-        invoke: unsafe extern "C-unwind" fn(),
-        block: *mut Block<Self>,
-        args: Self::Args,
-    ) -> Self::Output;
 }
 
 /// Types that may be converted into a block.
@@ -66,7 +58,7 @@ where
 }
 
 macro_rules! impl_traits {
-    ($($a:ident: $t:ident),*) => (
+    ($num_args:literal; $($a:ident: $t:ident),*) => (
         impl<$($t: EncodeArgument,)* R: EncodeReturn, Closure> private::Sealed<($($t,)*), R> for Closure
         where
             Closure: ?Sized + Fn($($t),*) -> R,
@@ -76,20 +68,6 @@ macro_rules! impl_traits {
         unsafe impl<$($t: EncodeArgument,)* R: EncodeReturn> BlockFn for dyn Fn($($t),*) -> R + '_ {
             type Args = ($($t,)*);
             type Output = R;
-
-            #[inline]
-            unsafe fn __call_block(
-                invoke: unsafe extern "C-unwind" fn(),
-                block: *mut Block<Self>,
-                ($($a,)*): Self::Args,
-            ) -> Self::Output {
-                // Very similar to `MessageArguments::__invoke`
-                let invoke: unsafe extern "C-unwind" fn(*mut Block<Self> $(, $t)*) -> R = unsafe {
-                    mem::transmute(invoke)
-                };
-
-                unsafe { invoke(block $(, $a)*) }
-            }
         }
 
         unsafe impl<'f, $($t,)* R, Closure> IntoBlock<'f, ($($t,)*), R> for Closure
@@ -121,22 +99,41 @@ macro_rules! impl_traits {
                 }
             }
         }
+
+        impl<'f, $($t: EncodeArgument,)* R: EncodeReturn> Block<dyn Fn($($t),*) -> R + 'f> {
+            #[doc = concat!("Call the block with ", $num_args, " arguments.")]
+            ///
+            /// The return value is the output of the block.
+            #[doc(alias = "invoke")]
+            #[inline]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call(&self, $($a: $t),*) -> R {
+                // Very similar to `MessageArguments::__invoke`
+                let invoke: unsafe extern "C-unwind" fn(&Self $(, $t)*) -> R = unsafe {
+                    mem::transmute(self.invoke_ptr())
+                };
+
+                // SAFETY: The closure is an `Fn`, and as such is safe to call
+                // from an immutable reference.
+                unsafe { invoke(self $(, $a)*) }
+            }
+        }
     );
 }
 
-impl_traits!();
-impl_traits!(t0: T0);
-impl_traits!(t0: T0, t1: T1);
-impl_traits!(t0: T0, t1: T1, t2: T2);
-impl_traits!(t0: T0, t1: T1, t2: T2, t3: T3);
-impl_traits!(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4);
-impl_traits!(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5);
-impl_traits!(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6);
-impl_traits!(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7);
-impl_traits!(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8);
-impl_traits!(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9);
-impl_traits!(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10);
-impl_traits!(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11);
+impl_traits!(0;);
+impl_traits!(1; t0: T0);
+impl_traits!(2; t0: T0, t1: T1);
+impl_traits!(3; t0: T0, t1: T1, t2: T2);
+impl_traits!(4; t0: T0, t1: T1, t2: T2, t3: T3);
+impl_traits!(5; t0: T0, t1: T1, t2: T2, t3: T3, t4: T4);
+impl_traits!(6; t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5);
+impl_traits!(7; t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6);
+impl_traits!(8; t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7);
+impl_traits!(9; t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8);
+impl_traits!(10; t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9);
+impl_traits!(11; t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10);
+impl_traits!(12; t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11);
 
 /// Interim abstraction to manually provide block encodings for use at compile
 /// time with [`StackBlock::with_encoding`] and [`RcBlock::with_encoding`].

crates/test-ui/ui/block_wrong_number_args.rs

@@ -0,0 +1,21 @@
+use block2::{Block, RcBlock, StackBlock};
+
+fn takes_block0(block: &Block<dyn Fn()>) {
+    block.call(1);
+}
+
+fn takes_block1(block: &Block<dyn Fn(i32)>) {
+    block.call();
+    block.call(1, 2);
+}
+
+fn main() {
+    takes_block0(&StackBlock::new(|_x| {}));
+    takes_block0(&RcBlock::new(|_x| {}));
+
+    takes_block1(&StackBlock::new(|| {}));
+    takes_block1(&RcBlock::new(|| {}));
+
+    takes_block1(&StackBlock::new(|_x, _y| {}));
+    takes_block1(&RcBlock::new(|_x, _y| {}));
+}