Convert LayoutTree trait to implicitly reference a single node in the tree

Author: nicoburns

src/compute/flexbox.rs

@@ -78,7 +78,7 @@ pub(super) fn align_and_position_item(
 ) {
     let grid_area_size = Size { width: grid_area.right - grid_area.left, height: grid_area.bottom - grid_area.top };
 
-    let style = tree.style(node);
+    let style = tree.child_style(node);
     let aspect_ratio = style.aspect_ratio;
     let justify_self = style.justify_self;
     let align_self = style.align_self;
@@ -204,7 +204,7 @@ pub(super) fn align_and_position_item(
         margin.vertical_components(),
     );
 
-    *tree.layout_mut(node) = Layout { order, size: Size { width, height }, location: Point { x, y } };
+    *tree.child_layout_mut(node) = Layout { order, size: Size { width, height }, location: Point { x, y } };
 }
 
 /// Align and size a grid item along a single axis

src/compute/grid/alignment.rs

@@ -39,24 +39,22 @@ impl LayoutAlgorithm for CssGridAlgorithm {
 
     fn perform_layout(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
         _sizing_mode: SizingMode,
     ) -> SizeAndBaselines {
-        compute_generic(tree, node, known_dimensions, parent_size, available_space, RunMode::PeformLayout)
+        compute_generic(tree, known_dimensions, parent_size, available_space, RunMode::PeformLayout)
     }
 
     fn measure_size(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
         _sizing_mode: SizingMode,
     ) -> Size<f32> {
-        compute_generic(tree, node, known_dimensions, parent_size, available_space, RunMode::ComputeSize).size
+        compute_generic(tree, known_dimensions, parent_size, available_space, RunMode::ComputeSize).size
     }
 }
 
