Calling Objective-C function that takes block as an argument from Rust

build.rs

fn main() {
    println!("cargo:rustc-link-search={}/Library/Developer/Xcode/DerivedData/interop-cohciqqveewsnccwrnprodrghxtq/Build/Products/Debug", env!("HOME"));
    println!("cargo:rustc-link-lib=interop");
}

DeepThought.h

#import <Foundation/Foundation.h>

typedef void (^CompletionHandler)(int);

@interface DeepThought : NSObject
+ (void)calculateWithCompletionHandler:(CompletionHandler)completionHandler;
@end

DeepThought.m

#import "DeepThought.h"

#include <stdio.h>

@implementation DeepThought
+ (void)calculateWithCompletionHandler:(CompletionHandler)completionHandler {
  printf("objc: DeepThought::calculateWithCompletionHandler\n");

  if (completionHandler != NULL) {
    completionHandler(42);
  }
}
@end

example output.txt

objc: DeepThought::calculateWithCompletionHandler
Rust: answer = 42

main.rs

use objc::runtime::Class;
use objc::{class, msg_send, sel, sel_impl};
use std::ffi::c_int;
use std::mem::size_of;

#[repr(C)]
struct BlockDescriptor {
    reserved: usize,
    size: usize,
}

#[repr(C)]
struct BlockLiteral {
    isa: *const Class,
    flags: c_int,
    reserved: c_int,
    invoke: extern "C" fn(&Self, c_int),
    descriptor: Box<BlockDescriptor>,
}

extern "C" fn handler(_: &BlockLiteral, answer: c_int) {
    println!("Rust: answer = {answer}")
}

fn main() {
    let literal = BlockLiteral {
        isa: class!(NSObject),
        flags: 0,
        reserved: 0,
        invoke: handler,
        descriptor: Box::new(BlockDescriptor {
            reserved: 0,
            size: size_of::<BlockLiteral>(),
        }),
    };

    let _: () = unsafe {
        msg_send![
            class!(DeepThought),
            calculateWithCompletionHandler: &literal
        ]
    };
}

• Language Specification for Blocks
• Block Implementation Specification