Avoid redundant anchor lookups in Fragment.anchor() and unkeyed v-for (#188)

* Add pytest-benchmark suite and per-PR benchmark CI workflow

Adds a bench/ suite (element creation, component mount depth,
attribute update at depth, keyed/unkeyed v-for reconciliation, and
unkeyed list grow/shrink) using pytest-benchmark with DictRenderer and
synchronous event loop, mirroring the setup in the sibling observ repo.

The new benchmark workflow runs the suite twice on every PR - once
against the master version of collagraph/ and once against the PR
version - and fails when mean time regresses more than 5%. The CI test
job is scoped to the tests directory so the matrix does not execute
benchmarks.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Disable GC during timed list-benchmark calls to reduce variance

The allocation burst of list reconciliation triggers collection pauses
in some rounds, which inflated stddev on the grow benchmarks to ~40%
of the mean - far too noisy for the 5% regression gate in CI.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Speed up mount path: cheap arity check, reuse first(), leaner emit

- weak(): read __code__.co_argcount instead of building a full
  inspect.Signature for every wrapped watcher callback; this runs for
  every dynamic bind during create/mount.
- ComponentFragment.mount(): use the existing first() helper to resolve
  the component root element instead of a hand-rolled BFS with a
  per-mount deque import. Adds a regression test for a component whose
  root element sits behind a v-if wrapper.
- Component.emit(): avoid creating defaultdict entries for events that
  have no handlers and skip the set copy when empty.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Cache Fragment._component_parent() lookups

The parent-chain walk ran on every reactive attribute update (via
_set_attr/_rem_attr calling component.updated()) and on every ref
(un)registration, making update cost scale with fragment depth.

The result is now cached per fragment. The cache is invalidated in the
parent property setter, on unmount(destroy=True), and - via a new
recursive helper - after DynamicFragment._create_fragment_for_tag()
transfers live children to a new active fragment on a <component :is>
tag switch, which reassigns _parent directly and changes the owning
component of every transferred descendant.

Two regression tests cover the tag-switch reparenting: updated()
attribution and string-ref registration must follow the new owner.
Both fail when the invalidation hook is removed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Avoid redundant anchor lookups in Fragment.anchor() and unkeyed v-for

- anchor(): a membership check followed by .index() scanned the
  parent's children twice; use a single .index() in a try/except,
  for both children and slot_contents.
- Unkeyed ListFragment updates mounted every appended fragment with a
  freshly computed self.anchor(), which walks the tree per item even
  though the anchor (the first element after the list) cannot change
  while appending items from the list's own subtree. Compute it lazily
  once per update run, turning growth by n items from O(n^2) anchor
  work into O(n). Same hoist in ListFragment.mount().

Adds a regression test asserting that growing an unkeyed v-for with a
trailing sibling inserts elements in order, each anchored before that
sibling.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: berendkleinhaneveld

collagraph/fragment.py

@@ -145,22 +145,31 @@ def anchor(self) -> Any | None:
         assert parent is not None
 
         # Check if this fragment is in parent's children
-        if self in parent.children:
+        try:
             idx = parent.children.index(self)
+        except ValueError:
+            idx = None
+
+        if idx is not None:
             length = len(parent.children) - 1
             while 0 <= idx < length:
                 idx += 1
                 if element := parent.children[idx].first():
                     return element
         # Fragment might be slot content - check parent's slot_contents if it's
         # a ComponentFragment
-        elif isinstance(parent, ComponentFragment) and self in parent.slot_contents:
-            idx = parent.slot_contents.index(self)
-            length = len(parent.slot_contents) - 1
-            while 0 <= idx < length:
-                idx += 1
-                if element := parent.slot_contents[idx].first():
-                    return element
+        elif isinstance(parent, ComponentFragment):
+            try:
+                idx = parent.slot_contents.index(self)
+            except ValueError:
+                idx = None
+
+            if idx is not None:
+                length = len(parent.slot_contents) - 1
+                while 0 <= idx < length:
+                    idx += 1
+                    if element := parent.slot_contents[idx].first():
+                        return element
 
         # No sibling anchor found at this level. If the parent doesn't have
         # its own element (e.g., ComponentFragment, ControlFlowFragment), climb
@@ -706,11 +715,18 @@ def update_children(self):
                     fragment.unmount()
                     self.values.pop(index)
 
+                # The anchor is loop-invariant: it is the first element
+                # *after* this ListFragment, and the loop below only
+                # appends items from the list's own subtree before it.
+                # Computed lazily so update-only runs don't pay for it.
+                anchor = _UNSET
                 for i, item in enumerate(items):
                     if i < len(self.children):
                         # Update the content for existing values
                         self.values[i]["context"] = item
                     else:
+                        if anchor is _UNSET:
+                            anchor = self.anchor()
                         # Create a new fragment + context
                         context = reactive({"context": item})
                         self.values.append(context)
@@ -719,15 +735,18 @@ def update_children(self):
                         )
                         self.children.append(fragment)
                         fragment.parent = self
-                        fragment.mount(target, anchor=self.anchor())
+                        fragment.mount(target, anchor=anchor)
 
             # Then we add a watch_effect for the children
             # which adds/removes/updates all the child fragments
             self._watchers["list"] = watch_effect(update_children)
 
+        anchor = _UNSET
         for child in self.children:
             if not child.element:
-                child.mount(target, anchor=self.anchor())
+                if anchor is _UNSET:
+                    anchor = self.anchor()
+                child.mount(target, anchor=anchor)
 
         self._mounted = True
 

tests/test_directive_for.py

@@ -675,3 +675,50 @@ class Items(cg.Component):
     first_item, second_item = container["children"]
     assert first_item["attrs"]["value"] == "a"
     assert second_item["attrs"]["value"] == "b"
+
+
+def test_for_unkeyed_grow_insert_order(parse_source):
+    """
+    Growing an unkeyed v-for in one reactive update must insert the new
+    elements in order, each anchored before the element that follows the
+    list (regression test for hoisting the loop-invariant anchor out of
+    the append loop).
+    """
+    from tests.conftest import CustomElement, TrackingRenderer
+
+    App, _ = parse_source(
+        """
+        <template>
+          <node v-for="item in items" :content="item" />
+          <footer content="footer" />
+        </template>
+        <script>
+        import collagraph as cg
+        class App(cg.Component):
+            pass
+        </script>
+        """
+    )
+
+    renderer = TrackingRenderer()
+    gui = Collagraph(renderer, event_loop_type=EventLoopType.SYNC)
+    container = CustomElement(type="root")
+    state = reactive({"items": []})
+    gui.render(App, container, state)
+
+    renderer.reset_counters()
+    state["items"] = ["a", "b", "c"]
+
+    inserts = [op for op in renderer.operations if op[0] == "insert"]
+    assert inserts == [
+        ("insert", "a", "before footer"),
+        ("insert", "b", "before footer"),
+        ("insert", "c", "before footer"),
+    ]
+    assert [child.type for child in container.children] == [
+        "node",
+        "node",
+        "node",
+        "footer",
+    ]
+    assert [child.content for child in container.children[:3]] == ["a", "b", "c"]