cranpose_core/

emit.rs

use std::any::TypeId;

use crate::{
    Applier, ChildList, Command, CommandQueue, Composer, DirtyBubble, EmittedNode, MutableState,
    Node, NodeError, NodeId, OwnedMutableState, ParentAttachMode, ParentFrame, debug_scope_label,
    recompose::RecomposeChildCursor, slot::NodeSlotUpdate,
};

impl Composer {
    fn planned_node_parent(&self, id: NodeId) -> Option<NodeId> {
        if let Some(parent) = self.current_parent_hint().filter(|parent| *parent != id) {
            return Some(parent);
        }
        let mut applier = self.borrow_applier();
        applier.get_mut(id).ok().and_then(|node| node.parent())
    }

    fn queue_replaced_slot_node_removal(&self, old_id: NodeId, old_generation: u32) {
        let current_generation = self.borrow_applier().node_generation(old_id);
        if current_generation != old_generation {
            log::trace!(
                target: "cranpose::compose::emit",
                "skipping stale replacement cleanup for node #{old_id} (slot_generation={old_generation} current_generation={current_generation})",
            );
            return;
        }

        log::trace!(
            target: "cranpose::compose::emit",
            "removing replaced node #{old_id} (generation={old_generation})",
        );
        self.commands_mut().push(Command::RemoveNode { id: old_id });
    }

