gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

package/dist/core/ingestion/languages/typescript/captures.js

@@ -6,7 +6,7 @@
  * synthesized streams on top:
  *
  *   1. **Import decomposition** — each `import_statement` / re-export is
- *      re-emitted with `@import.kind/source/name/alias/typeOnly` markers so
+ *      re-emitted with `@import.kind/source/name/alias/type-only` markers so
  *      `interpretTsImport` can recover the `ParsedImport` shape without
  *      re-parsing raw text (see `import-decomposer.ts`). Unit 2 adds this;
  *      until then, raw `@import.statement` matches flow through as-is.
@@ -31,13 +31,18 @@ import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { synthesizeTsReceiverBinding } from './receiver-binding.js';
 import { computeTsArityMetadata } from './arity-metadata.js';
 import { isArrayMethodCallbackArrow } from './array-callback.js';
+import { isShadowedCjsExportAssignment, isUnexportedMemberAssignmentValue, isUndeclarableThisMemberValue, } from './cjs-export-assignment.js';
+import { hasKeyword } from '../../field-extractors/configs/helpers.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { synthesizeCjsModuleExports } from './cjs-module-exports.js';
+import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 import { deriveDefaultExportHocName, isBlockedDefaultExportHoc, isDefaultExportHocFunctionNode, } from '../../ts-js-hoc-utils.js';
 /** tree-sitter-typescript node types for function-like scopes that may
  *  carry a synthesized `this` binding. Kept in sync with the
  *  `@scope.function` patterns in `query.ts`. */
