swiftui_native/views/

customstyle.rs

//! The protocols SwiftUI asks a *client* to conform to, conformed to in Rust.
//!
//! Five of them live here — `ButtonStyle`, `LabelStyle`, `ViewModifier`,
//! `Transition` and `CustomAnimation` — and they are together because they are
//! one idea: a protocol whose whole purpose is that the *caller* implements it,
//! a conformance synthesised at run time, and the callback landing in a Rust
//! closure. `Layout` is the same idea in
//! [`crate::views::customlayout`]; `Shape` in [`crate::views::customshape`],
//! where it needed a chapter of its own.
//!
//! What they have in common beyond that is the witness convention: every one of
//! these callbacks takes its argument in x0, `self` in x20 and its result
//! through x8, which no `extern "C"` signature can express — so each goes
//! through a small assembly thunk. Declaring the result as the first parameter
//! instead puts it in x0 and the argument in x1, and SwiftUI writes a view into
//! whatever x0 happened to hold. That is what the thunks are for, and it is
//! worth knowing that it was found by doing it.
//!
//! ```no_run
//! # use swiftui_native::{prelude::*, views::{self, ButtonConfiguration}};
//! // Every button below this one, drawn by Rust — including its reaction to
//! // being pressed, which is why a style is a callback and not a description.
//! let style = views::button_style_fn(|c: ButtonConfiguration<'_>| {
//!     let a = if c.is_pressed() { 0.4 } else { 1.0 };
//!     View::new(c.label()).padding(8.0).background(0.2, 0.6, 1.0, a).corner_radius(6.0).into_handle()
//! });
//! let v = View::new(views::button("Press", || {})).custom_button_style(&style);
//! ```
//!
//! # `Body` is `AnyView`
//!
//! A Swift style declares `associatedtype Body` and returns `some View`, so
//! each style has its own body type. A Rust closure cannot: what it returns is
//! decided at run time, not by its signature. So the associated type is
//! `AnyView` and the body is erased into one — the same trade the rest of this
//! crate makes wherever a closure's result crosses into SwiftUI.

use super::{wrap_owned, ViewHandle};
use crate::abi;
use crate::conformance::{synthesize, Conformance, Protocol, Witness};
use crate::resolve;
use core::ffi::c_void;
use std::sync::{Mutex, OnceLock};

/// What a button style is told about the button it is drawing.
pub struct ButtonConfiguration<'a> {
    raw: *mut c_void,
    marker: core::marker::PhantomData<&'a ()>,
}

impl ButtonConfiguration<'_> {
    /// The button's own label, to place inside whatever the style draws.
    pub fn label(&self) -> ViewHandle {
        unsafe { config_view(resolve::button_config_label(), resolve::button_config_label_ma(), self.raw) }
    }

    /// Whether the button is being pressed right now.
    ///
    /// The reason a style is a callback rather than a static description:
    /// SwiftUI re-runs it as this changes.
    pub fn is_pressed(&self) -> bool {
        unsafe { config_flag(resolve::button_config_pressed(), self.raw) }
    }
}

/// What a label style is told.
pub struct LabelConfiguration<'a> {
    raw: *mut c_void,
    marker: core::marker::PhantomData<&'a ()>,
}

impl LabelConfiguration<'_> {
    /// The label's text.
    pub fn title(&self) -> ViewHandle {
        unsafe { config_view(resolve::label_config_title(), resolve::label_config_title_ma(), self.raw) }
    }

    /// The label's icon.
    pub fn icon(&self) -> ViewHandle {
        unsafe { config_view(resolve::label_config_icon(), resolve::label_config_icon_ma(), self.raw) }
    }
}

/// Read a view-valued property off a style configuration.
///
/// The property's type — `ButtonStyleConfiguration.Label` and friends — is an
/// opaque wrapper SwiftUI hands back; its `View` witness is looked up rather
/// than named, because the `…Wl` accessor for it is emitted into the client
/// and is not something a binding can call.
///
/// # Safety
/// `getter` must be a property getter on the configuration `raw` points at,
/// and `ma` that property's metadata accessor.
unsafe fn config_view(
    getter: *const c_void,
    ma: *const c_void,
    raw: *mut c_void,
) -> ViewHandle {
    unsafe {
        let meta = abi::metadata0(ma);
        assert!(!meta.is_null(), "style configuration property metadata");
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "{} !: View", crate::diag::type_name(meta));
        let mut out = vec![0u8; abi::type_bytes(meta)];
        core::arch::asm!("blr {f}", f = in(reg) getter,
            in("x8") out.as_mut_ptr(),
            in("x20") raw,
            lateout("x0") _, lateout("x1") _, lateout("x2") _, lateout("x3") _,
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x21") _, clobber_abi("C"),
        );
        wrap_owned(out, meta, wt)
    }
}

