Function closureCollectionEdges

src/resolution/callback-synthesizer.ts:252–326

* Closure-collection dispatch: dispatcher iterates a closure-collection property * invoking each element; registrar appends a closure to the same-named property. * Emits dispatcher → registrar so a flow reaches the registration site (where the * appended closure's body — and its callers — live).

(queries: QueryBuilder, ctx: ResolutionContext, onYield: MaybeYield)

 * name shared across unrelated classes can't fan out into noise.
 */
async function closureCollectionEdges(queries: QueryBuilder, ctx: ResolutionContext, onYield: MaybeYield): Promise<Edge[]> {
  const dispatchers = new Map<string, Array<{ node: Node; line: number }>>(); // field → dispatcher methods + forEach line
  const registrars = new Map<string, Array<{ node: Node; line: number }>>();   // field → registrar methods + append line

  const addReg = (field: string | undefined, node: Node, absLine: number) => {
    if (!field || /^\d+$/.test(field)) return; // `$0.append` mis-captures the `0`; the write-RE owns that field
    const arr = registrars.get(field) ?? [];
    if (!arr.some((r) => r.node.id === node.id)) arr.push({ node, line: absLine });
    registrars.set(field, arr);
  };

  // Slices EVERY Swift/Kotlin method/function's source (no cheap name-gate), so
  // on a repo with a huge file this is the heaviest synthesis pass — yield
  // mid-scan (and mid-match-loop below: a single generated function dense with
  // matches must not starve the watchdog either) so it can't wedge the #850
  // watchdog on its own (#1091, #1235).
  let scanned = 0;
  let matchTick = 0;
  for (const m of methodAndFunctionNodes(queries)) {
    if ((++scanned & 127) === 0) await onYield();
    if (!CC_LANGUAGES.has(m.language)) continue;
    const content = ctx.readFile(m.filePath);
    const src = content && sliceLines(content, m.startLine, m.endLine);
    if (!src) continue;
    const hasForEach = src.includes('.forEach');
    const hasAppend = src.includes('.append(') || src.includes('.add(') || src.includes('.push(') || src.includes('.insert(');
    if (!hasForEach && !hasAppend) continue;
    const lineAt = makeLineAt(src, m.startLine ?? 1);

    if (hasForEach) {
      CC_DISPATCH_RE.lastIndex = 0;
      let d: RegExpExecArray | null;
      while ((d = CC_DISPATCH_RE.exec(src))) {
        if ((++matchTick & 255) === 0) await onYield();
        const arr = dispatchers.get(d[1]!) ?? [];
        if (!arr.some((n) => n.node.id === m.id)) arr.push({ node: m, line: lineAt(d.index) });
        dispatchers.set(d[1]!, arr);
      }
    }
    if (hasAppend) {
      CC_APPEND_WRITE_RE.lastIndex = 0;
      let w: RegExpExecArray | null;
      while ((w = CC_APPEND_WRITE_RE.exec(src))) {
        if ((++matchTick & 255) === 0) await onYield();
        addReg(w[2] || w[1], m, lineAt(w.index)); // nested `$0.streams` else the `.write` receiver
      }
      CC_APPEND_DIRECT_RE.lastIndex = 0;
      let a: RegExpExecArray | null;
      while ((a = CC_APPEND_DIRECT_RE.exec(src))) {
        if ((++matchTick & 255) === 0) await onYield();
        addReg(a[1], m, lineAt(a.index));
      }
    }
  }

  const edges: Edge[] = [];
  const seen = new Set<string>();
  for (const [field, disps] of dispatchers) {