swiftui-native 0.0.1

//! Rust functions Swift can call back into.

use core::ffi::c_void;

/// Context for a Swift `() -> T` closure implemented in Rust.
///
/// Swift treats a closure context as a reference-counted heap object. A
/// non-escaping closure never touches the count, but an escaping one — a
/// Button's action, say — is stored by the receiver, which retains it now and
/// releases it later. Handing Swift a plain `Box` means it eventually calls
/// `swift_release` on memory that is not a Swift object, and the process dies
/// with SIGBUS long after the call that caused it.
///
/// So the first two words mirror a Swift object header and carry the refcount
/// pattern of a known immortal object, which makes retain and release no-ops.
#[repr(C)]
pub struct ClosureCtx {
    isa: *const c_void,
    refcount: u64,
    body: unsafe extern "C" fn(*mut u8, *mut c_void),
    payload: *mut c_void,
}

/// The refcount word Swift uses for statically allocated, never-freed objects.
pub(crate) const IMMORTAL_REFCOUNT: u64 = 0x8000_0004_ffff_ffff;

/// Metadata of a known-immortal runtime object, reused as a plausible `isa`.
pub(crate) fn immortal_isa() -> *const c_void {
    // Resolved once: every `ClosureCtx` asks for this, and there are as many of
    // those as there are closures handed to SwiftUI.
    static ISA: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
    *ISA.get_or_init(|| {
        unsafe extern "C" {
            fn dlsym(handle: *mut c_void, symbol: *const core::ffi::c_char) -> *mut c_void;
        }
        let obj = unsafe { dlsym((-2isize) as *mut c_void, c"_swiftEmptyArrayStorage".as_ptr()) };
        if obj.is_null() {
            0
        } else {
            unsafe { *(obj as *const *const c_void) as usize }
        }
    }) as *const c_void
}

impl ClosureCtx {
    /// `body` receives `(out_ptr, payload)` and must initialise `*out_ptr` with
    /// a `+1` value (or ignore it, for a closure returning `Void`).
    pub fn new(
        body: unsafe extern "C" fn(*mut u8, *mut c_void),
        payload: *mut c_void,
    ) -> Self {
        Self { isa: immortal_isa(), refcount: IMMORTAL_REFCOUNT, body, payload }
    }
}

// Swift passes a closure's indirect (`@out`) result in x8 and the closure
// context in x20 — neither of which is reachable from a plain `extern "C"` fn
// signature. This thunk moves them into the C argument registers and tail-calls
// the dispatcher, so closure bodies can be ordinary Rust functions.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_swift_closure_thunk",
    "_rswift_swift_closure_thunk:",
    "mov x0, x8",
    "mov x1, x20",
    "b _rswift_swift_closure_dispatch",
);

unsafe extern "C" {
    /// Address to hand to Swift as the closure function pointer.
    #[link_name = "rswift_swift_closure_thunk"]
    pub fn swift_closure_thunk();
}

#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_swift_closure_dispatch(out: *mut u8, ctx: *mut ClosureCtx) {
    let ctx = unsafe { &*ctx };
    unsafe { (ctx.body)(out, ctx.payload) };
}

// A closure that takes one argument, such as `ForEach`'s `(Int) -> Content`.
// The argument arrives in x0, the indirect result in x8 and the context in x20,
// so all three are shuffled into the C argument registers. The moves are ordered
// so x0 is read before it is overwritten.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_index_closure_thunk",
    "_rswift_index_closure_thunk:",
    "mov x2, x20",
    "mov x1, x0",
    "mov x0, x8",
    "b _rswift_index_closure_dispatch",
);

unsafe extern "C" {
    /// Address to hand to Swift for a one-argument closure.
    #[link_name = "rswift_index_closure_thunk"]
    pub fn index_closure_thunk();
}

/// The context an `@isolated(any)` async closure carries.
///
/// Such a closure is not two words of function and context — the *isolation* it
/// runs on has to travel with it, and Swift puts it in the context: a heap box
/// of an object header followed by an `(any Actor)?`. All-zero is `nil`, which
/// means nonisolated, which is what a closure written `{ }` with no actor
/// context gets.
///
/// The refcount is the immortal pattern for the same reason [`ClosureCtx`] uses
/// it: SwiftUI stores the closure and releases it later, and this is not a real
/// Swift object to be freed.
#[repr(C)]
pub struct IsolatedContext {
    isa: *const c_void,
    refcount: u64,
    isolation: [u64; 2],
}

