Function celeryDispatchEdges

src/resolution/callback-synthesizer.ts:2564–2635

(ctx: ResolutionContext, onYield: MaybeYield)

const CELERY_DECORATOR_LOOKBACK = 12; // max lines above a `def` to scan for its decorators

async function celeryDispatchEdges(ctx: ResolutionContext, onYield: MaybeYield): Promise<Edge[]> {
  let scannedFiles = 0;
  // Memoize the decorator check per task-candidate node: it reads the file and scans a few
  // lines above the def. Only called on names that are actually `.delay`/`.apply_async`
  // receivers, so the candidate set stays small.
  const taskCache = new Map<string, boolean>();
  const isCeleryTask = (node: Node): boolean => {
    let v = taskCache.get(node.id);
    if (v !== undefined) return v;
    v = false;
    if (node.kind === 'function' && CELERY_PY_EXT.test(node.filePath)) {
      const content = ctx.readFile(node.filePath);
      if (content) {
        const lines = content.split('\n');
        // startLine is the `def` line (decorators sit ABOVE it). Walk upward, stopping at the
        // previous declaration so a non-task def can never inherit the prior def's decorator.
        const stop = Math.max(0, node.startLine - 1 - CELERY_DECORATOR_LOOKBACK);
        for (let i = node.startLine - 2; i >= stop; i--) {
          const t = (lines[i] ?? '').trim();
          if (/^(?:async\s+def|def|class)\b/.test(t)) break; // previous decl → stop
          if (CELERY_TASK_DECORATOR_RE.test(t)) { v = true; break; }
        }
      }
    }
    taskCache.set(node.id, v);
    return v;
  };

  const resolve = (name: string, dispatchFile: string): Node | null => {
    const cands = ctx.getNodesByName(name).filter((n) => n.kind === 'function' && isCeleryTask(n));
    if (!cands.length) return null;
    if (cands.length === 1) return cands[0]!;
    // Cross-module name collision: prefer a task defined in the dispatching file, else bail
    // (ambiguous — precision over recall, like vuex's root-key resolution).
    return cands.find((c) => c.filePath === dispatchFile) ?? null;
  };

  const edges: Edge[] = [];
  const seen = new Set<string>();
  for (const file of ctx.getAllFiles()) {
    if ((++scannedFiles & 15) === 0) await onYield();
    if (!CELERY_PY_EXT.test(file)) continue;
    const content = ctx.readFile(file);
    if (!content || (!content.includes('.delay(') && !content.includes('.apply_async('))) continue;
    const safe = stripCommentsForRegex(content, 'python');
    const nodesInFile = ctx.getNodesInFile(file);
    CELERY_DISPATCH_RE.lastIndex = 0;
    let m: RegExpExecArray | null;
    let added = 0;
    while ((m = CELERY_DISPATCH_RE.exec(safe)) && added < CELERY_FANOUT_CAP) {
      const name = m[1]!;
      const line = safe.slice(0, m.index).split('\n').length;
      const disp = enclosingFn(nodesInFile, line);
      if (!disp) continue; // module-level dispatch — no source symbol to attribute
      const target = resolve(name, file);
      if (!target || target.id === disp.id) continue;
      const key = `${disp.id}>${target.id}`;
      if (seen.has(key)) continue;