Function sidekiqDispatchEdges

src/resolution/callback-synthesizer.ts:2896–2966

(ctx: ResolutionContext, onYield: MaybeYield)

const SIDEKIQ_FANOUT_CAP = 80;

async function sidekiqDispatchEdges(ctx: ResolutionContext, onYield: MaybeYield): Promise<Edge[]> {
  let scannedFiles = 0;
  // class node id → its instance `perform` method (null if the class isn't a Sidekiq worker),
  // memoized. Reads the class body for the mixin; only consulted for actual dispatch receivers.
  const performCache = new Map<string, Node | null>();
  const performOf = (cls: Node): Node | null => {
    let v = performCache.get(cls.id);
    if (v !== undefined) return v;
    v = null;
    const content = ctx.readFile(cls.filePath);
    if (content) {
      const end = cls.endLine ?? cls.startLine;
      const body = content.split('\n').slice(cls.startLine - 1, end).join('\n');
      if (SIDEKIQ_WORKER_RE.test(body)) {
        v = ctx.getNodesInFile(cls.filePath).find(
          (n) => n.kind === 'method' && n.name === 'perform' && n.startLine >= cls.startLine && n.startLine <= end
        ) ?? null;
      }
    }
    performCache.set(cls.id, v);
    return v;
  };

  // Resolve a (possibly namespaced) worker reference to its `perform`. A namespaced ref is
  // matched by EXACT qualified name first, so same-named workers in different namespaces
  // (forem has four `SendEmailNotificationWorker`s) resolve to the right one; an unqualified
  // ref falls back to the simple name and links only when a single worker bears it — an
  // ambiguous collision bails (precision over recall).
  const resolve = (ref: string): Node | null => {
    if (ref.includes('::')) {
      const q = ctx.getNodesByQualifiedName(ref).find((n) => n.kind === 'class' && performOf(n));
      if (q) return performOf(q);
    }
    const workers = ctx.getNodesByName(ref.split('::').pop()!).filter((n) => n.kind === 'class' && performOf(n));
    return workers.length === 1 ? performOf(workers[0]!) : null;
  };

  const edges: Edge[] = [];
  const seen = new Set<string>();
  for (const file of ctx.getAllFiles()) {
    if ((++scannedFiles & 15) === 0) await onYield();
    if (!SIDEKIQ_RB_EXT.test(file)) continue;
    const content = ctx.readFile(file);
    if (!content || !/\.perform_(?:async|in|at)\b/.test(content)) continue;
    const safe = stripCommentsForRegex(content, 'ruby');
    const nodesInFile = ctx.getNodesInFile(file);
    SIDEKIQ_DISPATCH_RE.lastIndex = 0;
    let m: RegExpExecArray | null;
    let added = 0;
    while ((m = SIDEKIQ_DISPATCH_RE.exec(safe)) && added < SIDEKIQ_FANOUT_CAP) {
      const line = safe.slice(0, m.index).split('\n').length;
      const disp = enclosingFn(nodesInFile, line);
      if (!disp) continue;
      const target = resolve(m[1]!);
      if (!target || target.id === disp.id) continue;
      const key = `${disp.id}>${target.id}`;
      if (seen.has(key)) continue;
      seen.add(key);