-const FUNCTION_NODE_TYPES = [
+export const FUNCTION_NODE_TYPES = [
     'method_definition',
     'method_signature',
     'abstract_method_signature',
@@ -45,8 +50,47 @@ const FUNCTION_NODE_TYPES = [
     'function_expression',
     'function_declaration',
     'generator_function_declaration',
+    // The EXPRESSION form (`const g = function* () {}`). Both queries capture it
+    // as `@scope.function`, and both `this`-boundary lists already carry it, but
+    // this list did not — so callable-flow synthesis and the body-block filter
+    // treated a generator expression as a non-function.
+    //
+    // Measured: adding it changes no graph output today. A generator-expression
+    // binding still emits a `Const` node rather than a `Function` one, so the
+    // call never resolves either way — that label comes from the definition
+    // rules, not from here, and closing it is a separate change. This entry is
+    // list consistency, enforced by
+    // `test/unit/ts-js-function-node-type-lists.test.ts`.
+    'generator_function',
     'function_signature',
 ];
+/** Nodes whose `statement_block` child is their BODY, not a nested block.
+ *  Such a block duplicates the enclosing Function scope — see the emit-side
+ *  filter in `emitTsScopeCaptures`. */
+const FUNCTION_BODY_OWNER_TYPES = new Set(FUNCTION_NODE_TYPES);
+/** Direct-child node types that create a BINDING in their enclosing block.
+ *  `variable_declaration` (`var`) is deliberately absent: it hoists past the
+ *  block to the function, so a block containing only `var` binds nothing. */
+const BLOCK_BINDING_CHILD_TYPES = new Set([
+    'lexical_declaration',
+    'class_declaration',
+    'function_declaration',
+    'generator_function_declaration',
+]);
+/** True when `block` directly declares a name, i.e. it is a real environment
+ *  record rather than punctuation. A block that binds nothing is transparent to
+ *  every scope-chain walk — a lookup finds nothing in it and continues to the
+ *  parent — so emitting a scope for it costs tree size and walk depth and buys
+ *  exactly nothing. Only DIRECT children count: a declaration in a nested block
+ *  belongs to that block, which gets its own scope by the same rule. */
+const blockDeclaresBinding = (block) => {
+    for (let i = 0; i < block.namedChildCount; i++) {
+        const child = block.namedChild(i);
+        if (child !== null && BLOCK_BINDING_CHILD_TYPES.has(child.type))
+            return true;
+    }
+    return false;
+};
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.function'];
 /** Callsite anchors that should carry `@reference.arity` + param types. */
@@ -55,6 +99,25 @@ const CALL_TAGS = [
     '@reference.call.member',
     '@reference.call.constructor',
 ];
+const TS_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(FUNCTION_NODE_TYPES),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['formal_parameters', 'arguments']),
+    parameterNodeTypes: new Set([
+        'required_parameter',
+        'optional_parameter',
+        'rest_pattern',
+        'identifier',
+    ]),
+    bindingNodeTypes: new Set(['variable_declarator']),
+    assignmentNodeTypes: new Set(['assignment_expression', 'augmented_assignment_expression']),
+    identifierNodeTypes: new Set([
+        'identifier',
+        'property_identifier',
+        'shorthand_property_identifier_pattern',
+        'private_property_identifier',
+    ]),
+};
 function pickFirstCapture(grouped, tags) {
     for (const tag of tags) {
         const cap = grouped[tag];
@@ -112,6 +175,131 @@ function shouldEmitReadMember(memberNode) {
             return true;
     }
 }
+/**
+ * Is this `(this)` node the `this` of a STATIC method?
+ *
+ * `this` in a static method is the class object, so `this.x = new Y()` there
+ * assigns a STATIC property and must never type the instance field of the same
+ * name (#2807). Every other context that rebinds `this` is excluded
+ * structurally, by the query's `class_body → method_definition →
+ * statement_block → expression_statement` nesting; `static` is the one
+ * constraint tree-sitter cannot carry, because it is an ANONYMOUS token with no
+ * field name and patterns cannot negate one.
+ *
+ * The caller only reaches here for a capture the query already pinned inside a
+ * class method, so the `method_definition` lookup is a short walk. Detection is
+ * the shared `hasKeyword`, which is what the TypeScript METHOD EXTRACTOR already
+ * uses to decide the same question — matching on child TEXT, and skipping the
+ * `name` field so a method literally called `static()` is not misread.
+ *
+ * Text, not node type: `static` reaches the tree as an anonymous token in some
+ * grammar versions and as a keyword node in others (see `isStaticMember` in
+ * `receiver-binding.ts`), so a `child.type === 'static'` test silently stops
+ * firing on a grammar bump and every static `this.x = new Y()` starts typing the
+ * instance field of that name. `hasKeyword` scans the whole `method_definition`
+ * rather than stopping at the name, which is safe here because a
+ * `method_definition`'s own children are its modifiers, name, parameters and
+ * body — a mention of `static` inside the BODY is a descendant of the body node,
+ * never a direct child.
+ */
+function isStaticMethodThis(thisNode) {
+    const method = findSelfOrAncestorOfType(thisNode, 'method_definition');
+    if (method === null)
+        return false;
+    return hasKeyword(method, 'static');
+}
+/** The class-field declaration node a field `@type-binding.*` match anchors on
+ *  in TypeScript/TSX. JavaScript spells the same construct `field_definition`
+ *  and passes its own set in — the predicate below is shared because both
+ *  grammars carry `static` identically, but each language must NAME its own
+ *  node type. Listing both here made `field_definition` a dead literal in the
+ *  typescript grammar, which `grammar-literal-validation` fails on: the gate
+ *  checks every literal against the grammar of the FILE it appears in, and a
+ *  node type that is dead there is exactly how a guard silently stops firing. */
+export const TS_CLASS_FIELD_DEFINITION_TYPES = new Set([
+    'public_field_definition',
+]);
+/**
+ * Is this type-binding anchored on a **`static`** class field?
+ *
+ * A static member belongs to the CLASS OBJECT; an instance field belongs to
+ * instances. JavaScript and TypeScript keep the two in separate namespaces, so
+ * one class may legally declare both under one name:
+ *
+ *     class Host {
+ *       p = new Right();
+ *       static p = new Wrong();      // legal — a different member
+ *       hit() { return this.p.hit(); }   // `this.p` is Right
+ *     }
+ *
+ * Both field patterns anchor their binding on the same CLASS scope with the
+ * same `constructor-inferred` source, and `scope-extractor` breaks a
+ * same-strength tie with `>=` — last match wins. So the static field silently
+ * RETYPED the instance field of that name and `this.p.hit()` resolved to
+ * `Wrong.hit`: not a missing edge but a wrong one, the failure mode
+ * `scope-resolution/passes/compound-receiver.ts` exists to avoid. The scope
+ * tree has one `typeBindings` map per scope with no static/instance split, so a
+ * static field cannot be recorded separately — it is dropped instead.
+ *
+ * WHAT THAT COSTS, MEASURED rather than assumed (#2807 review, S7). An earlier
+ * version of this comment called the cost "a missed edge beats a wrong one".
+ * Only half of that is true, and the false half is the one that matters:
+ *
+ *   shape                       with the drop     without it
+ *   --------------------------  ----------------  ----------------
+ *   `this.p` (instance twin)    Right  ✓          Wrong  ✗
+ *   `Host.p` (static twin)      Right  ✗ WRONG    Wrong  ✓
+ *   `Host.q` (static, no twin)  — none, missed    Wrong  ✓
+ *
+ * For a class declaring BOTH twins the wrong edge does not disappear, it MOVES:
+ * `Host.p` now reads the INSTANCE twin's binding, because that is what is left
+ * in the map under that name. Only the no-twin case — the common static shape —
+ * is a true missed edge.
+ *
+ * The trade is still the right one, since `this.p` is overwhelmingly the more
+ * common access and a `Host.p` static chain is the cheaper place to be wrong.
+ * It is recorded here as a wrong edge rather than described as a missing one so
+ * that the next person weighing it is weighing the real thing. Closing it
+ * properly needs a static/instance split that the shared receiver fold cannot
+ * express today — `foldReceiverChain` in
+ * `scope-resolution/passes/compound-receiver.ts` explicitly discards whether a
+ * chain's base was a class reference or a value — so it is a separate change
+ * with a `SCHEMA_BUMP`, not a tweak here. Both shapes are pinned by rows in
+ * `test/integration/resolvers/inferred-field-receiver-matrix.test.ts`
+ * (`static-read-of-a-same-name-twin-picks-up-the-instance-type`,
+ * `static-read-without-a-twin-loses-its-type`), so the cost moves visibly.
+ *
+ * Sibling of {@link isStaticMethodThis}, which drops the ASSIGNMENT form
+ * (`this.x = new Y()` inside a static method). Together they cover both ways a
+ * static member can reach the field-typing path. This is an emit-side filter
+ * for the same reason that one is: `static` is an ANONYMOUS token on the
+ * declaration node, and a tree-sitter pattern cannot negate one.
+ *
+ * Detection is the shared `hasKeyword` — matching on child TEXT, never
+ * `child.type === 'static'`, because the token reaches the tree as an anonymous
+ * token in some grammar versions and a keyword node in others (see
+ * `isStaticMember` in `receiver-binding.ts`); a node-type test silently stops
+ * firing on a grammar bump and every static field starts retyping its instance
+ * twin again. Verified against both grammars in use here: `static` is an
+ * anonymous direct child of the caller's field-definition node —
+ * `public_field_definition` in TypeScript, `field_definition` in JavaScript —
+ * ahead of the name. Each language passes its OWN node-type set rather than the
+ * predicate holding both: a literal is only valid in the grammar of the file it
+ * appears in, and `grammar-literal-validation` fails a dead one.
+ *
+ * One deliberate over-fire: `hasKeyword` skips the node's `name` FIELD, and the
+ * JavaScript grammar names a field's name `property:`, not `name:` — so the
+ * legal-but-rare JavaScript field literally called `static`
+ * (`class C { static = new Right(); }`) reads as static and goes untyped. That
+ * is a declined binding, the safe direction of the same trade.
+ */
+export function isStaticClassFieldBinding(anchorNode, fieldDefinitionTypes) {
+    if (anchorNode === undefined)
+        return false;
+    if (!fieldDefinitionTypes.has(anchorNode.type))
+        return false;
+    return hasKeyword(anchorNode, 'static');
+}
 /** Walks the parent chain from `node` (inclusive), returning the first node
  *  whose type matches, or null. Faster than `findNodeAtRange` when the caller
  *  already holds the anchor node — avoids re-scanning the tree from the root. */
@@ -219,6 +407,24 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
             }
             continue;
         }
