less root specific logic

Author: ealmloff

packages/core/src/diff/attributes.rs

@@ -97,21 +97,25 @@ impl VNode {
         to_iter: &mut Peekable<impl Iterator<Item = &'a Attribute>>,
     ) -> Option<(AttributeKey, Option<&'a Attribute>, Option<&'a Attribute>)> {
         match (from_iter.peek().copied(), to_iter.peek().copied()) {
-            (Some(from), Some(to_attr)) => match Self::compare_attribute_keys(from, to_attr) {
-                Ordering::Less => {
-                    from_iter.next();
-                    Some((Self::attribute_key(from), Some(from), None))
+            (Some(from), Some(to_attr)) => {
+                let from_key = Self::attribute_key(from);
+                let to_key = Self::attribute_key(to_attr);
+                match from_key.cmp(&to_key) {
+                    Ordering::Less => {
+                        from_iter.next();
+                        Some((from_key, Some(from), None))
+                    }
+                    Ordering::Greater => {
+                        to_iter.next();
+                        Some((to_key, None, Some(to_attr)))
+                    }
+                    Ordering::Equal => {
+                        from_iter.next();
+                        to_iter.next();
+                        Some((to_key, Some(from), Some(to_attr)))
+                    }
                 }
-                Ordering::Greater => {
-                    to_iter.next();
-                    Some((Self::attribute_key(to_attr), None, Some(to_attr)))
-                }
-                Ordering::Equal => {
-                    from_iter.next();
-                    to_iter.next();
-                    Some((Self::attribute_key(to_attr), Some(from), Some(to_attr)))
-                }
-            },
+            }
             (Some(from), None) => {
                 from_iter.next();
                 Some((Self::attribute_key(from), Some(from), None))

packages/core/src/diff/iterator.rs

@@ -380,8 +380,6 @@ impl DiffState<'_, '_, '_, '_> {
             lis_sequence.remove(0);
         }
 
-        let mut mounted_new = Vec::new();
-
         // Every shared child not in the stable LIS will move, so its committed
         // position is stale for the rest of this reorder. Mark them all up front
         // (O(1) each) so placement scans never anchor on a node that is mid-move,
@@ -416,7 +414,6 @@ impl DiffState<'_, '_, '_, '_> {
             new_mounts[*idx] = Some(mount);
             self.dom
                 .set_mounted_fragment_child(new_children, new_offset + *idx, mount);
-            mounted_new.push(MountedSibling { index: *idx, mount });
         }
 
         let last = *lis_sequence.first().unwrap();
@@ -433,7 +430,6 @@ impl DiffState<'_, '_, '_, '_> {
                 &mut *new_mounts,
                 new_children,
                 new_offset,
-                &mut mounted_new,
             );
         }
 
@@ -452,7 +448,6 @@ impl DiffState<'_, '_, '_, '_> {
                     new_mounts,
                     new_children,
                     new_offset,
-                    &mut mounted_new,
                 );
             }
         }
@@ -471,7 +466,6 @@ impl DiffState<'_, '_, '_, '_> {
                 &mut *new_mounts,
                 new_children,
                 new_offset,
-                &mut mounted_new,
             );
         }
 