/// Read a `Bool` property off a style configuration.
///
/// # Safety
/// As [`config_view`].
unsafe fn config_flag(getter: *const c_void, raw: *mut c_void) -> bool {
    unsafe {
        let out: u64;
        core::arch::asm!("blr {f}", f = in(reg) getter,
            in("x20") raw,
            lateout("x0") out,
            lateout("x1") _, lateout("x2") _, lateout("x3") _, lateout("x4") _,
            lateout("x5") _, lateout("x6") _, lateout("x7") _, lateout("x8") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x21") _, clobber_abi("C"),
        );
        out & 1 != 0
    }
}

// ── The styles, kept on the Rust side ────────────────────────────────────

/// How a button draws.
pub trait ButtonStyling: Send + Sync + 'static {
    /// Draw one button. `configuration` carries its label and whether it is
    /// pressed.
    fn make_body(&self, configuration: ButtonConfiguration<'_>) -> ViewHandle;
}

impl<F> ButtonStyling for F
where
    F: Fn(ButtonConfiguration<'_>) -> ViewHandle + Send + Sync + 'static,
{
    fn make_body(&self, configuration: ButtonConfiguration<'_>) -> ViewHandle {
        self(configuration)
    }
}

/// How a label draws.
pub trait LabelStyling: Send + Sync + 'static {
    /// Draw one label. `configuration` carries its title and its icon.
    fn make_body(&self, configuration: LabelConfiguration<'_>) -> ViewHandle;
}

impl<F> LabelStyling for F
where
    F: Fn(LabelConfiguration<'_>) -> ViewHandle + Send + Sync + 'static,
{
    fn make_body(&self, configuration: LabelConfiguration<'_>) -> ViewHandle {
        self(configuration)
    }
}

/// A registered style, as the one word SwiftUI stores.
///
/// The same arrangement as a custom layout: SwiftUI copies a style value
/// freely, so what it holds is an index into a Rust-side table rather than the
/// closure, which is not something it could copy.
pub struct CustomButtonStyle {
    index: i64,
}

/// As [`CustomButtonStyle`], for labels.
pub struct CustomLabelStyle {
    index: i64,
}

fn button_registry() -> &'static Mutex<Vec<&'static dyn ButtonStyling>> {
    static R: OnceLock<Mutex<Vec<&'static dyn ButtonStyling>>> = OnceLock::new();
    R.get_or_init(|| Mutex::new(Vec::new()))
}

fn label_registry() -> &'static Mutex<Vec<&'static dyn LabelStyling>> {
    static R: OnceLock<Mutex<Vec<&'static dyn LabelStyling>>> = OnceLock::new();
    R.get_or_init(|| Mutex::new(Vec::new()))
}

/// Register a button style. A closure taking a [`ButtonConfiguration`] is one.
pub fn button_style_fn<S: ButtonStyling>(style: S) -> CustomButtonStyle {
    let leaked: &'static dyn ButtonStyling = Box::leak(Box::new(style));
    let mut r = button_registry().lock().expect("button style registry");
    r.push(leaked);
    CustomButtonStyle { index: r.len() as i64 - 1 }
}

/// Register a label style.
pub fn label_style_fn<S: LabelStyling>(style: S) -> CustomLabelStyle {
    let leaked: &'static dyn LabelStyling = Box::leak(Box::new(style));
    let mut r = label_registry().lock().expect("label style registry");
    r.push(leaked);
    CustomLabelStyle { index: r.len() as i64 - 1 }
}

// ── The witnesses SwiftUI calls ──────────────────────────────────────────

// `makeBody(configuration:)` receives its indirect result in **x8**, the
// configuration in x0 and `self` in x20 — the witness-method convention. An
// `extern "C"` function cannot name x8, so a thunk shuffles the three into the
// first three argument registers before tail-calling. Declaring the result as
// the first parameter instead put it in x0 and the configuration in x1, and
// SwiftUI wrote a view into whatever x0 happened to hold.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_button_style_thunk",
    "_rswift_button_style_thunk:",
    "mov x2, x20",
    "mov x1, x0",
    "mov x0, x8",
    "b _rswift_button_make_body",
    ".p2align 2",
    ".globl _rswift_label_style_thunk",
    "_rswift_label_style_thunk:",
    "mov x2, x20",
    "mov x1, x0",
    "mov x0, x8",
    "b _rswift_label_make_body",
);

unsafe extern "C" {
    #[link_name = "rswift_button_style_thunk"]
    fn button_style_thunk();
    #[link_name = "rswift_label_style_thunk"]
    fn label_style_thunk();
}

/// `makeBody(configuration:) -> Body`, with `Body == AnyView`.
///
/// # Safety
/// Reached through `rswift_button_style_thunk`, which supplies the three
/// arguments in order.
#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_button_make_body(
    out: *mut u8,
    configuration: *mut c_void,
    this: *const u8,
) {
    let index = unsafe { *(this as *const i64) } as usize;
    let style = {
        let r = button_registry().lock().expect("button style registry");
        r.get(index).copied().expect("button style index out of range")
    };
    let body = style.make_body(ButtonConfiguration {
        raw: configuration,
        marker: core::marker::PhantomData,
    });
    // `Body` is `AnyView`, so the result is one erased word.
    unsafe { *(out as *mut u64) = body.into_anyview_word() };
}