+        // A `statement_block` that IS a function body adds nothing: the enclosing
+        // Function scope already provides that environment record, so emitting one
+        // here just puts a redundant level inside EVERY function for every
+        // scope-chain walk to step through. Measured on a 762-file TypeScript
+        // corpus, keeping them cost ~6% of total analyze wall time; dropping them
+        // keeps the block scopes that matter (if/else/for/while/try/bare blocks,
+        // where `let`/`const` genuinely shadow) at no measurable cost.
+        //
+        // Semantically safe: nothing can be declared between a function and its
+        // own body, so a binding in either resolves identically.
+        if (grouped['@scope.block'] !== undefined) {
+            const blockNode = groupedNodes['@scope.block'];
+            const parentType = blockNode?.parent?.type;
+            if (parentType !== undefined && FUNCTION_BODY_OWNER_TYPES.has(parentType))
+                continue;
+            if (blockNode === undefined || !blockDeclaresBinding(blockNode))
+                continue;
+        }
         // Filter out `@reference.read.member` matches whose AST parent tells
         // us they are actually calls / writes / constructor invocations. The
         // tree-sitter pattern is context-free and matches every member_expression;
@@ -231,6 +437,27 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
                 continue;
             }
         }
+        // `this.<field> = new …` inside a STATIC method types a static property,
+        // not the instance field of the same name (#2807). Every other `this`-
+        // rebinding context is already excluded by the pattern's nesting — see the
+        // note on it in `query.ts`; `static` is an anonymous token, so no pattern
+        // can negate it and the last case is dropped here.
+        const thisFieldNode = groupedNodes['@type-binding.this-field'];
+        if (thisFieldNode !== undefined && isStaticMethodThis(thisFieldNode)) {
+            continue;
+        }
+        // …and a `static` FIELD is a member of the class object, not of instances,
+        // so it must not type the instance field of the same name either — see
+        // `isStaticClassFieldBinding`. Both class-field anchors are tested: the
+        // initializer form (`static p = new Wrong()`, `@type-binding.constructor`)
+        // and the annotated form (`static p: Wrong`, `@type-binding.annotation`),
+        // which collide on the Class scope the same way. The predicate self-gates on
+        // the anchor's node type, so the local `variable_declarator` patterns that
+        // share these tags are untouched.
+        if (isStaticClassFieldBinding(groupedNodes['@type-binding.constructor'], TS_CLASS_FIELD_DEFINITION_TYPES) ||
+            isStaticClassFieldBinding(groupedNodes['@type-binding.annotation'], TS_CLASS_FIELD_DEFINITION_TYPES)) {
+            continue;
+        }
         // #1876: drop @declaration.function for array higher-order-method
         // callbacks (`const x = arr.map(a => …)`). The HOC-wrapped-arrow
         // pattern matches them, but the binding holds a value, not a callable.