impl IsolatedContext {
    /// A context carrying no isolation.
    pub fn nonisolated() -> Self {
        Self { isa: immortal_isa(), refcount: IMMORTAL_REFCOUNT, isolation: [0; 2] }
    }
}

/// Context for a Swift `(Int) -> T` closure implemented in Rust.
#[repr(C)]
pub struct IndexClosureCtx {
    isa: *const c_void,
    refcount: u64,
    body: unsafe extern "C" fn(*mut u8, i64, *mut c_void),
    payload: *mut c_void,
}

impl IndexClosureCtx {
    pub fn new(
        body: unsafe extern "C" fn(*mut u8, i64, *mut c_void),
        payload: *mut c_void,
    ) -> Self {
        Self { isa: immortal_isa(), refcount: IMMORTAL_REFCOUNT, body, payload }
    }
}

#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_index_closure_dispatch(
    out: *mut u8,
    index: i64,
    ctx: *mut IndexClosureCtx,
) {
    let ctx = unsafe { &*ctx };
    unsafe { (ctx.body)(out, index, ctx.payload) };
}

// A closure that *consumes* one argument, such as a `Binding` setter's
// `(Value) -> ()`. The value arrives by pointer in x0 and the context in x20;
// only the context needs moving, so x0 passes straight through.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_value_closure_thunk",
    "_rswift_value_closure_thunk:",
    "mov x1, x20",
    "b _rswift_value_closure_dispatch",
);

unsafe extern "C" {
    /// Address to hand to Swift for a one-argument, no-result closure.
    #[link_name = "rswift_value_closure_thunk"]
    pub fn value_closure_thunk();
}

/// Context for a Swift `(Value) -> ()` closure implemented in Rust.
#[repr(C)]
pub struct ValueClosureCtx {
    isa: *const c_void,
    refcount: u64,
    body: unsafe extern "C" fn(*const u8, *mut c_void),
    payload: *mut c_void,
}

impl ValueClosureCtx {
    pub fn new(
        body: unsafe extern "C" fn(*const u8, *mut c_void),
        payload: *mut c_void,
    ) -> Self {
        Self { isa: immortal_isa(), refcount: IMMORTAL_REFCOUNT, body, payload }
    }
}

#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_value_closure_dispatch(value: *const u8, ctx: *mut ValueClosureCtx) {
    let ctx = unsafe { &*ctx };
    unsafe { (ctx.body)(value, ctx.payload) };
}

// A closure taking two arguments and returning nothing, such as `onChange`'s
// `(V, V) -> ()`. Both values arrive by pointer in x0 and x1 (V is generic, so
// they are indirect); only the context needs moving.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_pair_closure_thunk",
    "_rswift_pair_closure_thunk:",
    "mov x2, x20",
    "b _rswift_pair_closure_dispatch",
);

unsafe extern "C" {
    /// Address to hand to Swift for a two-argument, no-result closure.
    #[link_name = "rswift_pair_closure_thunk"]
    pub fn pair_closure_thunk();
}

/// Context for a Swift `(A, A) -> ()` closure implemented in Rust.
#[repr(C)]
pub struct PairClosureCtx {
    isa: *const c_void,
    refcount: u64,
    body: unsafe extern "C" fn(*const u8, *const u8, *mut c_void),
    payload: *mut c_void,
}

impl PairClosureCtx {
    pub fn new(
        body: unsafe extern "C" fn(*const u8, *const u8, *mut c_void),
        payload: *mut c_void,
    ) -> Self {
        Self { isa: immortal_isa(), refcount: IMMORTAL_REFCOUNT, body, payload }
    }
}

#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_pair_closure_dispatch(
    a: *const u8,
    b: *const u8,
    ctx: *mut PairClosureCtx,
) {
    let ctx = unsafe { &*ctx };
    unsafe { (ctx.body)(a, b, ctx.payload) };
}

// A closure taking one argument that may be up to three registers wide, such
// as `(HoverPhase) -> ()`. A frozen enum of seventeen bytes arrives *in* x0-x2;
// a resilient one of a single byte arrives as a pointer in x0. One thunk covers
// both, because forwarding registers the callee ignores costs nothing — while
// the narrow `value_closure_thunk` cannot, since it overwrites x1 with the
// context.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_wide_closure_thunk",
    "_rswift_wide_closure_thunk:",
    "mov x3, x20",
    "b _rswift_wide_closure_dispatch",
);