/// As [`rswift_button_make_body`], for a label style.
///
/// # Safety
/// As above.
#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_label_make_body(
    out: *mut u8,
    configuration: *mut c_void,
    this: *const u8,
) {
    let index = unsafe { *(this as *const i64) } as usize;
    let style = {
        let r = label_registry().lock().expect("label style registry");
        r.get(index).copied().expect("label style index out of range")
    };
    let body = style.make_body(LabelConfiguration {
        raw: configuration,
        marker: core::marker::PhantomData,
    });
    unsafe { *(out as *mut u64) = body.into_anyview_word() };
}

/// The carrier type a style value *is*: one `Int`, the style's index.
fn button_carrier() -> (*const c_void, *const c_void) {
    static C: OnceLock<(usize, usize)> = OnceLock::new();
    let (d, m) = *C.get_or_init(|| unsafe {
        let (d, m) =
            crate::state::emit_int_carrier(b"RustButtonStyle\0", b"6rswift15RustButtonStyleV\0");
        (d as usize, m as usize)
    });
    (d as *const c_void, m as *const c_void)
}

/// As [`button_carrier`], for label styles. A separate type, because a
/// conformance is registered per `(type, protocol)` and one type conforming to
/// both would make `buttonStyle(_:)` accept a label style.
fn label_carrier() -> (*const c_void, *const c_void) {
    static C: OnceLock<(usize, usize)> = OnceLock::new();
    let (d, m) = *C.get_or_init(|| unsafe {
        let (d, m) =
            crate::state::emit_int_carrier(b"RustLabelStyle\0", b"6rswift14RustLabelStyleV\0");
        (d as usize, m as usize)
    });
    (d as *const c_void, m as *const c_void)
}

/// A style conformance: the associated `Body`, its `View` witness, `makeBody`.
///
/// The three requirements are in that order and none has a default, which is
/// why both protocols read the same here.
///
/// # Safety
/// `make_body` must have the witness-method signature above.
unsafe fn style_conformance(
    protocol: &'static core::ffi::CStr,
    descriptor: *const c_void,
    make_body: *const c_void,
) -> Conformance {
    unsafe {
        let protocol = Protocol::from_symbol(protocol);
        assert_eq!(protocol.requirement_count(), 3, "the style protocol changed shape");
        synthesize(
            &protocol,
            descriptor,
            &[
                Witness::Metadata(resolve::anyview_wt()),
                Witness::Metadata(resolve::anyview_meta()),
                Witness::Function(make_body),
            ],
        )
    }
}

fn button_conformance() -> &'static Conformance {
    static C: OnceLock<Conformance> = OnceLock::new();
    C.get_or_init(|| unsafe {
        style_conformance(
            c"$s7SwiftUI11ButtonStyleMp",
            button_carrier().0,
            button_style_thunk as *const c_void,
        )
    })
}

fn label_conformance() -> &'static Conformance {
    static C: OnceLock<Conformance> = OnceLock::new();
    C.get_or_init(|| unsafe {
        style_conformance(
            c"$s7SwiftUI10LabelStyleMp",
            label_carrier().0,
            label_style_thunk as *const c_void,
        )
    })
}

/// Apply a style, whichever of the two it is.
///
/// `buttonStyle(_:)` and `labelStyle(_:)` take the same arguments in the same
/// registers and differ only in the protocol they constrain to, so one body
/// serves both.
///
/// # Safety
/// `f` and `oret` must be a matching modifier and opaque-result descriptor,
/// and `conformance` a conformance to that modifier's protocol.
unsafe fn apply_style(
    view: &ViewHandle,
    index: i64,
    conformance: &Conformance,
    carrier: (*const c_void, *const c_void),
    f: *const c_void,
    oret: *const c_void,
) -> ViewHandle {
    unsafe {
        let meta = carrier.1;
        let mut value = vec![0u8; abi::type_bytes(meta)];
        value[..8].copy_from_slice(&index.to_le_bytes());

        let subst = [view.meta, meta, view.wt, conformance.witness_table()];
        let (out_meta, out_wt, size) = super::opaque_result_type(oret, &subst);
        let mut result = vec![0u8; size];
        let this = view.value_ptr();
        // `(sret, @in style, Self.Type, S.Type, Self: View WT,
        //   S: ButtonStyle WT, swiftself self)`
        core::arch::asm!("blr {f}", f = in(reg) f,
            in("x0") value.as_mut_ptr(),
            in("x1") view.meta,
            in("x2") meta,
            in("x3") view.wt,
            in("x4") conformance.witness_table(),
            in("x8") result.as_mut_ptr(),
            in("x20") this,
            lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x21") _, clobber_abi("C"),
        );
        wrap_owned(result, out_meta, out_wt)
    }
}

/// `.buttonStyle(_:)` with a style written in Rust.
pub fn custom_button_style(view: &ViewHandle, style: &CustomButtonStyle) -> ViewHandle {
    unsafe {
        apply_style(
            view,
            style.index,
            button_conformance(),
            button_carrier(),
            resolve::button_style_custom_fn(),
            resolve::button_style_custom_oret(),
        )
    }
}

