handle height

packages/native-core/src/state.rs

@@ -5,7 +5,7 @@ use crate::node_ref::{NodeMask, NodeView};
 use crate::tree::TreeView;
 use crate::RealNodeId;
 use anymap::AnyMap;
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 /// Join two sorted iterators
 pub(crate) fn union_ordered_iter<'a>(
@@ -81,15 +81,15 @@ pub trait ChildDepState {
     /// The context is passed to the [ChildDepState::reduce] when it is resolved.
     type Ctx;
     /// A state from each child node that this node depends on. Typically this is Self, but it could be any state that is within the state tree.
-    /// This must be either a [ChildDepState], or [NodeDepState].
-    type DepState;
+    /// Depstate must be a tuple containing any number of borrowed elements that are either [ChildDepState] or [NodeDepState].
+    type DepState: ElementBorrowable;
     /// The part of a node that this state cares about. This is used to determine if the state should be updated when a node is updated.
     const NODE_MASK: NodeMask = NodeMask::NONE;
     /// Resolve the state current node's state from the state of the children, the state of the node, and some external context.
     fn reduce<'a>(
         &mut self,
         node: NodeView,
-        children: impl Iterator<Item = &'a Self::DepState>,
+        children: impl Iterator<Item = <Self::DepState as ElementBorrowable>::ElementBorrowed<'a>>,
         ctx: &Self::Ctx,
     ) -> bool
     where
@@ -143,15 +143,15 @@ pub trait ParentDepState {
     /// The context is passed to the [ParentDepState::reduce] when it is resolved.
     type Ctx;
     /// A state from from the parent node that this node depends on. Typically this is Self, but it could be any state that is within the state tree.
-    /// This must be either a [ParentDepState] or [NodeDepState]
-    type DepState;
+    /// Depstate must be a tuple containing any number of borrowed elements that are either [ParentDepState] or [NodeDepState].
+    type DepState: ElementBorrowable;
     /// The part of a node that this state cares about. This is used to determine if the state should be updated when a node is updated.
     const NODE_MASK: NodeMask = NodeMask::NONE;
     /// Resolve the state current node's state from the state of the parent node, the state of the node, and some external context.
     fn reduce<'a>(
         &mut self,
         node: NodeView,
-        parent: Option<&'a Self::DepState>,
+        parent: Option<<Self::DepState as ElementBorrowable>::ElementBorrowed<'a>>,
         ctx: &Self::Ctx,
     ) -> bool;
 }
@@ -193,23 +193,27 @@ pub trait ParentDepState {
 ///     }
 /// }
 /// ```
-/// The generic argument (Depstate) must be a tuple containing any number of borrowed elements that are either a [ChildDepState], [ParentDepState] or [NodeDepState].
-// Todo: once GATs land we can model multable dependencies better
-
-pub trait NodeDepState<DepState = ()> {
+pub trait NodeDepState {
+    /// Depstate must be a tuple containing any number of borrowed elements that are either [ChildDepState], [ParentDepState] or [NodeDepState].
+    type DepState: ElementBorrowable;
     /// The state passed to [NodeDepState::reduce] when it is resolved.
     type Ctx;
     /// The part of a node that this state cares about. This is used to determine if the state should be updated when a node is updated.
     const NODE_MASK: NodeMask = NodeMask::NONE;
     /// Resolve the state current node's state from the state of the sibling states, the state of the node, and some external context.
-    fn reduce(&mut self, node: NodeView, siblings: DepState, ctx: &Self::Ctx) -> bool;
+    fn reduce<'a>(
+        &mut self,
+        node: NodeView,
+        siblings: <Self::DepState as ElementBorrowable>::ElementBorrowed<'a>,
+        ctx: &Self::Ctx,
+    ) -> bool;
 }
 
 /// Do not implement this trait. It is only meant to be derived and used through [crate::real_dom::RealDom].
 pub trait State: Default + Clone {
     #[doc(hidden)]
     fn update<'a, T: TreeView<Self>, T2: TreeView<NodeData>>(
-        dirty: &[(RealNodeId, NodeMask)],
+        dirty: &FxHashMap<RealNodeId, NodeMask>,
         state_tree: &'a mut T,
         rdom: &'a T2,
         ctx: &AnyMap,
@@ -219,12 +223,7 @@ pub trait State: Default + Clone {
 impl ChildDepState for () {
     type Ctx = ();
     type DepState = ();
-    fn reduce<'a>(
-        &mut self,
-        _: NodeView,
-        _: impl Iterator<Item = &'a Self::DepState>,
-        _: &Self::Ctx,
-    ) -> bool
+    fn reduce<'a>(&mut self, _: NodeView, _: impl Iterator<Item = ()>, _: &Self::Ctx) -> bool
     where
         Self::DepState: 'a,
     {
@@ -235,14 +234,55 @@ impl ChildDepState for () {
 impl ParentDepState for () {
     type Ctx = ();
     type DepState = ();
-    fn reduce<'a>(&mut self, _: NodeView, _: Option<&'a Self::DepState>, _: &Self::Ctx) -> bool {
+    fn reduce<'a>(&mut self, _: NodeView, _: Option<()>, _: &Self::Ctx) -> bool {
         false
     }
 }
 
-impl NodeDepState<()> for () {
+impl NodeDepState for () {
+    type DepState = ();
     type Ctx = ();
     fn reduce(&mut self, _: NodeView, _sibling: (), _: &Self::Ctx) -> bool {
         false
     }
 }
+
+pub trait ElementBorrowable {
+    type ElementBorrowed<'a>
+    where
+        Self: 'a;
+
+    fn borrow_elements(&self) -> Self::ElementBorrowed<'_>;
+}
+
+macro_rules! impl_element_borrowable {
+    ($($t:ident),*) => {
+        impl< $($t),* > ElementBorrowable for ($($t,)*) {
+            type ElementBorrowed<'a> = ($(&'a $t,)*) where Self: 'a;
+
+            #[allow(clippy::unused_unit, non_snake_case)]
+            fn borrow_elements<'a>(&'a self) -> Self::ElementBorrowed<'a> {
+                let ($($t,)*) = self;
+                ($(&$t,)*)
+            }
+        }
+    };
+}
+
+impl_element_borrowable!();
+impl_element_borrowable!(A);
+impl_element_borrowable!(A, B);
+impl_element_borrowable!(A, B, C);
+impl_element_borrowable!(A, B, C, D);
+impl_element_borrowable!(A, B, C, D, E);
+impl_element_borrowable!(A, B, C, D, E, F);
+impl_element_borrowable!(A, B, C, D, E, F, G);
+impl_element_borrowable!(A, B, C, D, E, F, G, H);
+impl_element_borrowable!(A, B, C, D, E, F, G, H, I);
+impl_element_borrowable!(A, B, C, D, E, F, G, H, I, J);
+impl_element_borrowable!(A, B, C, D, E, F, G, H, I, J, K);
+impl_element_borrowable!(A, B, C, D, E, F, G, H, I, J, K, L);
+impl_element_borrowable!(A, B, C, D, E, F, G, H, I, J, K, L, M);
+impl_element_borrowable!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
+impl_element_borrowable!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
+impl_element_borrowable!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);