Method getImpactRecursive

src/graph/traversal.ts:543–607

(
    nodeId: string,
    maxDepth: number,
    currentDepth: number,
    nodes: Map<string, Node>,
    edges: Edge[],
    visited: Set<string>
  )

  }

  private getImpactRecursive(
    nodeId: string,
    maxDepth: number,
    currentDepth: number,
    nodes: Map<string, Node>,
    edges: Edge[],
    visited: Set<string>
  ): void {
    // Mark visited before the depth check so a node collected at the depth
    // boundary still lands in `visited`. Otherwise it could sit in `nodes` but
    // not `visited`, and the two loops below — which used different sets to
    // gate re-processing — would disagree about it (#1089).
    if (visited.has(nodeId)) {
      return;
    }
    visited.add(nodeId);
    if (currentDepth >= maxDepth) {
      return;
    }

    // For container nodes (classes, interfaces, structs, etc.), also traverse
    // into their children so that callers of contained methods appear in impact
    const focalNode = this.queries.getNodeById(nodeId);
    if (focalNode) {
      const containerKinds = new Set(['class', 'interface', 'struct', 'trait', 'protocol', 'module', 'enum']);
      if (containerKinds.has(focalNode.kind)) {
        const containsEdges = this.queries.getOutgoingEdges(nodeId, ['contains']);
        if (containsEdges.length > 0) {
          const children = this.queries.getNodesByIds(containsEdges.map((e) => e.target));
          for (const edge of containsEdges) {
            const childNode = children.get(edge.target);
            if (childNode && !visited.has(childNode.id)) {
              nodes.set(childNode.id, childNode);
              edges.push(edge);
              // Recurse into children at the same depth (they're part of the same symbol)
              this.getImpactRecursive(childNode.id, maxDepth, currentDepth, nodes, edges, visited);
            }
          }
        }
      }
    }

    // Get all incoming edges (things that depend on this node). Exclude
    // `contains`: a container "contains" its members but does not *depend* on
    // them, so following it upward would climb to the parent class and then
    // re-expand every sibling member — exploding impact for a leaf symbol. (#536)
    const incomingEdges = this.queries.getIncomingEdges(nodeId).filter((e) => e.kind !== 'contains');
    if (incomingEdges.length === 0) return;
    const sources = this.queries.getNodesByIds(incomingEdges.map((e) => e.source));

    for (const edge of incomingEdges) {
      const sourceNode = sources.get(edge.source);
      if (!sourceNode) continue;
      // Record the dependency edge unconditionally. The gate used to also gate
      // edge collection (`!nodes.has(...)`), so a second incoming edge into a
      // node already collected via another path was silently dropped from
      // `edges` even though it's a real dependency (#1089). Each node's incoming
      // edges are fetched once (nodes are expanded once), so no edge repeats.