/// `.labelStyle(_:)` with a style written in Rust.
pub fn custom_label_style(view: &ViewHandle, style: &CustomLabelStyle) -> ViewHandle {
    unsafe {
        apply_style(
            view,
            style.index,
            label_conformance(),
            label_carrier(),
            resolve::label_style_fn(),
            resolve::label_style_oret(),
        )
    }
}

// ── A `ViewModifier` written in Rust ──
//
// The third protocol in this file, and the same shape as the first two: SwiftUI
// asks a *client* to conform, the conformance is synthesised, and the callback
// lands in a Rust closure. What makes it worth having beyond
// [`custom_button_style`] is reach — a `ViewModifier` applies to *any* view, not
// only to buttons, so it is how a Rust caller packages "my card style" once and
// uses it everywhere.
//
// `body(content:)`'s argument is a `_ViewModifier_Content<Self>`: SwiftUI's stand-in
// for "whatever this modifier was applied to". It is a real `View`, so the
// closure gets it as an ordinary [`ViewHandle`] and can wrap it.

/// How a view modifier draws.
pub trait Modifying: Send + Sync + 'static {
    /// Draw one modified view. `content` is whatever the modifier was applied to.
    fn body(&self, content: ViewHandle) -> ViewHandle;
}

impl<F> Modifying for F
where
    F: Fn(ViewHandle) -> ViewHandle + Send + Sync + 'static,
{
    fn body(&self, content: ViewHandle) -> ViewHandle {
        self(content)
    }
}

/// A registered modifier, as the one word SwiftUI stores.
pub struct CustomModifier {
    index: i64,
}

fn modifier_registry() -> &'static Mutex<Vec<&'static dyn Modifying>> {
    static R: OnceLock<Mutex<Vec<&'static dyn Modifying>>> = OnceLock::new();
    R.get_or_init(|| Mutex::new(Vec::new()))
}

/// Register a view modifier. A closure taking the content is one.
pub fn modifier_fn<M: Modifying>(modifier: M) -> CustomModifier {
    let leaked: &'static dyn Modifying = Box::leak(Box::new(modifier));
    let mut r = modifier_registry().lock().expect("modifier registry");
    r.push(leaked);
    CustomModifier { index: r.len() as i64 - 1 }
}

// `body(content:)` has exactly `makeBody(configuration:)`'s convention — result
// in x8, argument in x0, `self` in x20 — so the same shuffle serves it.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_view_modifier_thunk",
    "_rswift_view_modifier_thunk:",
    "mov x2, x20",
    "mov x1, x0",
    "mov x0, x8",
    "b _rswift_view_modifier_body",
);

unsafe extern "C" {
    #[link_name = "rswift_view_modifier_thunk"]
    fn view_modifier_thunk();
}

/// The content's metadata and `View` conformance, per registered modifier.
///
/// `_ViewModifier_Content<Modifier>` is generic over the modifier and
/// constrained to `ViewModifier`, so building its metadata needs the carrier's
/// metadata *and* the synthesised conformance — which is why this is looked up
/// once the conformance exists rather than at first use.
static CONTENT_META: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
static CONTENT_WT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);

/// `body(content:) -> Body`, with `Body == AnyView`.
///
/// # Safety
/// Reached through `rswift_view_modifier_thunk`, which supplies the three
/// arguments in order.
#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_view_modifier_body(
    out: *mut u8,
    content: *mut c_void,
    this: *const u8,
) {
    use std::sync::atomic::Ordering::Acquire;
    let index = unsafe { *(this as *const i64) } as usize;
    let modifier = {
        let r = modifier_registry().lock().expect("modifier registry");
        r.get(index).copied().expect("modifier index out of range")
    };
    let meta = CONTENT_META.load(Acquire) as *const c_void;
    let wt = CONTENT_WT.load(Acquire) as *const c_void;
    // The content is borrowed for the call, so it is copied into a handle SwiftUI
    // does not own — the closure may keep it inside whatever it builds.
    let handle = unsafe {
        let mut bytes = vec![0u8; abi::type_bytes(meta)];
        let vwt = &*swift_runtime_sys::SwiftABI::get_value_witness_table(meta);
        (vwt.initialize_with_copy)(bytes.as_mut_ptr() as *mut c_void, content, meta);
        wrap_owned(bytes, meta, wt)
    };
    let body = modifier.body(handle);
    unsafe { *(out as *mut u64) = body.into_anyview_word() };
}

/// The carrier type a modifier value *is*: one `Int`, its index.
fn modifier_carrier() -> (*const c_void, *const c_void) {
    static C: OnceLock<(usize, usize)> = OnceLock::new();
    let (d, m) = *C.get_or_init(|| unsafe {
        let (d, m) =
            crate::state::emit_int_carrier(b"RustModifier\0", b"6rswift12RustModifierV\0");
        (d as usize, m as usize)
    });
    (d as *const c_void, m as *const c_void)
}

