Method flushValueRefs

src/extraction/tree-sitter.ts:783–937

* Emit same-file `references` edges from a symbol to the file-scope const/var it reads (TS/JS). * The engine doesn't edge const→consumer, so impact analysis misses "change this table, affect * its readers" (the ReScript-PR false positive). Same-file only (resolution is unambiguous), * disti

()

   * additive. Shadowed targets are pruned — see below.
   */
  private flushValueRefs(): void {
    const scopes = this.valueRefScopes;
    const targets = this.fileScopeValues;
    const fileScopeCounts = this.fileScopeValueCounts;
    this.valueRefScopes = [];
    this.fileScopeValues = new Map();
    this.fileScopeValueCounts = new Map();
    if (!this.valueRefsEnabled || !TreeSitterExtractor.VALUE_REF_LANGS.has(this.language)) return;
    if (targets.size === 0 || scopes.length === 0 || isGeneratedFile(this.filePath)) return;

    // Prune SHADOWED targets. A target re-bound in an INNER scope (a
    // bundled/Emscripten `const Module` re-declared as a nested `var Module`; a
    // Go package `const Timeout` shadowed by a local `Timeout := …`; a Python
    // module `CONFIG` shadowed by a local `CONFIG = …`) resolves to the inner
    // binding for nested readers, so a file-scope edge is a false positive.
    // Inner re-bindings aren't graph nodes, so detect them at the syntax level:
    // count every declarator of the name across the tree and compare against how
    // many FILE-SCOPE nodes carry it. A real shadow makes (declarators >
    // file-scope nodes) — the excess is the local binding. A conditional
    // module-level def (`try: X = a; except: X = b`) makes them EQUAL (both
    // declarators are file-scope nodes), so it's correctly kept. Complements the
    // path-based isGeneratedFile() check, which can't catch content-minified
    // bundles.
    //
    // Declarator node types are per-grammar; a file only contains its own
    // language's nodes, so matching all of them in one switch is safe.
    if (this.tree) {
      const declCounts = new Map<string, number>();
      const bump = (nameNode: SyntaxNode | null) => {
        // `simple_identifier` is Kotlin's name node (a property declarator's name).
        if (nameNode && (nameNode.type === 'identifier' || nameNode.type === 'simple_identifier')) {
          const nm = getNodeText(nameNode, this.source);
          if (targets.has(nm)) declCounts.set(nm, (declCounts.get(nm) ?? 0) + 1);
        }
      };
      const dstack: SyntaxNode[] = [this.tree.rootNode];
      let dvisited = 0;
      while (dstack.length > 0 && dvisited < TreeSitterExtractor.MAX_VALUE_REF_NODES) {
        const n = dstack.pop()!;
        dvisited++;
        switch (n.type) {
          case 'variable_declarator': // TS/JS/tsx
          case 'const_spec':          // Go  `const X = …`
          case 'var_spec':            // Go  `var X = …`
            bump(n.namedChild(0));
            break;
          case 'const_item':          // Rust  `const X: T = …`
          case 'static_item':         // Rust  `static X: T = …`
            bump(getChildByField(n, 'name'));
            break;
          case 'let_declaration':       // Rust  `let x = …` (locals — the shadow source)
          case 'short_var_declaration': // Go    `x, Y := …`
          case 'assignment': {          // Python `X = …` / `X: T = …` / `A, B = …`
            const left = getChildByField(n, 'left') ?? getChildByField(n, 'pattern') ?? n.namedChild(0);
            if (left?.type === 'identifier') bump(left);
            else if (left) for (const c of left.namedChildren) bump(c);
            break;
          }