Function interfaceOverrideEdges

src/resolution/callback-synthesizer.ts:1043–1111

(queries: QueryBuilder, onYield: MaybeYield)

}

async function interfaceOverrideEdges(queries: QueryBuilder, onYield: MaybeYield): Promise<Edge[]> {
  let scanned255 = 0;
  const edges: Edge[] = [];
  const seen = new Set<string>();
  // Memoized: a popular base interface's method list is otherwise re-fetched
  // once per implementer (dubbo-style hub interfaces have hundreds), and the
  // memo only ever serves reads. Same rows, same order — byte-identical.
  const methodsMemo = new Map<string, Node[]>();
  const methodsOf = (classId: string): Node[] => {
    const hit = methodsMemo.get(classId);
    if (hit) return hit;
    const methods = queries
      .getOutgoingEdges(classId, ['contains'])
      .map((e) => queries.getNodeById(e.target))
      .filter((n): n is Node => !!n && n.kind === 'method');
    methodsMemo.set(classId, methods);
    return methods;
  };
  // Concrete-side kinds vary by language: `class` covers Java / Kotlin /
  // C# / TS / Swift-classes / Scala-classes; `struct` covers Swift value
  // types that conform to protocols. Iterate both.
  const concreteKinds = ['class', 'struct'] as const;
  for (const kind of concreteKinds) {
  for (const cls of queries.iterateNodesByKind(kind)) {
    if ((++scanned255 & 63) === 0) await onYield();
    // A class can only emit here if it HAS a supertype edge — check that
    // (one edge query) before materializing its methods: most classes in a
    // typical graph extend/implement nothing and skip in one hop.
    const sups = queries.getOutgoingEdges(cls.id, ['implements', 'extends']);
    if (sups.length === 0) continue;
    const implMethods = methodsOf(cls.id).filter((n) => IFACE_OVERRIDE_LANGS.has(n.language));
    if (implMethods.length === 0) continue;
    for (const sup of sups) {
      const base = queries.getNodeById(sup.target);
      if (!base || !IFACE_OVERRIDE_LANGS.has(base.language) || base.id === cls.id) continue;
      // Group impl methods by name to handle OVERLOADS: an interface `list()` and
      // `list(params)` are distinct nodes and a call may resolve to either, so
      // link every base overload → every same-name impl overload (keying by name
      // alone would drop all but one and miss the resolved overload).
      const implByName = new Map<string, Node[]>();
      for (const m of implMethods) {
        const arr = implByName.get(m.name);
        if (arr) arr.push(m); else implByName.set(m.name, [m]);
      }
      let added = 0;
      for (const bm of methodsOf(base.id)) {
        if (added >= MAX_CALLBACKS_PER_CHANNEL) break;
        for (const m of implByName.get(bm.name) ?? []) {
          if (added >= MAX_CALLBACKS_PER_CHANNEL) break;
          if (bm.id === m.id) continue;
          const key = `${bm.id}>${m.id}`;
          if (seen.has(key)) continue;
          seen.add(key);
          edges.push({
            source: bm.id,
            target: m.id,
            kind: 'calls',
            line: bm.startLine,