@@ -247,6 +474,27 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
             if (arrowNode !== null && isBlockedDefaultExportHoc(arrowNode)) {
                 continue;
             }
+            // #2723: a CJS export assignment must not register a SECOND module-scope
+            // declaration for a name the file already declares lexically — the name
+            // would become ambiguous and the resolver would drop the intra-module
+            // edge that resolved before #2723.
+            if (arrowNode !== null && isShadowedCjsExportAssignment(arrowNode, tree.rootNode)) {
+                continue;
+            }
+            // #2723 follow-up: the member-assignment rule matches ANY identifier
+            // receiver so an `exports` alias can be recognised. A receiver that is
+            // not the exports object declares nothing at module scope — drop it, or
+            // every `obj.handler = fn` would bind `handler` as a module symbol.
+            if (arrowNode !== null && isUnexportedMemberAssignmentValue(arrowNode, tree.rootNode)) {
+                continue;
+            }
+            // A `this.X = fn` declares a module symbol ONLY at the top level of a
+            // CommonJS file, where `this` is `module.exports`. Inside a function it
+            // is an instance member (a Method with an owner, no module binding), and
+            // in ESM top-level `this` is undefined and exports nothing.
+            if (arrowNode !== null && isUndeclarableThisMemberValue(arrowNode, tree.rootNode)) {
+                continue;
+            }
         }
         if (fnDeclAnchor !== undefined) {
             const fnNode = findFunctionNode(tree.rootNode, fnDeclAnchor.range, groupedNodes['@declaration.function']);
@@ -315,6 +563,12 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
                 grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', callNode, JSON.stringify(argTypes));
             }
         }
