Struct LayoutTree 

pub struct LayoutTree {
    pub nodes: Vec<LayoutNodeHot>,
    pub warm: Vec<LayoutNodeWarm>,
    pub cold: Vec<LayoutNodeCold>,
    pub root: usize,
    pub dom_to_layout: HashMap<NodeId, Vec<usize>>,
    pub children_arena: Vec<usize>,
    pub children_offsets: Vec<(u32, u32)>,
    pub subtree_needs_intrinsic: Vec<bool>,
}

The complete layout tree structure.

Uses a struct-of-arrays (SoA) layout for cache performance:

• nodes (hot): accessed on every node in every layout pass
• warm: accessed during specific layout phases
• cold: construction / reconciliation only

Fields

nodes: Vec<LayoutNodeHot>

Hot layout data — box props, parent, used_size, formatting context

warm: Vec<LayoutNodeWarm>

Warm layout data — intrinsic sizes, baseline, inline layout, etc.

cold: Vec<LayoutNodeCold>

Cold layout data — dirty flags, fingerprints, reconciliation data

root: usize

Root node index

dom_to_layout: HashMap<NodeId, Vec<usize>>

Mapping from DOM node IDs to layout node indices

children_arena: Vec<usize>

Flat arena holding all children indices contiguously.

children_offsets: Vec<(u32, u32)>

Per-node (start, len) into children_arena. Indexed by node index.

subtree_needs_intrinsic: Vec<bool>

Per-node bit: this node or any descendant establishes a shrink-to-fit (STF) context whose sizing algorithm reads children’s intrinsic sizes (flex/grid/table/inline-block containers, floats, or abspos elements).

If subtree_needs_intrinsic[i] is false AND no ancestor of i is STF either, the intrinsic sizing pass can skip the entire subtree — nothing will ever read those values. This is the static-DOM optimization from §58 Win #3 (the “safely re-enabled Fix C”).

Computed once at tree build time in generate_layout_tree. An empty vec means “assume every subtree needs intrinsics” (safe fallback for code paths that construct LayoutTree without going through the builder — currently none, but preserves the invariant for tests).

Implementations

impl LayoutTree

pub fn memory_report(&self) -> LayoutTreeMemoryReport

Approximate heap bytes retained by this LayoutTree.

pub fn children(&self, index: usize) -> &[usize]

Returns the children of node index as a contiguous slice from the arena.

pub fn get(&self, index: usize) -> Option<&LayoutNodeHot>

Get hot layout data for a node (box_props, dom_node_id, used_size, etc.)

pub fn get_mut(&mut self, index: usize) -> Option<&mut LayoutNodeHot>

Get mutable hot layout data for a node.

pub fn warm(&self, index: usize) -> Option<&LayoutNodeWarm>

Get warm layout data for a node (intrinsic_sizes, baseline, inline_layout, etc.)

pub fn warm_mut(&mut self, index: usize) -> Option<&mut LayoutNodeWarm>

Get mutable warm layout data for a node.

pub fn cold(&self, index: usize) -> Option<&LayoutNodeCold>

Get cold layout data for a node (dirty_flag, subtree_hash, fingerprint, etc.)

pub fn cold_mut(&mut self, index: usize) -> Option<&mut LayoutNodeCold>

Get mutable cold layout data for a node.

pub fn root_node(&self) -> &LayoutNodeHot

pub fn get_full_node(&self, index: usize) -> Option<LayoutNode>

Reconstruct a full LayoutNode from the split hot/warm/cold arrays.

Used when passing node data to LayoutTreeBuilder::clone_node_from_old().

pub fn resolve_box_props( &mut self, node_index: usize, containing_block: LogicalSize, viewport_size: LogicalSize, element_font_size: f32, root_font_size: f32, )

Re-resolve box properties for a node with the actual containing block size.

pub fn mark_dirty(&mut self, start_index: usize, flag: DirtyFlag)

Marks a node and its ancestors as dirty with the given flag.

pub fn mark_subtree_dirty(&mut self, start_index: usize, flag: DirtyFlag)

Marks a node and its entire subtree of descendants with the given dirty flag.

pub fn clear_all_dirty_flags(&mut self)

Resets the dirty flags of all nodes in the tree to None after layout is complete.

pub fn get_inline_layout_for_node( &self, layout_index: usize, ) -> Option<&Arc<UnifiedLayout>>

Get inline layout for a node, navigating through IFC membership if needed.

pub fn get_content_size(&self, index: usize) -> LogicalSize

Get the content size of a node (for scrollbar calculations).

Trait Implementations

impl Clone for LayoutTree

fn clone(&self) -> LayoutTree

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LayoutTree

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.