fn modifier_conformance() -> &'static Conformance {
    static C: OnceLock<Conformance> = OnceLock::new();
    C.get_or_init(|| unsafe {
        let protocol = Protocol::from_symbol(c"$s7SwiftUI12ViewModifierMp");
        assert_eq!(
            protocol.requirement_count(),
            6,
            "ViewModifier changed shape — it used to be Body, its conformance, \
             three defaulted `_make…` entries and `body(content:)`",
        );
        let conformance = synthesize(
            &protocol,
            modifier_carrier().0,
            &[
                Witness::Metadata(resolve::anyview_wt()),
                Witness::Metadata(resolve::anyview_meta()),
                Witness::Default,
                Witness::Default,
                Witness::Default,
                Witness::Function(view_modifier_thunk as *const c_void),
            ],
        );

        // Now that the conformance exists, `_ViewModifier_Content<RustModifier>`
        // can be built — it is constrained to `ViewModifier`, so it needs both.
        use std::sync::atomic::Ordering::Release;
        let meta = abi::generic_metadata2(
            resolve::vm_content_ma(),
            modifier_carrier().1,
            conformance.witness_table(),
        );
        assert!(!meta.is_null(), "_ViewModifier_Content<RustModifier> metadata");
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "{} !: View", crate::diag::type_name(meta));
        CONTENT_META.store(meta as usize, Release);
        CONTENT_WT.store(wt as usize, Release);

        conformance
    })
}

/// `.modifier(_:)` with a modifier written in Rust.
///
/// The result is `ModifiedContent<Self, RustModifier>` — a concrete type, not an
/// opaque one, because `modifier<T>(_:)` says so. `T` is unconstrained there, so
/// no witness table is passed at the call: SwiftUI finds the conformance by
/// lookup when it renders, which is exactly why registering it matters.
pub fn custom_modifier(view: &ViewHandle, modifier: &CustomModifier) -> ViewHandle {
    unsafe {
        let conformance = modifier_conformance();
        let carrier = modifier_carrier().1;
        let mut value = vec![0u8; abi::type_bytes(carrier)];
        value[..8].copy_from_slice(&modifier.index.to_le_bytes());

        let meta = abi::generic_metadata2(resolve::modified_content_ma(), view.meta, carrier);
        assert!(!meta.is_null(), "ModifiedContent metadata");
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "{} !: View", crate::diag::type_name(meta));

        let mut result = vec![0u8; abi::type_bytes(meta)];
        let this = view.value_ptr();
        // x0 = @in the modifier, x1 = Self.Type, x2 = T.Type,
        // x3 = Self: View WT, x8 = @out, x20 = self.
        core::arch::asm!("blr {f}", f = in(reg) resolve::apply_view_modifier_fn(),
            in("x0") value.as_mut_ptr(),
            in("x1") view.meta,
            in("x2") carrier,
            in("x3") view.wt,
            in("x8") result.as_mut_ptr(),
            in("x20") this,
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x21") _, clobber_abi("C"),
        );
        let _ = conformance;
        wrap_owned(result, meta, wt)
    }
}

// ── A `Transition` written in Rust ──
//
// The fourth of these, and the one with an extra argument: `body(content:phase:)`
// is told *where in the transition* it is, and returns a different view for each
// phase. That is what a transition is — the same closure answering "appearing",
// "settled" and "leaving" differently.
//
// `.transition(_:)` for a custom `Transition` is `@_alwaysEmitIntoClient` and
// exports nothing. Its body wraps the value in an `AnyTransition` and calls the
// `AnyTransition` overload, so that is the route here.

/// Where in a transition `body` is being asked to draw.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TransitionPhase {
    /// About to appear.
    WillAppear,
    /// Fully present — the phase in which a transition must change nothing.
    Identity,
    /// Gone.
    DidDisappear,
}

impl TransitionPhase {
    /// Swift's own name for the case, for looking its tag up.
    fn case(self) -> &'static str {
        match self {
            Self::WillAppear => "willAppear",
            Self::Identity => "identity",
            Self::DidDisappear => "didDisappear",
        }
    }

    /// The phase a tag stands for, read from reflection rather than written down.
    ///
    /// `TransitionPhase` is resilient, so the numbering is not something a caller
    /// may assume — and getting it wrong would show as a transition that animates
    /// the wrong way round, which is exactly the kind of thing that looks like a
    /// design choice.
    fn from_tag(tag: u8) -> Self {
        unsafe {
            let meta = abi::metadata0(resolve::transition_phase_ma());
            assert!(!meta.is_null(), "TransitionPhase metadata");
            for p in [Self::WillAppear, Self::Identity, Self::DidDisappear] {
                let want = abi::enum_case_index(meta, p.case())
                    .unwrap_or_else(|| panic!("TransitionPhase has no `{}` case", p.case()));
                if want as u8 == tag {
                    return p;
                }
            }
            panic!("TransitionPhase tag {tag} is none of the three cases");
        }
    }
}

/// How a transition draws in each phase.
pub trait Transitioning: Send + Sync + 'static {
    /// Draw the content for one phase.
    fn body(&self, content: ViewHandle, phase: TransitionPhase) -> ViewHandle;
}