+        // Structural receiver chain for a call whose receiver is itself an
+        // expression, so resolution can type it by folding over structure
+        // instead of re-parsing the receiver's source text. Self-gating: a
+        // non-call match, an absent receiver, or a chain with no nameable base
+        // all leave `grouped` untouched.
+        synthesizeReceiverChainCapture(grouped, groupedNodes['@reference.receiver']);
         out.push(grouped);
         // Synthesize `this` receiver type-bindings on every function-like
         // scope that is structurally a class member. `receiver-binding.ts`
@@ -344,6 +598,12 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
     synthesizeForOfMapTupleBindings(tree.rootNode, out);
     synthesizeInstanceofNarrowings(tree.rootNode, out);
     synthesizeTsInheritanceReferences(tree.rootNode, out);
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, TS_CALLABLE_CAPTURE_OPTIONS));
+    // CommonJS module-export declarations (#2723). Shared with the JavaScript
+    // emitter: a `.ts` file in a CommonJS package uses the same forms, and
+    // without this the default-export NODE was emitted with nothing declaring it
+    // — the "found, zero callers" state this work exists to remove (#2729 F7).
+    synthesizeCjsModuleExports(tree.rootNode, filePath, out);
     return out;
 }
 /**
@@ -369,8 +629,12 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
  * matching arms (member_expression for extends, nested_type_identifier plain +
  * generic-wrapped for implements).
  *
- * `interface_declaration` / `abstract_class_declaration` heritage is NOT emitted
- * by the synth. The EXTENDS-vs-IMPLEMENTS split is decided downstream from the
+ * `interface_declaration` and `abstract_class_declaration` heritage IS emitted
+ * (#2842 review; both were silently skipped before, so `interface B extends A`
+ * and `abstract class X implements I` produced no edge and every dispatch walk
+ * dead-ended on a bodiless declaration). They reach their bases by different
+ * shapes: an abstract class carries the same `class_heritage` child a concrete
+ * one does, while an interface's bases hang off `extends_type_clause` directly. The EXTENDS-vs-IMPLEMENTS split is decided downstream from the
  * resolved target's symbol kind in `preEmitInheritanceEdges` (class-extends →
  * EXTENDS, implements-interface / interface-target → IMPLEMENTS), so all bases
  * are emitted with the same `inherits` kind here. The base lookup name is
@@ -387,7 +651,26 @@ function synthesizeTsInheritanceReferences(root, out) {
             if (child !== null)
                 stack.push(child);
         }
-        if (node.type !== 'class_declaration')
+        // `interface B extends A, C` hangs its bases off an `extends_type_clause`
+        // DIRECTLY on the interface — there is no `class_heritage` wrapper, so the
+        // class path below cannot reach them (#2842 review). The clause's `type`
+        // field is `multiple: true`, so `childForFieldName('type')` would silently
+        // return only `A` and drop `C`; iterate the named children instead.
+        if (node.type === 'interface_declaration') {
+            for (const child of node.namedChildren) {
+                if (child === null || child.type !== 'extends_type_clause')
+                    continue;
+                for (const base of child.namedChildren) {
+                    emitTsInheritanceBase(base, out);
+                }
+            }
+            continue;
+        }
+        // `abstract class X implements I` carries an identical `class_heritage`
+        // child, so the existing body handles it once the node type is admitted.
+        // Omitting it severed the only link between an interface and the concrete
+        // classes below an abstract base — a whole subtree, not a leaf.
+        if (node.type !== 'class_declaration' && node.type !== 'abstract_class_declaration')
             continue;
         // Find the `class_heritage` child (holds extends / implements clauses).
         let heritage = null;

package/dist/core/ingestion/languages/typescript/cjs-export-assignment.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Shadowed CommonJS export-assignment detection (issue #2723).
+ *
+ * The CJS declaration rules in the JS/TS scope queries bind the bare property
+ * name of `exports.X = function () {}` / `module.exports.X = (a) => a` into the
+ * enclosing module scope, so importers resolve to it by name. That is the whole
+ * point of #2723 — without it the graph node exists and nothing resolves to it.
+ *
+ * But a file may ALSO declare that same name lexically:
+ *
+ *   function dup(v) { return v; }
+ *   exports.dup = function (v) { return !v; };
+ *   function callIt(v) { return dup(v); }
+ *
+ * Then the module scope holds TWO declarations named `dup`, the name is
+ * ambiguous, and the resolver drops `callIt -> dup` altogether — an edge that
+ * resolved fine before #2723. A silently missing caller is worse than the gap
+ * #2723 set out to close, so the emitter drops the CJS declaration in exactly
+ * this case: the lexical declaration already supplies the module-scope name,
+ * so importers still resolve, and intra-module resolution is unchanged from
+ * before #2723.
+ *
+ * Only the `@declaration.function` match is suppressed. The graph node comes
+ * from a separate query (`tree-sitter-queries.ts`) and collapses onto the
+ * lexical declaration's node by name anyway, so no node is lost.
+ *
+ * Shared by both the JavaScript and TypeScript capture emitters — every
+ * grammar node named here (`assignment_expression`, `member_expression`,
+ * `property_identifier`, `function_declaration`, `lexical_declaration`,
+ * `variable_declaration`, `export_statement`) exists in both
+ * `tree-sitter-javascript` and `tree-sitter-typescript`.
+ *
+ * Pure given the input nodes. No I/O, no globals; the cache is keyed on the
+ * root node it derives from, so it cannot outlive its tree.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+/**
+ * True when `assignment` is a `this.X = <function>` at MODULE level — i.e. no
+ * `this`-binding function encloses it — inside a CommonJS module, which makes
+ * it an export of `X`.
+ *
+ * Arrow functions are transparent here: ECMA-262 gives an arrow
+ * `[[ThisMode]] = lexical`, so a top-level arrow's `this` is still the
+ * module's. Every other function form binds its own receiver and stops the
+ * walk — that is an instance member, handled as a Method instead.
+ */
+/**
+ * True when `assignment` is a `this.X = <callable>` at MODULE level, regardless
+ * of module system.
+ *
+ * Distinct from {@link isModuleLevelThisExport}, which additionally requires the
+ * file to be CommonJS. A module-level `this` member in ESM (or in a file with no
+ * module-system signal) is neither an export nor an instance member — `this` is
+ * `undefined` there — so it should produce nothing rather than an ownerless
+ * `Method` node (#2729 review F13).
+ */
+export declare function isModuleLevelThisAssignment(assignment: SyntaxNode): boolean;
+export declare function isModuleLevelThisExport(assignment: SyntaxNode, root: SyntaxNode, filePath?: string): boolean;
+/** The property name of a module-level `this.X = fn` export, or null. */
+export declare function moduleLevelThisExportName(assignment: SyntaxNode, root: SyntaxNode, filePath?: string): string | null;
+/**
+ * The name this assignment exports, or null when it exports nothing.
+ *
+ * Takes the VALUE node (the function literal) and the program root, because
+ * alias resolution is a whole-file question. Used by the capture emitters to
+ * keep the widened `<identifier>.X = fn` match only when the receiver really
+ * is the exports object.
+ */
+export declare function cjsExportedNameFor(node: SyntaxNode, root: SyntaxNode): string | null;
+/**
+ * True when `node` is the value of a `this.X = fn` assignment that declares
+ * NOTHING at module scope — either because a function encloses it (an instance
+ * member, which gets a Method + owner edge instead) or because the file is not
+ * CommonJS (top-level `this` is undefined in ESM).
+ */
+export declare function isUndeclarableThisMemberValue(node: SyntaxNode, root: SyntaxNode): boolean;
+/**
+ * True when `node` is the value of a `<identifier>.<member> = fn` assignment
+ * whose receiver is NOT the exports object — the over-match the widened
+ * member-assignment rule accepts so an `exports` alias can be recognised.
+ *
+ * Such a receiver declares nothing at module scope: `obj.handler = fn` binds a
+ * property of `obj`, not a module symbol named `handler`. Prototype and `this`
+ * receivers are not identifiers, so they never reach this guard and keep their
+ * own (Method) treatment.
+ */
+export declare function isUnexportedMemberAssignmentValue(node: SyntaxNode, root: SyntaxNode): boolean;
+/**
+ * True when `node` (an `arrow_function` / `function_expression` /
+ * `generator_function`) is the value of a CJS export assignment whose property
+ * name is ALREADY declared at module scope of `root`.
+ *
+ * False for a CJS export whose name is declared only by the assignment (the
+ * ordinary #2723 case — the declaration must be emitted), and false for
+ * anything that is not a CJS export assignment at all.
+ */
+export declare function isShadowedCjsExportAssignment(node: SyntaxNode, root: SyntaxNode): boolean;
+/**
+ * The module-scope name this assignment value exports, across EVERY export
+ * form — direct `exports.X`, `module.exports.X`, an alias receiver, a
+ * module-level `this.X`, and the anonymous/named default export.
+ *
+ * One entry point so the shadow guard cannot silently miss a form. Previously
+ * it consulted only the direct path: the alias path was skipped because `root`
+ * was not forwarded, `this` never reached it at all, and the default export had
+ * no check — three holes that each dropped a real call edge or, for the
+ * default, fabricated a self-recursive one (#2729 review F3/F4).
+ */
+export declare function cjsExportedName(value: SyntaxNode, root: SyntaxNode): string | null;
+/**
+ * True when the DERIVED default-export name collides with a callable the module
+ * already declares.
+ *
+ * `format.js` containing `function format() {}` plus an anonymous
+ * `module.exports = function () { return format(v); }` merged both onto one
+ * node, and the inner call to `format` then resolved to the merged node —
+ * fabricating a self-recursion edge present in no source (#2729 review F4).
+ * A fabricated edge is worse than a missing one: it misleads `impact` with a
+ * caller that does not exist.
+ */
+export declare function defaultExportNameCollides(assignment: SyntaxNode, root: SyntaxNode, derivedName: string): boolean;
+/**
+ * Same question as {@link isShadowedCjsExportAssignment}, asked of the
+ * ASSIGNMENT node rather than its value — the shape `provider.labelOverride`
+ * receives, since the graph-node capture is anchored on the assignment.
+ *
+ * Used to drop the graph node too, not just the scope declaration. When the
+ * shadowed name is a `function`, the node collapsed onto the lexical
+ * declaration's node anyway (same label, same id), but a `class Dup {}` plus
+ * `exports.Dup = function () {}` produced `Class:f:Dup` AND an orphan
+ * `Function:f:Dup` — a node nothing can reach, because the declaration that
+ * would have made it reachable is suppressed by the rule above.
+ */
+export declare function isShadowedCjsExportAssignmentNode(node: SyntaxNode, root: SyntaxNode): boolean;