unsafe extern "C" {
    /// Address to hand to Swift for a one-argument, no-result closure whose
    /// argument may not fit in a single register.
    #[link_name = "rswift_wide_closure_thunk"]
    pub fn wide_closure_thunk();
}

/// Context for a Swift `(V) -> ()` closure where `V` may span three registers.
#[repr(C)]
pub struct WideClosureCtx {
    isa: *const c_void,
    refcount: u64,
    body: unsafe extern "C" fn(u64, u64, u64, *mut c_void),
    payload: *mut c_void,
}

impl WideClosureCtx {
    pub fn new(
        body: unsafe extern "C" fn(u64, u64, u64, *mut c_void),
        payload: *mut c_void,
    ) -> Self {
        Self { isa: immortal_isa(), refcount: IMMORTAL_REFCOUNT, body, payload }
    }
}

#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_wide_closure_dispatch(
    a0: u64,
    a1: u64,
    a2: u64,
    ctx: *mut WideClosureCtx,
) {
    let ctx = unsafe { &*ctx };
    unsafe { (ctx.body)(a0, a1, a2, ctx.payload) };
}

/// Which case of an enum a value holds.
///
/// The inverse of [`super::inject_enum_tag`], and the first of the three enum value
/// witnesses rather than the third.
///
/// # Safety
/// `value` must point at a valid value of the enum `metadata` describes.
pub unsafe fn read_enum_tag(value: *const u8, metadata: *const c_void) -> u32 {
    unsafe {
        const ENUM_WITNESSES: usize = 8 * 8 + 8 + 8 + 4 + 4;
        let vwt = *(metadata.cast::<*const u8>().offset(-1));
        let get = *(vwt.add(ENUM_WITNESSES) as *const *const c_void);
        type Get = unsafe extern "C" fn(*const c_void, *const c_void) -> u32;
        let f: Get = core::mem::transmute(get);
        f(value as *const c_void, metadata)
    }
}

/// Resolve a Swift type from its mangled name string.
///
/// Results are cached. Demangling walks the name, instantiates generic metadata
/// and consults the runtime's caches, which costs on the order of a microsecond
/// — and the same handful of names are resolved on *every* view construction, so
/// uncached it dominates the cost of building a tree.
/// Resolve a *fixed* mangled name, caching in one word at the call site.
///
/// This is what the Swift compiler emits for the same job: a global per site,
/// a relaxed load, a null check, and the slow path taken once. The shared map
/// behind [`resolve_type_by_mangled_name`] has to hash the whole mangled string
/// under a mutex — 266 ns against the 416 the runtime call costs, so it earns
/// its keep, but a site that always asks for the same type should not be paying
/// either.
///
/// Only for names that cannot vary between calls. A site whose name is computed
/// would cache the first answer and hand it back for every later one.
#[macro_export]
macro_rules! type_by_name {
    ($bytes:expr) => {{
        static SITE: ::std::sync::atomic::AtomicUsize = ::std::sync::atomic::AtomicUsize::new(0);
        let hit = SITE.load(::std::sync::atomic::Ordering::Relaxed);
        if hit != 0 {
            hit as *const ::core::ffi::c_void
        } else {
            let m = $crate::abi::resolve_type_by_mangled_name($bytes);
            SITE.store(m as usize, ::std::sync::atomic::Ordering::Relaxed);
            m
        }
    }};
}

/// # Safety
/// `mangled` must be a well-formed mangled type name without its `$s` prefix.
/// The runtime parses it, and a malformed one is not merely a null answer.
pub unsafe fn resolve_type_by_mangled_name(mangled: &[u8]) -> *const c_void {
    use std::collections::HashMap;
    use std::sync::{Mutex, OnceLock};
    static CACHE: OnceLock<Mutex<HashMap<Vec<u8>, usize>>> = OnceLock::new();
    let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new()));

    if let Ok(map) = cache.lock() {
        if let Some(&hit) = map.get(mangled) {
            return hit as *const c_void;
        }
    }
    let resolved = unsafe {
        swift_runtime_sys::RuntimeRaw::swift_getTypeByMangledNameInEnvironment(
            mangled.as_ptr(),
            mangled.len(),
            core::ptr::null(),
            0,
        )
    };
    if !resolved.is_null() {
        if let Ok(mut map) = cache.lock() {
            map.insert(mangled.to_vec(), resolved as usize);
        }
    }
    resolved
}