impl<F> Transitioning for F
where
    F: Fn(ViewHandle, TransitionPhase) -> ViewHandle + Send + Sync + 'static,
{
    fn body(&self, content: ViewHandle, phase: TransitionPhase) -> ViewHandle {
        self(content, phase)
    }
}

/// A registered transition, as the one word SwiftUI stores.
pub struct CustomTransition {
    index: i64,
}

fn transition_registry() -> &'static Mutex<Vec<&'static dyn Transitioning>> {
    static R: OnceLock<Mutex<Vec<&'static dyn Transitioning>>> = OnceLock::new();
    R.get_or_init(|| Mutex::new(Vec::new()))
}

/// Register a transition. A closure taking the content and the phase is one.
pub fn transition_fn<T: Transitioning>(transition: T) -> CustomTransition {
    let leaked: &'static dyn Transitioning = Box::leak(Box::new(transition));
    let mut r = transition_registry().lock().expect("transition registry");
    r.push(leaked);
    CustomTransition { index: r.len() as i64 - 1 }
}

// `body(content:phase:)` has one argument more than the others: the content in
// x0, the phase as a byte in x1, `self` in x20, the result through x8.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_transition_thunk",
    "_rswift_transition_thunk:",
    "mov x3, x20",
    "mov x2, x1",
    "mov x1, x0",
    "mov x0, x8",
    "b _rswift_transition_body",
);

unsafe extern "C" {
    #[link_name = "rswift_transition_thunk"]
    fn transition_thunk();
}

static PLACEHOLDER_META: std::sync::atomic::AtomicUsize =
    std::sync::atomic::AtomicUsize::new(0);
static PLACEHOLDER_WT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);

/// `body(content:phase:) -> Body`, with `Body == AnyView`.
///
/// # Safety
/// Reached through `rswift_transition_thunk`, which supplies the four arguments
/// in order.
#[unsafe(no_mangle)]
unsafe extern "C" fn rswift_transition_body(
    out: *mut u8,
    content: *mut c_void,
    phase: u64,
    this: *const u8,
) {
    use std::sync::atomic::Ordering::Acquire;
    let index = unsafe { *(this as *const i64) } as usize;
    let transition = {
        let r = transition_registry().lock().expect("transition registry");
        r.get(index).copied().expect("transition index out of range")
    };
    let meta = PLACEHOLDER_META.load(Acquire) as *const c_void;
    let wt = PLACEHOLDER_WT.load(Acquire) as *const c_void;
    let handle = unsafe {
        let mut bytes = vec![0u8; abi::type_bytes(meta)];
        let vwt = &*swift_runtime_sys::SwiftABI::get_value_witness_table(meta);
        (vwt.initialize_with_copy)(bytes.as_mut_ptr() as *mut c_void, content, meta);
        wrap_owned(bytes, meta, wt)
    };
    let body = transition.body(handle, TransitionPhase::from_tag(phase as u8));
    unsafe { *(out as *mut u64) = body.into_anyview_word() };
}

/// The carrier type a transition value *is*: one `Int`, its index.
fn transition_carrier() -> (*const c_void, *const c_void) {
    static C: OnceLock<(usize, usize)> = OnceLock::new();
    let (d, m) = *C.get_or_init(|| unsafe {
        let (d, m) =
            crate::state::emit_int_carrier(b"RustTransition\0", b"6rswift14RustTransitionV\0");
        (d as usize, m as usize)
    });
    (d as *const c_void, m as *const c_void)
}

fn transition_conformance() -> &'static Conformance {
    static C: OnceLock<Conformance> = OnceLock::new();
    C.get_or_init(|| unsafe {
        let protocol = Protocol::from_symbol(c"$s7SwiftUI10TransitionMp");
        assert_eq!(
            protocol.requirement_count(),
            5,
            "Transition changed shape — it used to be Body, its conformance, \
             `body(content:phase:)` and two defaulted requirements",
        );
        let conformance = synthesize(
            &protocol,
            transition_carrier().0,
            &[
                Witness::Metadata(resolve::anyview_wt()),
                Witness::Metadata(resolve::anyview_meta()),
                Witness::Function(transition_thunk as *const c_void),
                Witness::Default,
                Witness::Default,
            ],
        );

        use std::sync::atomic::Ordering::Release;
        let meta = abi::generic_metadata2(
            resolve::placeholder_content_ma(),
            transition_carrier().1,
            conformance.witness_table(),
        );
        assert!(!meta.is_null(), "PlaceholderContentView<RustTransition> metadata");
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "{} !: View", crate::diag::type_name(meta));
        PLACEHOLDER_META.store(meta as usize, Release);
        PLACEHOLDER_WT.store(wt as usize, Release);

        conformance
    })
}

