perf(go): order the body-node owner candidates once, not per lookup

split_body_node_id sorted every callable id on every call, and
_body_source_of calls it once per get_source of a body-node id -- so a bulk
get_source over a page's endpoints sorted 5,955 ids per endpoint on
nats-server. The order is a property of the application, not of the node being
looked up.

longest_first() now produces it and the backend caches it in
_owner_ids_longest_first. Ties break on the id, so the order is total and a
lookup is reproducible rather than dependent on dict iteration.

Found evaluating against the analyzer's real-app corpus.

Refs #436

Author: sinha108

cldk/analysis/go/codeanalyzer/codeanalyzer.py

@@ -68,7 +68,7 @@
     VIA,
     GoAnalysisBackend,
 )
-from cldk.analysis.go.ids import body_node_id, callable_match_names, external_signature, go_value_names, pick_declaration, split_body_node_id
+from cldk.analysis.go.ids import body_node_id, callable_match_names, external_signature, go_value_names, longest_first, pick_declaration, split_body_node_id
 from cldk.models.go import (
     GoAnalysis,
     GoApplication,
@@ -372,6 +372,16 @@ def get_source(self, node_id: str) -> str:
             self._module_bytes[mod.id] = encoded
         return encoded[b0:b1].decode("utf-8")
 
+    @cached_property
+    def _owner_ids_longest_first(self) -> Tuple[str, ...]:
+        """Every owner id, longest first — the candidate order a body-node id is split against.
+
+        Cached because the order is a property of the application, not of the node being looked up:
+        computing it inside the lookup sorted 5,955 ids on every ``get_source`` of a body-node id
+        on nats-server.
+        """
+        return longest_first(self._dataflow_owners)
+
     def _body_source_of(self, node_id: str) -> "tuple | None":
         """``(module, body node)`` for a body-node id, or ``None`` if nothing owns it.
 
@@ -380,11 +390,15 @@ def _body_source_of(self, node_id: str) -> "tuple | None":
         vertex ``@``. A stand-in has no module and so no text, which this reports as "not found"
         rather than as a module lookup that would fail further on.
 
-        Not indexed eagerly: the body-node ids outnumber the durable ones by a wide margin (3,324
-        against 319 on the analyzer's own corpus), and ``get_source`` on one is the uncommon case,
+        Not indexed eagerly: the body-node ids outnumber the durable ones by a wide margin (1.69
+        **million** against 5,955 on nats-server), and ``get_source`` on one is the uncommon case,
         so the prefix walk is paid per call instead of the index being paid per application.
+
+        The *candidate order*, though, is paid once — :attr:`_owner_ids_longest_first`. It used to
+        be sorted inside the lookup, which made a bulk ``get_source`` over a page's endpoints sort
+        every callable id per endpoint.
         """
-        hit = split_body_node_id(node_id, self._dataflow_owners)
+        hit = split_body_node_id(node_id, self._owner_ids_longest_first)
         if hit is None:
             return None
         cid, key = hit

cldk/analysis/go/ids.py

@@ -52,6 +52,20 @@ def body_node_id(callable_id: str, body_key: str) -> str:
     return f"{callable_id}{body_key}" if body_key.startswith("@") else f"{callable_id}@{body_key}"
 
 
+def longest_first(callable_ids: Iterable[str]) -> Tuple[str, ...]:
+    """``callable_ids`` ordered longest first — the order :func:`split_body_node_id` needs.
+
+    Longest first because a callable id can be a proper prefix of a nested closure's
+    (``…flow.Closure`` and ``…flow.Closure.closure_1``), so the shorter would otherwise claim the
+    longer's vertices. Ties are broken by the id itself, so the order is total and a lookup is
+    reproducible rather than dependent on dict iteration.
+
+    Separate from the lookup so a backend computes it **once** per application instead of once per
+    node: see :func:`split_body_node_id`'s ``callable_ids``.
+    """
+    return tuple(sorted(callable_ids, key=lambda cid: (-len(cid), cid)))
+
+
 def split_body_node_id(node_id: str, callable_ids: Iterable[str]) -> Tuple[str, str] | None:
     """``(callable id, body key)`` for ``node_id``, or ``None`` if no known callable owns it.
 
@@ -72,15 +86,18 @@ def split_body_node_id(node_id: str, callable_ids: Iterable[str]) -> Tuple[str,
 
     Args:
         node_id: A body node's absolute ``can://`` id.
-        callable_ids: Every callable id in the application, stand-ins included. Order is
-            irrelevant; this sorts.
+        callable_ids: Every callable id in the application, stand-ins included, **already ordered
+            longest first** — :func:`longest_first` is what produces that order, and a backend
+            should compute it once rather than per call. Sorting here instead cost a sort of every
+            callable id on every lookup, which on nats-server (5,955 callables) made a bulk
+            ``get_source`` over a page's endpoints quadratic; the eval surfaced it.
 
     Returns:
         ``(callable_id, body_key)`` where ``body_node_id(*result) == node_id``, or ``None`` when no
         candidate owns it — a miss is returned, not raised, because the callers here are describing
         a walk's nodes and an unknown node is a node to skip, not an error to propagate.
     """
-    for cid in sorted(callable_ids, key=len, reverse=True):
+    for cid in callable_ids:
         if not node_id.startswith(cid) or node_id == cid:
             continue
         rest = node_id[len(cid) :]