// A closure returning a single word — an `Array`, a class reference, a `Bool`.
// Swift returns a loadable one-word result in x0, not through x8, so this
// thunk moves only the context and lets the return value pass straight back.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_word_closure_thunk",
    "_rswift_word_closure_thunk:",
    "mov x1, x0",
    "mov x0, x20",
    "b _rswift_word_closure_dispatch",
);

unsafe extern "C" {
    /// Address to hand to Swift for a closure returning one word.
    #[link_name = "rswift_word_closure_thunk"]
    pub fn word_closure_thunk();
}

/// Context for a Swift closure returning a single word.
///
/// `body` also receives whatever was in x0 on entry, so one context serves
/// both `() -> T` and `(U) -> T` where each of `T` and `U` is one word.
#[repr(C)]
pub struct WordClosureCtx {
    isa: *const c_void,
    refcount: u64,
    body: unsafe extern "C" fn(*mut c_void, u64) -> u64,
    payload: *mut c_void,
}

impl WordClosureCtx {
    pub fn new(
        body: unsafe extern "C" fn(*mut c_void, u64) -> u64,
        payload: *mut c_void,
    ) -> Self {
        Self { isa: immortal_isa(), refcount: IMMORTAL_REFCOUNT, body, payload }
    }
}

#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_word_closure_dispatch(ctx: *mut WordClosureCtx, arg: u64) -> u64 {
    let ctx = unsafe { &*ctx };
    unsafe { (ctx.body)(ctx.payload, arg) }
}

// A closure returning a `Double` — an alignment guide, a length. Swift returns
// it in d0, which no integer-returning thunk can carry back.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_float_closure_thunk",
    "_rswift_float_closure_thunk:",
    "mov x1, x20",
    "b _rswift_float_closure_dispatch",
);

unsafe extern "C" {
    /// Address to hand to Swift for a closure returning a `Double`.
    #[link_name = "rswift_float_closure_thunk"]
    pub fn float_closure_thunk();
}

/// Context for a Swift closure returning a `Double`.
#[repr(C)]
pub struct FloatClosureCtx {
    isa: *const c_void,
    refcount: u64,
    body: unsafe extern "C" fn(u64, *mut c_void) -> f64,
    payload: *mut c_void,
}

impl FloatClosureCtx {
    pub fn new(
        body: unsafe extern "C" fn(u64, *mut c_void) -> f64,
        payload: *mut c_void,
    ) -> Self {
        Self { isa: immortal_isa(), refcount: IMMORTAL_REFCOUNT, body, payload }
    }
}

#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_float_closure_dispatch(arg: u64, ctx: *mut FloatClosureCtx) -> f64 {
    let ctx = unsafe { &*ctx };
    unsafe { (ctx.body)(arg, ctx.payload) }
}

// A closure returning *two* words. `draggable(_:)` takes an autoclosure
// `() -> T`, and the smallest useful `T` is `String` — sixteen bytes, which is
// loadable, so Swift returns it in x0/x1 rather than through x8. The
// single-word thunk next door cannot carry the second half back.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_pair_return_closure_thunk",
    "_rswift_pair_return_closure_thunk:",
    "mov x0, x20",
    "b _rswift_pair_return_closure_dispatch",
);

unsafe extern "C" {
    /// Address to hand to Swift for a `() -> (word, word)` closure.
    #[link_name = "rswift_pair_return_closure_thunk"]
    pub fn pair_return_closure_thunk();
}

/// Two words, laid out so the ABI returns them in x0 and x1.
#[repr(C)]
pub struct Pair(pub u64, pub u64);

/// Context for a Swift closure returning two words.
#[repr(C)]
pub struct PairReturnClosureCtx {
    isa: *const c_void,
    refcount: u64,
    body: unsafe extern "C" fn(*mut c_void) -> Pair,
    payload: *mut c_void,
}

impl PairReturnClosureCtx {
    pub fn new(body: unsafe extern "C" fn(*mut c_void) -> Pair, payload: *mut c_void) -> Self {
        Self { isa: immortal_isa(), refcount: IMMORTAL_REFCOUNT, body, payload }
    }
}

#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_pair_return_closure_dispatch(ctx: *mut PairReturnClosureCtx) -> Pair {
    let ctx = unsafe { &*ctx };
    unsafe { (ctx.body)(ctx.payload) }
}