/// `.transition(_:)` with a transition written in Rust.
///
/// Wrapped in an `AnyTransition` on the way, because that is what
/// `transition<T: Transition>(_:)` does: it is `@_alwaysEmitIntoClient` and
/// exports no symbol, so the binding calls what its body calls.
pub fn custom_transition(view: &ViewHandle, transition: &CustomTransition) -> ViewHandle {
    unsafe {
        let conformance = transition_conformance();
        let carrier = transition_carrier().1;
        let mut value = vec![0u8; abi::type_bytes(carrier)];
        value[..8].copy_from_slice(&transition.index.to_le_bytes());

        // `AnyTransition.init<T: Transition>(_:)` — x0 = @in T, x1 = T.Type,
        // x2 = T: Transition WT, and the box comes back in x0. `AnyTransition` is
        // `@frozen` around one class reference, so it is one word.
        let boxed: u64;
        core::arch::asm!("blr {f}", f = in(reg) resolve::any_transition_init(),
            in("x0") value.as_mut_ptr(),
            in("x1") carrier,
            in("x2") conformance.witness_table(),
            lateout("x0") boxed,
            lateout("x1") _, lateout("x2") _, lateout("x3") _, lateout("x4") _,
            lateout("x5") _, lateout("x6") _, lateout("x7") _, lateout("x8") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        assert!(boxed != 0, "AnyTransition.init returned nothing");

        super::opaque_modifier_for_transition(view, boxed)
    }
}

// ── A `CustomAnimation` written in Rust ──
//
// The timing curve itself, not one of SwiftUI's. This is the most interesting of
// the five, because `animate` is generic over *any* `VectorArithmetic` — a
// `Double`, a `CGSize`, an `AnimatablePair` of either — and the implementation
// is not allowed to know which. So it does not try: the Rust closure answers
// only "how far along is this, at time t", and the witness applies that fraction
// to whatever it was handed by calling the protocol's own `scale(by:)` through
// that type's witness table.
//
// `nil` means the animation has finished. That is how SwiftUI knows when to stop
// asking, and returning a value forever would leave it running.

/// A timing curve written in Rust.
pub trait Animating: Send + Sync + 'static {
    /// How much of the value to apply at `time` seconds in, or `None` when the
    /// animation is over.
    ///
    /// `0.0` is the starting value and `1.0` the target, but nothing stops a
    /// curve from overshooting — that is what a spring does.
    fn progress(&self, time: f64) -> Option<f64>;
}

impl<F> Animating for F
where
    F: Fn(f64) -> Option<f64> + Send + Sync + 'static,
{
    fn progress(&self, time: f64) -> Option<f64> {
        self(time)
    }
}

/// A registered animation, as the one word SwiftUI stores.
pub struct CustomAnimationCurve {
    index: i64,
}

fn animation_registry() -> &'static Mutex<Vec<&'static dyn Animating>> {
    static R: OnceLock<Mutex<Vec<&'static dyn Animating>>> = OnceLock::new();
    R.get_or_init(|| Mutex::new(Vec::new()))
}

/// Register a timing curve. A closure from time to progress is one.
pub fn animation_fn<A: Animating>(curve: A) -> CustomAnimationCurve {
    let leaked: &'static dyn Animating = Box::leak(Box::new(curve));
    let mut r = animation_registry().lock().expect("animation registry");
    r.push(leaked);
    CustomAnimationCurve { index: r.len() as i64 - 1 }
}

// `animate(value:time:context:)` arrives as
//   x8 = @out V?, x0 = @in V, d0 = time, x1 = inout AnimationContext<V>,
//   x2 = V.Type, x3 = V: VectorArithmetic WT, x20 = self
// and every integer argument has to move up one place. They are written in
// descending order of destination so none is overwritten before it is read.
core::arch::global_asm!(
    ".p2align 2",
    ".globl _rswift_custom_animation_thunk",
    "_rswift_custom_animation_thunk:",
    "mov x5, x20",
    "mov x4, x3",
    "mov x3, x2",
    "mov x2, x1",
    "mov x1, x0",
    "mov x0, x8",
    "b _rswift_custom_animation_animate",
);

unsafe extern "C" {
    #[link_name = "rswift_custom_animation_thunk"]
    fn custom_animation_thunk();
}