@@ -68,15 +66,14 @@ impl LayoutAlgorithm for CssGridAlgorithm {
 ///   - Alignment & Final item placement
 pub fn compute_generic(
     tree: &mut impl LayoutTree,
-    node: Node,
     known_dimensions: Size<Option<f32>>,
     parent_size: Size<Option<f32>>,
     available_space: Size<AvailableSpace>,
     _run_mode: RunMode,
 ) -> SizeAndBaselines {
-    let get_child_styles_iter = |node| tree.children(node).map(|child_node: &Node| tree.style(*child_node));
-    let style = tree.style(node).clone();
-    let child_styles_iter = get_child_styles_iter(node);
+    let get_child_styles_iter = || tree.children().map(|child_node: &Node| tree.child_style(*child_node));
+    let style = tree.style().clone();
+    let child_styles_iter = get_child_styles_iter();
 
     // 1. Resolve the explicit grid
     // Exactly compute the number of rows and columns in the explicit grid.
@@ -91,14 +88,14 @@ pub fn compute_generic(
 
     // 2. Grid Item Placement
     // Match items (children) to a definite grid position (row start/end and column start/end position)
-    let mut items = Vec::with_capacity(tree.child_count(node));
+    let mut items = Vec::with_capacity(tree.child_count());
     let mut cell_occupancy_matrix = CellOccupancyMatrix::with_track_counts(est_col_counts, est_row_counts);
     let grid_auto_flow = style.grid_auto_flow;
     let in_flow_children_iter = || {
-        tree.children(node)
+        tree.children()
             .copied()
             .enumerate()
-            .map(|(index, child_node)| (index, child_node, tree.style(child_node)))
+            .map(|(index, child_node)| (index, child_node, tree.child_style(child_node)))
             .filter(|(_, _, style)| style.display != Display::None && style.position != Position::Absolute)
     };
     place_grid_items(&mut cell_occupancy_matrix, &mut items, in_flow_children_iter, grid_auto_flow);
@@ -312,13 +309,13 @@ pub fn compute_generic(
 
     // Position hidden and absolutely positioned children
     let mut order = items.len() as u32;
-    (0..tree.child_count(node)).for_each(|index| {
-        let child = tree.child(node, index);
-        let child_style = tree.style(child);
+    (0..tree.child_count()).for_each(|index| {
+        let child = tree.child(index);
+        let child_style = tree.child_style(child);
 
         // Position hidden child
         if child_style.display == Display::None {
-            *tree.layout_mut(node) = Layout::with_order(order);
+            *tree.layout_mut() = Layout::with_order(order);
             tree.perform_child_layout(child, Size::NONE, Size::NONE, Size::MAX_CONTENT, SizingMode::InherentSize);
             order += 1;
             return;

src/compute/grid/mod.rs

@@ -158,8 +158,8 @@ pub(super) fn determine_if_item_crosses_flexible_tracks(
 /// Track sizing algorithm
 /// Note: Gutters are treated as empty fixed-size tracks for the purpose of the track sizing algorithm.
 #[allow(clippy::too_many_arguments)]
-pub(super) fn track_sizing_algorithm<Tree: LayoutTree>(
-    tree: &mut Tree,
+pub(super) fn track_sizing_algorithm<>(
+    tree: &mut impl LayoutTree,
     axis: AbstractAxis,
     available_space: Size<AvailableSpace>,
     available_grid_space: Size<AvailableSpace>,

src/compute/grid/track_sizing.rs

@@ -235,7 +235,7 @@ impl GridItem {
         inner_node_size: Size<Option<f32>>,
     ) -> f32 {
         self.minimum_contribution_cache.unwrap_or_else(|| {
-            let style = tree.style(self.node);
+            let style = tree.child_style(self.node);
             style
                 .size
                 .maybe_resolve(available_space.into_options())

src/compute/grid/types/grid_item.rs

@@ -4,7 +4,6 @@ use crate::compute::LayoutAlgorithm;
 use crate::geometry::{Point, Size};
 use crate::layout::{SizeAndBaselines, SizingMode};
 use crate::math::MaybeMath;
-use crate::node::Node;
 use crate::resolve::{MaybeResolve, ResolveOrZero};
 use crate::style::AvailableSpace;
 use crate::sys::f32_max;
@@ -20,37 +19,34 @@ impl LayoutAlgorithm for LeafAlgorithm {
 
     fn perform_layout(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
         sizing_mode: SizingMode,
     ) -> SizeAndBaselines {
-        compute_generic(tree, node, known_dimensions, parent_size, available_space, sizing_mode)
+        compute_generic(tree, known_dimensions, parent_size, available_space, sizing_mode)
     }
 
     fn measure_size(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
         sizing_mode: SizingMode,
     ) -> Size<f32> {
-        compute_generic(tree, node, known_dimensions, parent_size, available_space, sizing_mode).size
+        compute_generic(tree, known_dimensions, parent_size, available_space, sizing_mode).size
     }
 }
 
 /// Compute the size of a leaf node (node with no children)
 pub(crate) fn compute_generic(
     tree: &mut impl LayoutTree,
-    node: Node,
     known_dimensions: Size<Option<f32>>,
     parent_size: Size<Option<f32>>,
     available_space: Size<AvailableSpace>,
     sizing_mode: SizingMode,
 ) -> SizeAndBaselines {
-    let style = tree.style(node);
+    let style = tree.style();
 
     // Resolve node's preferred/min/max sizes (width/heights) against the available space (percentages resolve to pixel values)
     // For ContentSize mode, we pretend that the node has no size styles as these should be ignored.
@@ -87,7 +83,7 @@ pub(crate) fn compute_generic(
         return SizeAndBaselines { size, first_baselines: Point::NONE };
     };
 
-    if tree.needs_measure(node) {
+    if tree.needs_measure() {
         // Compute available space
         let available_space = Size {
             width: available_space
@@ -103,7 +99,7 @@ pub(crate) fn compute_generic(
         };
 
         // Measure node
-        let measured_size = tree.measure_node(node, known_dimensions, available_space);
+        let measured_size = tree.measure_node(known_dimensions, available_space);
 
         let measured_size = Size {
             width: measured_size.width,