@@ -534,7 +528,6 @@ impl DiffState<'_, '_, '_, '_> {
         new_mounts: &mut [Option<MountId>],
         new_children: FragmentMountWriter,
         new_offset: usize,
-        mounted_new: &mut Vec<MountedSibling>,
     ) {
         let context = self.context();
         let sibling_mount = new_mounts[sibling_idx].expect("sibling");
@@ -549,7 +542,7 @@ impl DiffState<'_, '_, '_, '_> {
                 crate::MountedVNode::new(&new[sibling_idx], sibling_mount),
                 self.dom,
             )
-            .or_else(|| insertion_site_in_new_order(edge, new, mounted_new, sibling_idx, self.dom))
+            .or_else(|| insertion_site_in_new_order(edge, new, new_mounts, sibling_idx, self.dom))
             .unwrap_or_else(|| {
                 insertion_site_at(
                     edge,
@@ -577,7 +570,6 @@ impl DiffState<'_, '_, '_, '_> {
                     new_mounts,
                     new_children,
                     new_offset,
-                    mounted_new,
                     &mut replaced_nodes,
                 )
             });
@@ -593,7 +585,6 @@ impl DiffState<'_, '_, '_, '_> {
                 new_mounts,
                 new_children,
                 new_offset,
-                mounted_new,
                 &mut replaced_nodes,
             );
         }
@@ -617,7 +608,6 @@ impl DiffState<'_, '_, '_, '_> {
         new_mounts: &mut [Option<MountId>],
         new_children: FragmentMountWriter,
         new_offset: usize,
-        mounted_new: &mut Vec<MountedSibling>,
         replaced_nodes: &mut Vec<(&'a VNode, MountId)>,
     ) -> usize {
         let range_start = range.start;
@@ -658,10 +648,6 @@ impl DiffState<'_, '_, '_, '_> {
             new_mounts[new_index] = Some(mount);
             self.dom
                 .set_mounted_fragment_child(new_children, new_offset + new_index, mount);
-            mounted_new.push(MountedSibling {
-                index: new_index,
-                mount,
-            });
             nodes += created_nodes;
         }
         nodes
@@ -732,44 +718,30 @@ impl DiffState<'_, '_, '_, '_> {
     }
 }
 
-#[derive(Clone, Copy)]
-struct MountedSibling {
-    index: usize,
-    mount: MountId,
-}
-
 /// Prefer anchors already materialized in the new sibling order.
 ///
-/// Invariant: every entry in `mounted_new` owns a live mount in `new` order. Pending new siblings are
-/// not representable in this slice and therefore cannot be used as anchors.
+/// Invariant: every `Some` entry in `new_mounts` owns a materialized sibling in new order. Pending
+/// new siblings are `None` and therefore cannot be used as anchors.
 fn insertion_site_in_new_order(
     edge: ElementEdge,
     new: &[VNode],
-    mounted_new: &[MountedSibling],
+    new_mounts: &[Option<MountId>],
     sibling_idx: usize,
     dom: &VirtualDom,
 ) -> Option<InsertionSite> {
     match edge {
-        ElementEdge::First => mounted_new
-            .iter()
-            .filter(|sibling| sibling.index >= sibling_idx)
-            .filter_map(|sibling| {
-                new[sibling.index]
-                    .find_first_element(sibling.mount, dom)
-                    .map(|id| (sibling.index, id))
-            })
-            .min_by_key(|(index, _)| *index)
-            .map(|(_, id)| InsertionSite::before(id)),
-        ElementEdge::Last => mounted_new
-            .iter()
-            .filter(|sibling| sibling.index <= sibling_idx)
-            .filter_map(|sibling| {
-                new[sibling.index]
-                    .find_last_element(sibling.mount, dom)
-                    .map(|id| (sibling.index, id))
-            })
-            .max_by_key(|(index, _)| *index)
-            .map(|(_, id)| InsertionSite::after(id)),
+        ElementEdge::First => (sibling_idx..new.len()).find_map(|index| {
+            let mount = new_mounts[index]?;
+            new[index]
+                .find_first_element(mount, dom)
+                .map(InsertionSite::before)
+        }),
+        ElementEdge::Last => (0..=sibling_idx).rev().find_map(|index| {
+            let mount = new_mounts[index]?;
+            new[index]
+                .find_last_element(mount, dom)
+                .map(InsertionSite::after)
+        }),
     }
 }
 

packages/core/src/diff/node.rs

@@ -8,8 +8,7 @@ use crate::{
         context::{DiffFrame, DiffState},
         placement::{
             ElementEdge, InsertionSite, at_site, create_at_site_with_mounts, insertion_site_at,
-            insertion_site_for_mounted_anchor, insertion_site_for_mounted_child,
-            insertion_site_for_slot,
+            insertion_site_for_mounted_child, insertion_site_for_slot,
         },
         template::{DynamicAnchor, DynamicNodeSlot},
     },
@@ -746,7 +745,7 @@ impl VNode {
             "background mounts must be created without renderer writes"
         );
 
-        let nodes_created = self.materialize_template_roots(mount, state, reuse_existing_mounts);
+        let nodes_created = self.materialize_static_roots(mount, state);
         self.fill_dynamic_slots(mount, state, reuse_existing_mounts);
 
         state.dom.commit_mount(mount, self);
@@ -758,26 +757,16 @@ impl VNode {
 }
 
 impl VNode {
-    fn materialize_template_roots(
+    fn materialize_static_roots(
         &self,
         mount: MountId,
         state: &mut DiffState<'_, '_, '_, '_>,
-        reuse_existing_mounts: bool,
     ) -> usize {
         let mut nodes_created = 0;
 
         for child in self.children() {
             match child {
-                VNodeChild::Dynamic(anchor) => {
-                    for slot in anchor.nodes() {
-                        nodes_created += self.create_dynamic_node_inner(
-                            mount,
-                            slot.index(),
-                            state,
-                            reuse_existing_mounts,
-                        );
-                    }
-                }
+                VNodeChild::Dynamic(_) => {}
                 VNodeChild::Element(element) => {
                     if let Some(to) = state.to.as_deref_mut() {
                         let root_anchor_idx = element.anchor_index().expect("root element");
@@ -813,7 +802,7 @@ impl VNode {
                 self.write_attr_anchor(mount, anchor, state.dom, to);
             }
 
-            if anchor.nodes().len() > 0 && anchor.parent_element_op_index().is_some() {
+            if anchor.nodes().len() > 0 {
                 self.load_dynamic_anchor(mount, anchor, state, reuse_existing_mounts);
             }
         }
@@ -907,8 +896,9 @@ impl VNode {
             return;
         }
 
+        let first_slot = anchor.nodes().next().expect("dynamic anchor has nodes");
         let context = state.context();
-        let site = insertion_site_for_mounted_anchor(mount, anchor, state.dom);
+        let site = insertion_site_for_slot(mount, first_slot, state.dom, context);
         let runtime = state.dom.runtime.clone();
         let dom = &mut *state.dom;
         let to = state.to.as_deref_mut().expect("writer checked");
@@ -982,16 +972,11 @@ impl VNode {
         dom: &mut VirtualDom,
         to: &mut dyn WriteMutations,
     ) {
-        let root_path = self.template.anchors()[root_anchor_idx].static_path();
         let mut assigned_paths = Vec::new();
 
-        for (anchor_idx, anchor) in self.template.anchors().iter().enumerate() {
-            let Some(path) = anchor_static_target(anchor) else {
-                continue;
-            };
-            if !path.starts_with(root_path) {
-                continue;
-            }
+        for target in self.static_anchor_targets_under(root_anchor_idx) {
+            let anchor_idx = target.anchor_index;
+            let path = target.path;
 
             if let Some((_, id)) = assigned_paths
                 .iter()