/// `animate(value:time:context:) -> V?`.
///
/// # Safety
/// Reached through `rswift_custom_animation_thunk`, which supplies the six
/// integer arguments in order and leaves the time in d0.
#[unsafe(no_mangle)]
#[allow(clippy::too_many_arguments)]
unsafe extern "C" fn rswift_custom_animation_animate(
    out: *mut u8,
    value: *const c_void,
    _context: *mut c_void,
    v_meta: *const c_void,
    v_wt: *const c_void,
    this: *const u8,
    time: f64,
) {
    let index = unsafe { *(this as *const i64) } as usize;
    let curve = {
        let r = animation_registry().lock().expect("animation registry");
        r.get(index).copied().expect("animation index out of range")
    };
    unsafe {
        match curve.progress(time) {
            // Finished. `V?` with an address-only payload spends a spare bit
            // pattern or a tag byte on `.none`; which of those is the payload's
            // business, so the witness is asked rather than a byte written.
            None => abi::store_optional_tag_at(out, v_meta, false),
            Some(fraction) => {
                let vwt = &*swift_runtime_sys::SwiftABI::get_value_witness_table(v_meta);
                (vwt.initialize_with_copy)(
                    out as *mut c_void,
                    value as *mut c_void,
                    v_meta,
                );
                // `scale(by:)` is a *mutating* requirement, so `self` is an
                // `inout` in x20 and the factor is in d0. Reached through its
                // dispatch thunk, which is how a generic caller reaches any
                // requirement it cannot name a concrete implementation for.
                core::arch::asm!("blr {f}", f = in(reg) resolve::vector_scale_by(),
                    in("d0") fraction,
                    in("x0") v_meta,
                    in("x1") v_wt,
                    in("x20") out,
                    lateout("x2") _, lateout("x3") _, lateout("x4") _, lateout("x5") _,
                    lateout("x6") _, lateout("x7") _, lateout("x8") _,
                    lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
                    lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
                    lateout("x17") _, lateout("lr") _, lateout("x21") _, clobber_abi("C"),
                );
                abi::store_optional_tag_at(out, v_meta, true);
            }
        }
    }
}

/// The carrier type an animation value *is*: one `Int`, its index.
fn animation_carrier() -> (*const c_void, *const c_void) {
    static C: OnceLock<(usize, usize)> = OnceLock::new();
    let (d, m) = *C.get_or_init(|| unsafe {
        let (d, m) =
            crate::state::emit_int_carrier(b"RustAnimation\0", b"6rswift13RustAnimationV\0");
        (d as usize, m as usize)
    });
    (d as *const c_void, m as *const c_void)
}

fn animation_conformance() -> &'static Conformance {
    static C: OnceLock<Conformance> = OnceLock::new();
    C.get_or_init(|| unsafe {
        let protocol = Protocol::from_symbol(c"$s7SwiftUI15CustomAnimationMp");
        assert_eq!(
            protocol.requirement_count(),
            4,
            "CustomAnimation changed shape — it used to be Hashable, `animate` and \
             two defaulted requirements",
        );
        synthesize(
            &protocol,
            animation_carrier().0,
            &[
                // `CustomAnimation: Hashable`, and the carrier is one `Int` — the
                // same size, alignment and bit pattern. So `Int`'s own `Hashable`
                // conformance describes it exactly: `hashValue` reads one word of
                // `self`, `hash(into:)` feeds one word to a `Hasher`, and `==`
                // compares two. Borrowing it is an ABI statement, not a language
                // one, and it is the same trade `custom_layout` makes for
                // `Animatable`.
                Witness::Metadata(resolve::int_hashable_wt()),
                Witness::Function(custom_animation_thunk as *const c_void),
                Witness::Default,
                Witness::Default,
            ],
        )
    })
}

impl CustomAnimationCurve {
    /// The curve as an `Animation`, for anything that takes one.
    ///
    /// `withAnimation` is the main such thing —
    /// [`StatefulView::set_animated_with`](crate::state::StatefulView::set_animated_with)
    /// takes exactly this word — and driving a state change with it is the only
    /// way to see the curve actually run: a static render shows one frame, and
    /// one frame of an animation is indistinguishable from no animation.
    ///
    /// A `CustomAnimation` is not an `Animation`; it is what one can be built
    /// from, which is what `Animation.init<A: CustomAnimation>(_:)` is for.
    pub fn animation_object(&self) -> u64 {
        unsafe { self.build_animation() }
    }

    /// # Safety
    /// Calls into SwiftUI.
    unsafe fn build_animation(&self) -> u64 {
        unsafe { build_custom_animation(self.index) }
    }
}

/// `Animation(curve)` for the curve registered at `index`.
///
/// # Safety
/// Calls into SwiftUI; `index` must be a registered curve.
unsafe fn build_custom_animation(index: i64) -> u64 {
    unsafe {
        let conformance = animation_conformance();
        let carrier = animation_carrier().1;
        let mut held = vec![0u8; abi::type_bytes(carrier)];
        held[..8].copy_from_slice(&index.to_le_bytes());

        // `Animation.init<A: CustomAnimation>(_:)` — x0 = @in A, x1 = A.Type,
        // x2 = A: CustomAnimation WT, and the box comes back in x0.
        let anim: u64;
        core::arch::asm!("blr {f}", f = in(reg) resolve::animation_custom_init(),
            in("x0") held.as_mut_ptr(),
            in("x1") carrier,
            in("x2") conformance.witness_table(),
            lateout("x0") anim,
            lateout("x1") _, lateout("x2") _, lateout("x3") _, lateout("x4") _,
            lateout("x5") _, lateout("x6") _, lateout("x7") _, lateout("x8") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        assert!(anim != 0, "Animation.init returned nothing");
        anim
    }
}

/// `.animation(Animation(curve), value:)` with a curve written in Rust.
pub fn custom_animation(
    view: &ViewHandle,
    curve: &CustomAnimationCurve,
    value: i64,
) -> ViewHandle {
    unsafe {
        let anim = build_custom_animation(curve.index);
        super::animation_word(view, anim, value)
    }
}