    /// Returns a [`MutableState`] holding the value `init` made on the first composition at this
    /// call site. Later compositions return the same state, so its value survives recomposition.
    #[track_caller]
    pub fn use_state<T: Clone + 'static>(&self, init: impl FnOnce() -> T) -> MutableState<T> {
        let source = crate::caller_location_key();
        let runtime = self.runtime_handle();
        let state = self.with_slot_session_mut(|slots| {
            slots.remember(source, || {
                OwnedMutableState::with_runtime(init(), runtime.clone())
            })
        });
        state.with(super::state::OwnedMutableState::handle)
    }

    fn emit_node_box<N: Node + 'static>(
        &self,
        source: crate::Key,
        make_node: impl FnOnce(&mut dyn Applier) -> EmittedNode,
    ) -> NodeId {
        let adopted = {
            let mut skip = 0;
            loop {
                let Some(found) = self
                    .with_slot_session_mut(|slots| slots.peek_node_record_by_source(source, skip))
                else {
                    break None;
                };
                let (type_ok, gen_ok) = {
                    let mut applier = self.borrow_applier();
                    let gen_ok = applier.node_generation(found.id) == found.generation;
                    let type_ok = match applier.get_mut(found.id) {
                        Ok(node) => node.as_any_mut().downcast_ref::<N>().is_some(),
                        Err(_) => false,
                    };
                    (type_ok, gen_ok)
                };
                if type_ok && gen_ok {
                    break Some(found);
                }
                skip += 1;
            }
        };

        if let Some(found) = adopted {
            let id = found.id;
            let scope_debug = self.current_recompose_scope().map_or((0, None), |scope| {
                (scope.id(), debug_scope_label(scope.id()))
            });
            log::trace!(
                target: "cranpose::compose::emit",
                "reusing node #{id} as {} [scope_id={} scope_label={:?}]",
                std::any::type_name::<N>(),
                scope_debug.0,
                scope_debug.1,
            );
            self.attach_to_parent(id);
            let parent_id = self.planned_node_parent(id);
            let recorded = self
                .with_slot_session_mut(|slots| slots.adopt_node_record(found, parent_id, source));
            match recorded {
                NodeSlotUpdate::Reused {
                    id: recorded_id,
                    generation,
                } => {
                    debug_assert_eq!(recorded_id, id);
                    debug_assert_eq!(generation, found.generation);
                }
                NodeSlotUpdate::Inserted { .. } => {
                    log::warn!(
                        target: "cranpose::compose::emit",
                        "slot writer inserted node #{id} while reusing the same node identity",
                    );
                }
                NodeSlotUpdate::Replaced {
                    old_id,
                    old_generation,
                    ..
                } => {
                    log::warn!(
                        target: "cranpose::compose::emit",
                        "slot writer replaced node #{old_id} while reusing node #{id}",
                    );
                    self.queue_replaced_slot_node_removal(old_id, old_generation);
                }
            }
            return id;
        }

        let (id, generation) = {
            let mut applier = self.borrow_applier();
            let emitted = make_node(&mut *applier);
            let id = match emitted {
                EmittedNode::Fresh(node) => applier.create(node),
                EmittedNode::Recycled(recycled) => {
                    let (stable_id, node, warm_origin) = recycled.into_parts();
                    let insertion = applier.insert_recycled_node_or_create(stable_id, node);
                    if let Some(error) = insertion.fallback_error.as_ref() {
                        log::warn!(
                            target: "cranpose::compose::emit",
                            "discarding stale recycled stable id #{stable_id}: {error}",
                        );
                    }
                    applier.set_recycled_node_origin(insertion.id, warm_origin);
                    insertion.id
                }
            };
            let generation = applier.node_generation(id);
            (id, generation)
        };
        let scope_debug = self.current_recompose_scope().map_or((0, None), |scope| {
            (scope.id(), debug_scope_label(scope.id()))
        });
        log::trace!(
            target: "cranpose::compose::emit",
            "creating node #{} (gen={}) as {} [scope_id={} scope_label={:?}]",
            id,
            generation,
            std::any::type_name::<N>(),
            scope_debug.0,
            scope_debug.1,
        );
        self.commands_mut().push(Command::MountNode { id });
        self.attach_to_parent(id);
        let parent_id = self.planned_node_parent(id);
        let recorded = self.with_slot_session_mut(|slots| {
            slots.record_node_with_parent(id, generation, parent_id, source)
        });
        match recorded {
            NodeSlotUpdate::Inserted {
                id: recorded_id,
                generation: recorded_generation,
            } => {
                debug_assert_eq!(recorded_id, id);
                debug_assert_eq!(recorded_generation, generation);
            }
            NodeSlotUpdate::Replaced {
                old_id,
                old_generation,
                new_id,
                new_generation,
            } => {
                debug_assert_eq!(new_id, id);
                debug_assert_eq!(new_generation, generation);
                self.queue_replaced_slot_node_removal(old_id, old_generation);
            }
            NodeSlotUpdate::Reused { .. } => {
                log::warn!(
                    target: "cranpose::compose::emit",
                    "slot writer reported reuse for newly emitted node #{id}",
                );
            }
        }
        id
    }

    /// Emits a node of type `N` as a child of the current parent and returns its id. The first
    /// composition at this call site calls `init` to make the node. Later compositions reuse that
    /// node and do not call `init`.
    #[track_caller]
    pub fn emit_node<N: Node + 'static>(&self, init: impl FnOnce() -> N) -> NodeId {
        let source = crate::caller_location_key();
        self.emit_node_box::<N>(source, |_| EmittedNode::Fresh(Box::new(init())))
    }

    /// Emits a node of type `N` as `emit_node` does, reusing a pooled node when one exists. A
    /// pooled `N` is cleared by `reset`, and otherwise `init` makes a new node.
    #[track_caller]
    pub fn emit_recyclable_node<N: Node + 'static>(
        &self,
        init: impl FnOnce() -> N,
        reset: impl FnOnce(&mut N),
    ) -> NodeId {
        let source = crate::caller_location_key();
        self.emit_node_box::<N>(source, |applier| {
            let key = TypeId::of::<N>();
            if let Some(mut recycled) = applier.take_recycled_node(key) {
                if let Some(typed) = recycled.node_mut().as_any_mut().downcast_mut::<N>() {
                    reset(typed);
                    return EmittedNode::Recycled(recycled);
                }
                log::warn!(
                    target: "cranpose::compose::emit",
                    "discarding recycled node shell with mismatched type for {}",
                    std::any::type_name::<N>(),
                );
            }

            let node = Box::new(init());
            applier.record_fresh_recyclable_creation(key);
            if let Some(shell) = node.rehouse_for_recycle() {
                applier.seed_recycled_node_shell(key, node.recycle_pool_limit(), shell);
            }
            EmittedNode::Fresh(node)
        })
    }

    fn skip_recompose_child(&self) {
        let cursor = match self.core.recompose_child_cursor.get() {
            RecomposeChildCursor::After { first, placed } => RecomposeChildCursor::After {
                first,
                placed: placed + 1,
            },
            RecomposeChildCursor::At(index) => RecomposeChildCursor::At(index + 1),
            RecomposeChildCursor::Unknown => return,
        };
        self.core.recompose_child_cursor.set(cursor);
    }

    fn next_recompose_insert_index(&self) -> Option<usize> {
        let RecomposeChildCursor::At(index) = self.resolve_recompose_child_cursor() else {
            return None;
        };
        self.core
            .recompose_child_cursor
            .set(RecomposeChildCursor::At(index + 1));
        Some(index)
    }

    pub(crate) fn attach_to_parent(&self, id: NodeId) {
        if self.attach_to_current_parent(id) {
            return;
        }
        self.attach_without_parent_frame(id);
    }

    fn attach_to_current_parent(&self, id: NodeId) -> bool {
        let mut parent_stack = self.parent_stack();
        if let Some(parent_id) = parent_stack.last().map(|frame| frame.id) {
            let stale_root_parent = self.core.root.get() == Some(parent_id) && {
                let mut applier = self.borrow_applier();
                applier.get_mut(parent_id).is_err()
            };
            if stale_root_parent {
                parent_stack.pop();
                self.set_root(None);
            } else {
                let Some(frame) = parent_stack.last_mut() else {
                    return false;
                };
                let attach_mode = frame.attach_mode;
                if parent_id == id {
                    return true;
                }
                // A child where the parent held it before is already attached
                // to the parent: its node needs no visit.
                let attached_before = frame.previous.get(frame.new_children.len()) == Some(&id);
                if matches!(attach_mode, ParentAttachMode::DeferredSync) {
                    frame.new_children.push(id);
                }
                drop(parent_stack);

                if attached_before {
                    debug_assert!(
                        self.borrow_applier()
                            .get_mut(id)
                            .map_or(true, |node| node.parent().is_none_or(|p| p == parent_id)),
                        "a parent's previous child must name no other parent"
                    );
                } else {
                    let mut applier = self.borrow_applier();
                    if let Ok(child_node) = applier.get_mut(id) {
                        child_node.set_parent_for_bubbling(parent_id);
                    }
                }
                if matches!(attach_mode, ParentAttachMode::ImmediateAppend) {
                    self.commands_mut().push(Command::AttachChild {
                        parent_id,
                        child_id: id,
                        insert_index: None,
                        bubble: DirtyBubble::LAYOUT_AND_MEASURE,
                    });
                }
                return true;
            }
        }
        false
    }

    fn attach_without_parent_frame(&self, id: NodeId) {
        let in_subcompose = !self.subcompose_stack().is_empty();
        if in_subcompose {
            let has_parent = {
                let mut applier = self.borrow_applier();
                applier
                    .get_mut(id)
                    .is_ok_and(|node| node.parent().is_some())
            };

            if !has_parent {
                let mut subcompose_stack = self.subcompose_stack();
                if let Some(frame) = subcompose_stack.last_mut() {
                    frame.nodes.push(id);
                }
            }
            return;
        }

        if let Some(parent_hint) = self.core.recompose_parent_hint.get() {
            if parent_hint == id {
                debug_assert_ne!(
                    parent_hint, id,
                    "a node cannot be attached as its own parent"
                );
                return;
            }
            let parent_status = {
                let mut applier = self.borrow_applier();
                applier.get_mut(id).map_or(None, |node| node.parent())
            };
            match parent_status {
                Some(existing) if existing == parent_hint => {
                    self.skip_recompose_child();
                }
                None => {
                    let insert_index = self.next_recompose_insert_index();
                    self.commands_mut().push(Command::AttachChild {
                        parent_id: parent_hint,
                        child_id: id,
                        insert_index,
                        bubble: DirtyBubble::LAYOUT_AND_MEASURE,
                    });
                }
                Some(_) => {}
            }
            return;
        }

        let has_parent = {
            let mut applier = self.borrow_applier();
            applier
                .get_mut(id)
                .is_ok_and(|node| node.parent().is_some())
        };
        if has_parent {
            return;
        }

        self.set_root(Some(id));
    }

    /// Runs `f` on the node `id` as an `N`. Returns an error if the node does not exist or is not
    /// an `N`.
    pub fn with_node_mut<N: Node + 'static, R>(
        &self,
        id: NodeId,
        f: impl FnOnce(&mut N) -> R,
    ) -> Result<R, NodeError> {
        let mut applier = self.borrow_applier();
        let node = applier.get_mut(id)?;
        let typed =
            node.as_any_mut()
                .downcast_mut::<N>()
                .ok_or_else(|| NodeError::TypeMismatch {
                    id,
                    expected: std::any::type_name::<N>(),
                })?;
        Ok(f(typed))
    }

    /// Makes the node `id` the parent of the nodes emitted next. Each call needs a matching
    /// `pop_parent`.
    pub fn push_parent(&self, id: NodeId) {
        let in_subcompose = !self.core.subcompose_stack.borrow().is_empty();

        let children = self.get_node_children(id);
        let previous = if children.is_empty() {
            ChildList::new()
        } else {
            ChildList::from_slice(&children)
        };
        let attach_mode = if in_subcompose || !previous.is_empty() {
            ParentAttachMode::DeferredSync
        } else {
            ParentAttachMode::ImmediateAppend
        };

        self.parent_stack().push(ParentFrame {
            id,
            previous,
            new_children: ChildList::new(),
            new_children_membership: None,
            attach_mode,
            synthetic_root: false,
        });
    }

    /// Composes nothing under node `id`, which holds children when
    /// `holds_children`: the parent frame [`Composer::push_parent`] and
    /// [`Composer::pop_parent`] would open and close around nothing is left
    /// out where closing it would sync nothing, which is outside a
    /// subcomposition for a node that holds no children.
    pub fn compose_no_children(&self, id: NodeId, holds_children: bool) {
        if holds_children || !self.core.subcompose_stack.borrow().is_empty() {
            self.push_parent(id);
            self.pop_parent();
        }
    }

    /// Closes the parent opened by the matching `push_parent` and sets that node's children to the
    /// nodes emitted since.
    pub fn pop_parent(&self) {
        let frame_opt = {
            let mut stack = self.parent_stack();
            stack.pop()
        };
        if let Some(frame) = frame_opt {
            let ParentFrame {
                id,
                previous,
                new_children,
                new_children_membership: _new_children_membership,
                attach_mode,
                synthetic_root: _synthetic_root,
            } = frame;

            log::trace!(target: "cranpose::compose::parent", "pop_parent: node #{id}");
            log::trace!(
                target: "cranpose::compose::parent",
                "previous children: {previous:?}"
            );
            log::trace!(
                target: "cranpose::compose::parent",
                "new children: {new_children:?}"
            );
            if matches!(attach_mode, ParentAttachMode::DeferredSync) {
                let _ = previous;
                self.commands_mut().push(Command::SyncChildren {
                    parent_id: id,
                    expected_children: new_children,
                });
            }
        }
    }

    pub(crate) fn take_commands(&self) -> CommandQueue {
        std::mem::take(&mut *self.commands_mut())
    }

    /// Applies any pending applier commands and runtime updates.
    ///
    /// This is useful during measure-time subcomposition to ensure newly created
    /// nodes are available for measurement before the full composition is committed.
    pub fn apply_pending_commands(&self) -> Result<(), NodeError> {
        self.resolve_recompose_child_cursor();
        let mut commands = self.take_commands();
        let runtime_handle = self.runtime_handle();
        let result = {
            let mut applier = self.borrow_applier();
            let mut result = commands.apply(&mut *applier);
            if result.is_ok() {
                for update in runtime_handle.take_updates() {
                    if let Err(err) = update.apply(&mut *applier) {
                        result = Err(err);
                        break;
                    }
                }
            }
            result
        };
        // The pass goes on queueing: hand it back the storage just applied.
        let mut queued = self.commands_mut();
        if queued.len() == 0 {
            std::mem::swap(&mut *queued, &mut commands);
        }
        drop(queued);
        if result.is_err() {
            let host = self.active_slots_host();
            if !host.has_active_pass() {
                host.abandon_after_apply_failure();
            }
        }
        result
    }

    /// Queues `effect` to run after this pass has applied its node changes.
    pub fn register_side_effect(&self, effect: impl FnOnce() + 'static) {
        self.side_effects_mut().push(Box::new(effect));
    }

    /// Removes and returns the side effects queued during this pass.
    pub fn take_side_effects(&self) -> Vec<Box<dyn FnOnce()>> {
        std::mem::take(&mut *self.side_effects_mut())
    }

    pub(crate) fn root(&self) -> Option<NodeId> {
        self.core.root.get()
    }

    pub(crate) fn set_root(&self, node: Option<NodeId>) {
        self.core.root.set(node);
    }
}