fix: skip reversal when list lengths match in unkeyed reconciliation

The common case (same-length lists) now takes the original back-to-back zip path with zero overhead. The front-to-front reversal only fires when lengths actually differ.

Author: Madoshakalaka

packages/yew/src/dom_bundle/blist.rs

@@ -145,7 +145,7 @@ impl BList {
 
     /// Diff and patch unkeyed child lists
     ///
-    /// Pairs children by render-order position from the front, so that leading
+    /// Pairs children front-to-front by render-order position so that leading
     /// nodes are always reconciled with themselves when the list grows or
     /// shrinks at the tail.
     fn apply_unkeyed(
@@ -163,47 +163,54 @@ impl BList {
             slot,
         };
 
-        // `rights` is stored in reverse render order. Flip to render order so
-        // that simple index-based pairing matches children front-to-front.
-        rights.reverse();
+        if lefts.len() == rights.len() {
+            // Fast path: when lengths match, back-to-back pairing (the natural
+            // order for rev_children) is identical to front-to-front.  No
+            // reversal needed.
+            for (l, r) in lefts.into_iter().rev().zip(rights.iter_mut()) {
+                writer = writer.patch(l, r);
+            }
+        } else {
+            // Lengths differ: flip to render order so index-based pairing
+            // matches children front-to-front.
+            rights.reverse();
 
-        let left_len = lefts.len();
+            let left_len = lefts.len();
 
-        // Remove excess old nodes from the END of render order (now the tail).
-        if left_len < rights.len() {
-            for r in rights.drain(left_len..) {
-                test_log!("removing: {:?}", r);
-                r.detach(root, parent, false);
+            // Remove excess old nodes from the end of render order (the tail).
+            if left_len < rights.len() {
+                for r in rights.drain(left_len..) {
+                    test_log!("removing: {:?}", r);
+                    r.detach(root, parent, false);
+                }
             }
-        }
-
-        let paired_count = rights.len(); // min(left_len, old_len)
 
-        // The NodeWriter must process children right-to-left in render order.
-        let mut lefts_rev = lefts.into_iter().rev();
+            let paired_count = rights.len(); // min(left_len, old_len)
+            let mut lefts_rev = lefts.into_iter().rev();
+
+            // Add excess new nodes at the tail of render order (rightmost
+            // first for the NodeWriter).
+            let excess_start = rights.len();
+            for l in lefts_rev
+                .by_ref()
+                .take(left_len.saturating_sub(paired_count))
+            {
+                let (next_writer, el) = writer.add(l);
+                rights.push(el);
+                writer = next_writer;
+            }
+            // Items were pushed right-to-left; flip to render order.
+            rights[excess_start..].reverse();
 
-        // 1. Add excess new nodes at the tail of render order (rightmost first).
-        let excess_start = rights.len();
-        for l in lefts_rev
-            .by_ref()
-            .take(left_len.saturating_sub(paired_count))
-        {
-            let (next_writer, el) = writer.add(l);
-            rights.push(el);
-            writer = next_writer;
-        }
-        // Items were pushed right-to-left; flip them to render order.
-        rights[excess_start..].reverse();
+            // Patch paired nodes right-to-left.
+            for (l, r) in lefts_rev.zip(rights[..paired_count].iter_mut().rev()) {
+                writer = writer.patch(l, r);
+            }
 
-        // 2. Patch paired nodes right-to-left. lefts_rev now yields positions [paired_count-1 ..
-        //    0]. rights[..paired_count] is in render order, .rev() walks right-to-left.
-        for (l, r) in lefts_rev.zip(rights[..paired_count].iter_mut().rev()) {
-            writer = writer.patch(l, r);
+            // Flip back to reverse render order.
+            rights.reverse();
         }
 
-        // Flip back to reverse render order.
-        rights.reverse();
-
         writer.slot
     }