cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/utils/call-analysis.js

@@ -0,0 +1,779 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCallArgTypes = exports.extractReceiverNode = exports.extractReceiverName = exports.inferCallForm = exports.countCallArguments = exports.MAX_CHAIN_DEPTH = exports.CALL_EXPRESSION_TYPES = void 0;
+exports.extractCallChain = extractCallChain;
+exports.extractMixedChain = extractMixedChain;
+const ast_helpers_js_1 = require("./ast-helpers.js");
+const callable_flow_captures_js_1 = require("./callable-flow-captures.js");
+/** Node types representing call expressions across supported languages. */
+exports.CALL_EXPRESSION_TYPES = new Set([
+    'call_expression', // TS/JS/C/C++/Go/Rust
+    'method_invocation', // Java
+    'member_call_expression', // PHP
+    'nullsafe_member_call_expression', // PHP ?.
+    'call', // Python/Ruby
+    'invocation_expression', // C#
+]);
+/**
+ * Hard limit on chain depth to prevent runaway recursion.
+ * For `a.b().c().d()`, the chain has depth 2 (b and c before d).
+ *
+ * A chain deeper than this is DISCARDED WHOLE, not truncated:
+ * `extractMixedChain` returns an undefined base and the encoder refuses to mint
+ * a partial chain, because a base-side prefix decodes cleanly as a shorter,
+ * complete-looking chain and would type the receiver against the wrong member.
+ * Correct, but it means a builder chain one hop too long contributes nothing at
+ * all rather than degrading.
+ *
+ * DELIBERATELY NOT RAISED. Measured (see bench/receiver-resolution/BASELINE.md,
+ * `fourHopChain`): a 4-step chain mints NOTHING at this cap — confirmed by
+ * probing the emitter directly — and the site still RESOLVES, because the text
+ * cascade that owns the fallback path runs to `COMPOUND_RECEIVER_MAX_DEPTH` (8)
+ * and answers where the structural fold declined.
+ *
+ * So the cap bounds which chains are typed STRUCTURALLY, not which calls
+ * resolve. Raising it moves work from the cascade to the fold without changing
+ * any edge, and the fixture that proves it is committed so the next person to
+ * reach for this number has the measurement rather than the intuition.
+ */
+exports.MAX_CHAIN_DEPTH = 3;
+/**
+ * Count direct arguments for a call expression across common tree-sitter grammars.
+ * Returns undefined when the argument container cannot be located cheaply.
+ */
+const countCallArguments = (callNode) => {
+    if (!callNode)
+        return undefined;
+    // Direct field or direct child (most languages)
+    let argsNode = callNode.childForFieldName('arguments') ??
+        callNode.children.find((child) => ast_helpers_js_1.CALL_ARGUMENT_LIST_TYPES.has(child.type));
+    // Kotlin/Swift: call_expression → call_suffix → value_arguments
+    // Search one level deeper for languages that wrap arguments in a suffix node
+    if (!argsNode) {
+        for (const child of callNode.children) {
+            if (!child.isNamed)
+                continue;
+            const nested = child.children.find((gc) => ast_helpers_js_1.CALL_ARGUMENT_LIST_TYPES.has(gc.type));
+            if (nested) {
+                argsNode = nested;
+                break;
+            }
+        }
+    }
+    if (!argsNode)
+        return undefined;
+    let count = 0;
+    for (const child of argsNode.children) {
+        if (!child.isNamed)
+            continue;
+        if (child.type === 'comment')
+            continue;
+        count++;
+    }
+    return count;
+};
+exports.countCallArguments = countCallArguments;
+// ── Call-form discrimination (Phase 1, Step D) ─────────────────────────
+/**
+ * AST node types that indicate a member-access wrapper around the callee name.
+ * When nameNode.parent.type is one of these, the call is a member call.
+ */
+const MEMBER_ACCESS_NODE_TYPES = new Set([
+    'member_expression', // TS/JS: obj.method()
+    'attribute', // Python: obj.method()
+    'member_access_expression', // C#: obj.Method()
+    'field_expression', // Rust/C++: obj.method() / ptr->method()
+    'selector_expression', // Go: obj.Method()
+    'navigation_suffix', // Kotlin/Swift: obj.method() — nameNode sits inside navigation_suffix
+    'member_binding_expression', // C#: user?.Method() — null-conditional access
+    'unconditional_assignable_selector', // Dart: obj.method() — nameNode inside selector > unconditional_assignable_selector
+]);
+/**
+ * Call node types that are inherently constructor invocations.
+ * Only includes patterns that the tree-sitter queries already capture as @call.
+ */
+const CONSTRUCTOR_CALL_NODE_TYPES = new Set([
+    'constructor_invocation', // Kotlin: Foo()
+    'new_expression', // TS/JS/C++: new Foo()
+    'object_creation_expression', // Java/C#/PHP: new Foo()
+    'implicit_object_creation_expression', // C# 9: User u = new(...)
+    'composite_literal', // Go: User{...}
+    'struct_expression', // Rust: User { ... }
+]);
+/**
+ * AST node types for scoped/qualified calls (e.g., Foo::new() in Rust, Foo::bar() in C++).
+ */
+const SCOPED_CALL_NODE_TYPES = new Set([
+    'scoped_identifier', // Rust: Foo::new()
+    'qualified_identifier', // C++: ns::func()
+]);
+/**
+ * Infer whether a captured call site is a free call, member call, or constructor.
+ * Returns undefined if the form cannot be determined.
+ *
+ * Works by inspecting the AST structure between callNode (@call) and nameNode (@call.name).
+ * No tree-sitter query changes needed — the distinction is in the node types.
+ */
+const inferCallForm = (callNode, nameNode) => {
+    // 1. Constructor: callNode itself is a constructor invocation (Kotlin)
+    if (CONSTRUCTOR_CALL_NODE_TYPES.has(callNode.type)) {
+        return 'constructor';
+    }
+    // 2. Member call: nameNode's parent is a member-access wrapper
+    const nameParent = nameNode.parent;
+    if (nameParent && MEMBER_ACCESS_NODE_TYPES.has(nameParent.type)) {
+        return 'member';
+    }
+    // 3. PHP: the callNode itself distinguishes member vs free calls
+    if (callNode.type === 'member_call_expression' ||
+        callNode.type === 'nullsafe_member_call_expression') {
+        return 'member';
+    }
+    if (callNode.type === 'scoped_call_expression') {
+        return 'member'; // static call Foo::bar()
+    }
+    // 4. Java method_invocation: member if it has an 'object' field
+    if (callNode.type === 'method_invocation' && callNode.childForFieldName('object')) {
+        return 'member';
+    }
+    // 4b. Ruby call with receiver: obj.method
+    if (callNode.type === 'call' && callNode.childForFieldName('receiver')) {
+        return 'member';
+    }
+    // 5. Scoped calls (Rust Foo::new(), C++ ns::func()): treat as free
+    //    The receiver is a type, not an instance — handled differently in Phase 3
+    if (nameParent && SCOPED_CALL_NODE_TYPES.has(nameParent.type)) {
+        return 'free';
+    }
+    // 6. Default: if nameNode is a direct child of callNode, it's a free call
+    if (nameNode.parent === callNode || nameParent?.parent === callNode) {
+        return 'free';
+    }
+    return undefined;
+};
+exports.inferCallForm = inferCallForm;
+/**
+ * Extract the receiver identifier for member calls.
+ * Only captures simple identifiers — returns undefined for complex expressions
+ * like getUser().save() or arr[0].method().
+ */
+const SIMPLE_RECEIVER_TYPES = new Set([
+    'identifier',
+    'simple_identifier',
+    'variable_name', // PHP $variable (tree-sitter-php)
+    'name', // PHP name node
+    'this', // TS/JS/Java/C# this.method()
+    'self', // Rust/Python self.method()
+    'super', // TS/JS/Java/Kotlin/Ruby super.method()
+    'super_expression', // Kotlin wraps super in super_expression
+    'base', // C# base.Method()
+    'parent', // PHP parent::method()
+    'constant', // Ruby CONSTANT.method() (uppercase identifiers)
+]);
+const extractReceiverName = (nameNode) => {
+    const parent = nameNode.parent;
+    if (!parent)
+        return undefined;
+    // PHP: member_call_expression / nullsafe_member_call_expression — receiver is on the callNode
+    // Java: method_invocation — receiver is the 'object' field on callNode
+    // For these, parent of nameNode is the call itself, so check the call's object field
+    const callNode = parent.parent ?? parent;
+    let receiver = null;
+    // Try standard field names used across grammars
+    receiver =
+        parent.childForFieldName('object') ?? // TS/JS member_expression, Python attribute, PHP, Java
+            parent.childForFieldName('value') ?? // Rust field_expression
+            parent.childForFieldName('operand') ?? // Go selector_expression
+            parent.childForFieldName('expression') ?? // C# member_access_expression
+            parent.childForFieldName('argument'); // C++ field_expression
+    // Java method_invocation: 'object' field is on the callNode, not on nameNode's parent
+    if (!receiver && callNode.type === 'method_invocation') {
+        receiver = callNode.childForFieldName('object');
+    }
+    // PHP: member_call_expression has 'object' on the call node
+    if (!receiver &&
+        (callNode.type === 'member_call_expression' ||
+            callNode.type === 'nullsafe_member_call_expression')) {
+        receiver = callNode.childForFieldName('object');
+    }
+    // Ruby: call node has 'receiver' field
+    if (!receiver && parent.type === 'call') {
+        receiver = parent.childForFieldName('receiver');
+    }
+    // PHP scoped_call_expression (parent::method(), self::method()):
+    // nameNode's direct parent IS the scoped_call_expression (name is a direct child)
+    if (!receiver &&
+        (parent.type === 'scoped_call_expression' || callNode.type === 'scoped_call_expression')) {
+        const scopedCall = parent.type === 'scoped_call_expression' ? parent : callNode;
+        receiver = scopedCall.childForFieldName('scope');
+        // relative_scope wraps 'parent'/'self'/'static' — unwrap to get the keyword
+        if (receiver?.type === 'relative_scope') {
+            receiver = receiver.firstChild;
+        }
+    }
+    // Dart: unconditional_assignable_selector is inside a `selector`, which is a sibling
+    // of the receiver in the expression_statement.  For `user.save()`, the previous named
+    // sibling of the `selector` is `identifier [user]`.
+    if (!receiver && parent.type === 'unconditional_assignable_selector') {
+        const selectorNode = parent.parent; // selector [.save]
+        if (selectorNode) {
+            receiver = selectorNode.previousNamedSibling;
+        }
+    }
+    // C# null-conditional: user?.Save() → conditional_access_expression wraps member_binding_expression
+    if (!receiver && parent.type === 'member_binding_expression') {
+        const condAccess = parent.parent;
+        if (condAccess?.type === 'conditional_access_expression') {
+            receiver = condAccess.firstNamedChild;
+        }
+    }
+    // Kotlin/Swift: navigation_expression target is the first child
+    if (!receiver && parent.type === 'navigation_suffix') {
+        const navExpr = parent.parent;
+        if (navExpr?.type === 'navigation_expression') {
+            // First named child is the target (receiver)
+            for (const child of navExpr.children) {
+                if (child.isNamed && child !== parent) {
+                    receiver = child;
+                    break;
+                }
+            }
+        }
+    }
+    if (!receiver)
+        return undefined;
+    // Only capture simple identifiers — refuse complex expressions
+    if (SIMPLE_RECEIVER_TYPES.has(receiver.type)) {
+        return receiver.text;
+    }
+    // Python super().method(): receiver is a call node `super()` — extract the function name
+    if (receiver.type === 'call') {
+        const func = receiver.childForFieldName('function');
+        if (func?.text === 'super')
+            return 'super';
+    }
+    return undefined;
+};
+exports.extractReceiverName = extractReceiverName;
+/**
+ * Extract the raw receiver AST node for a member call.
+ * Unlike extractReceiverName, this returns the receiver node regardless of its type —
+ * including call_expression / method_invocation nodes that appear in chained calls
+ * like `svc.getUser().save()`.
+ *
+ * Returns undefined when the call is not a member call or when no receiver node
+ * can be found (e.g. top-level free calls).
+ */
+const extractReceiverNode = (nameNode) => {
+    const parent = nameNode.parent;
+    if (!parent)
+        return undefined;
+    const callNode = parent.parent ?? parent;
+    let receiver = null;
+    receiver =
+        parent.childForFieldName('object') ??
+            parent.childForFieldName('value') ??
+            parent.childForFieldName('operand') ??
+            parent.childForFieldName('expression') ??
+            parent.childForFieldName('argument');
+    if (!receiver && callNode.type === 'method_invocation') {
+        receiver = callNode.childForFieldName('object');
+    }
+    if (!receiver &&
+        (callNode.type === 'member_call_expression' ||
+            callNode.type === 'nullsafe_member_call_expression')) {
+        receiver = callNode.childForFieldName('object');
+    }
+    if (!receiver && parent.type === 'call') {
+        receiver = parent.childForFieldName('receiver');
+    }
+    if (!receiver &&
+        (parent.type === 'scoped_call_expression' || callNode.type === 'scoped_call_expression')) {
+        const scopedCall = parent.type === 'scoped_call_expression' ? parent : callNode;
+        receiver = scopedCall.childForFieldName('scope');
+        if (receiver?.type === 'relative_scope') {
+            receiver = receiver.firstChild;
+        }
+    }
+    // Dart: unconditional_assignable_selector — receiver is previous sibling of the selector
+    if (!receiver && parent.type === 'unconditional_assignable_selector') {
+        const selectorNode = parent.parent;
+        if (selectorNode) {
+            receiver = selectorNode.previousNamedSibling;
+        }
+    }
+    if (!receiver && parent.type === 'member_binding_expression') {
+        const condAccess = parent.parent;
+        if (condAccess?.type === 'conditional_access_expression') {
+            receiver = condAccess.firstNamedChild;
+        }
+    }
+    if (!receiver && parent.type === 'navigation_suffix') {
+        const navExpr = parent.parent;
+        if (navExpr?.type === 'navigation_expression') {
+            for (const child of navExpr.children) {
+                if (child.isNamed && child !== parent) {
+                    receiver = child;
+                    break;
+                }
+            }
+        }
+    }
+    return receiver ?? undefined;
+};
+exports.extractReceiverNode = extractReceiverNode;
+// ── Chained-call extraction ───────────────────────────────────────────────
+/** Node types representing member/field access across languages. */
+/**
+ * Await expressions, per grammar. The walk previously stopped here — an await
+ * node is neither a call nor a field access — so `(await svc.getUserAsync()).save()`
+ * minted NO chain at all and the receiver fell to the text cascade.
+ */
+const AWAIT_EXPRESSION_NODE_TYPES = new Set([
+    'await_expression', // TS/JS/C#/Rust
+    'await', // Python
+]);
+/**
+ * Subscript / index expressions, per grammar. Same story as await: the walk
+ * stopped, so `repos[0].save()` minted no chain — which is why `indexElement`
+ * is an INVISIBLE-GAP (no edge AND no recorded drop) in all 14 languages, the
+ * most uniform cell in the matrix.
+ */
+const SUBSCRIPT_NODE_TYPES = new Set([
+    'subscript_expression', // TS/JS/PHP/C/C++
+    'subscript', // Python
+    'index_expression', // Go/Rust
+    'element_access_expression', // C#
+    'array_access', // Java
+    'indexing_expression', // Kotlin
+]);
+/**
+ * Can the chain walk descend into this node, or is it the base?
+ *
+ * ONE predicate for all four branches. The call and field branches previously
+ * tested only the call/field sets, so a receiver like `x[0].f().g()` stopped at
+ * the subscript and returned the literal text `x[0]` as the base — which
+ * `isEncodableSegment` accepts, minting a chain whose base binds to nothing. And
+ * `(await f()).g.h()` returned `await f()`, rejected on whitespace, minting no
+ * chain at all. Adding a fifth step kind must not require remembering four
+ * separate call sites.
+ */
+function isChainableReceiverNode(node) {
+    return (exports.CALL_EXPRESSION_TYPES.has(node.type) ||
+        FIELD_ACCESS_NODE_TYPES.has(node.type) ||
+        AWAIT_EXPRESSION_NODE_TYPES.has(node.type) ||
+        SUBSCRIPT_NODE_TYPES.has(node.type));
+}
+const FIELD_ACCESS_NODE_TYPES = new Set([
+    'member_expression', // TS/JS
+    'member_access_expression', // C#
+    'selector_expression', // Go
+    'field_expression', // Rust/C++
+    'field_access', // Java
+    'attribute', // Python
+    'navigation_expression', // Kotlin/Swift
+    'member_binding_expression', // C# null-conditional (user?.Address)
+]);
+/**
+ * Walk a receiver AST node that is itself a call expression, accumulating the
+ * chain of intermediate method names up to MAX_CHAIN_DEPTH.
+ *
+ * For `svc.getUser().save()`, called with the receiver of `save` (getUser() call):
+ *   returns { chain: ['getUser'], baseReceiverName: 'svc' }
+ *
+ * For `a.b().c().d()`, called with the receiver of `d` (c() call):
+ *   returns { chain: ['b', 'c'], baseReceiverName: 'a' }
+ */
+function extractCallChain(receiverCallNode) {
+    const chain = [];
+    let current = receiverCallNode;
+    while (exports.CALL_EXPRESSION_TYPES.has(current.type) && chain.length < exports.MAX_CHAIN_DEPTH) {
+        // Extract the method name from this call node.
+        const funcNode = current.childForFieldName?.('function') ??
+            current.childForFieldName?.('name') ??
+            current.childForFieldName?.('method'); // Ruby `call` node
+        let methodName;
+        let innerReceiver = null;
+        if (funcNode) {
+            // member_expression / attribute: last named child is the method identifier
+            methodName = funcNode.lastNamedChild?.text ?? funcNode.text;
+        }
+        // Kotlin/Swift: call_expression exposes callee as firstNamedChild, not a field.
+        // navigation_expression: method name is in navigation_suffix → simple_identifier.
+        if (!funcNode && current.type === 'call_expression') {
+            const callee = current.firstNamedChild;
+            if (callee?.type === 'navigation_expression') {
+                const suffix = callee.lastNamedChild;
+                if (suffix?.type === 'navigation_suffix') {
+                    methodName = suffix.lastNamedChild?.text;
+                    // The receiver is the part of navigation_expression before the suffix
+                    for (let i = 0; i < callee.namedChildCount; i++) {
+                        const child = callee.namedChild(i);
+                        if (child && child.type !== 'navigation_suffix') {
+                            innerReceiver = child;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (!methodName)
+            break;
+        chain.unshift(methodName); // build chain outermost-last
+        // Walk into the receiver of this call to continue the chain
+        if (!innerReceiver && funcNode) {
+            innerReceiver =
+                funcNode.childForFieldName?.('object') ??
+                    funcNode.childForFieldName?.('value') ??
+                    funcNode.childForFieldName?.('operand') ??
+                    funcNode.childForFieldName?.('expression');
+        }
+        // Java method_invocation: object field is on the call node
+        if (!innerReceiver && current.type === 'method_invocation') {
+            innerReceiver = current.childForFieldName?.('object');
+        }
+        // PHP member_call_expression
+        if (!innerReceiver &&
+            (current.type === 'member_call_expression' ||
+                current.type === 'nullsafe_member_call_expression')) {
+            innerReceiver = current.childForFieldName?.('object');
+        }
+        // Ruby `call` node: receiver field is on the call node itself
+        if (!innerReceiver && current.type === 'call') {
+            innerReceiver = current.childForFieldName?.('receiver');
+        }
+        if (!innerReceiver)
+            break;
+        if (exports.CALL_EXPRESSION_TYPES.has(innerReceiver.type)) {
+            current = innerReceiver; // continue walking
+        }
+        else {
+            // Reached a simple identifier — the base receiver
+            return {
+                chain,
+                baseReceiverName: unwrapTransparentReceiver(innerReceiver).text || undefined,
+            };
+        }
+    }
+    return chain.length > 0 ? { chain, baseReceiverName: undefined } : undefined;
+}
+/**
+ * Walk a receiver AST node that may interleave field accesses and method calls,
+ * building a unified chain of steps up to MAX_CHAIN_DEPTH.
+ *
+ * For `svc.getUser().address.save()`, called with the receiver of `save`
+ * (`svc.getUser().address`, a field access node):
+ *   returns { chain: [{ kind:'call', name:'getUser' }, { kind:'field', name:'address' }],
+ *             baseReceiverName: 'svc' }
+ *
+ * For `user.getAddress().city.getName()`, called with receiver of `getName`
+ * (`user.getAddress().city`):
+ *   returns { chain: [{ kind:'call', name:'getAddress' }, { kind:'field', name:'city' }],
+ *             baseReceiverName: 'user' }
+ *
+ * Pure field chains and pure call chains are special cases (all steps same kind).
+ */
+/**
+ * Node types that wrap an expression without changing what it denotes, so a
+ * receiver chain's BASE can be read through them.
+ *
+ * `svc!` (TS non-null assertion) and `(svc)` denote exactly `svc`; taking the
+ * wrapper's own text instead yields `svc!` / `(svc)`, which matches no binding
+ * and silently costs the chain its base.
+ *
+ * Deliberately EXCLUDES a cast (`x as T`, `(T)x`): a cast changes the type an
+ * expression denotes, so reading through one would type the receiver as the
+ * operand rather than as the cast target.
+ *
+ * Keyed by node type; the value is the operator text that has to TERMINATE the
+ * node for the peel to apply, or `null` for a node type that is transparent
+ * unconditionally.
+ *
+ * The gated entry exists because Swift force-unwrap (`self.a!`) is the exact
+ * semantic of TypeScript's `non_null_expression` — it yields the wrapped type —
+ * but Swift parses it as the general `postfix_expression`, which ALSO carries
+ * user-defined postfix operators. Those can return anything, so peeling that
+ * node type unconditionally would type the receiver as the operand and could
+ * produce a confidently wrong owner. Reading the operator keeps the peel to the
+ * case that is provably type-preserving.
+ */
+const TRANSPARENT_RECEIVER_WRAPPERS = new Map([
+    ['non_null_expression', null], // TypeScript `svc!`
+    ['parenthesized_expression', null], // `(svc)`
+    // NOT Swift-only: Kotlin's `!!` non-null assertion parses as the same node type
+    // and is equally type-preserving, so it is peeled too. Measured — the
+    // receiver-resolution bench moved `kotlin.nonNullAssert` VISIBLE-GAP ->
+    // RESOLVES when this landed, which is how the Kotlin effect was discovered
+    // rather than assumed. Any other grammar emitting `postfix_expression` is
+    // affected as well; the `!` gate, not the language, is what bounds this.
+    ['postfix_expression', '!'], // Swift `self.a!`, Kotlin `a!!`
+]);
+/** Is `node` a wrapper that denotes exactly what its operand denotes? */
+function isTransparentReceiverWrapper(node) {
+    // `node.type` is a native getter, and this predicate runs on every receiver
+    // node. Crossing it twice for two separate table lookups measured 376 ns/check
+    // against 188 ns for the single read below.
+    const operator = TRANSPARENT_RECEIVER_WRAPPERS.get(node.type);
+    // `undefined` is "not in the table"; `null` is "in the table, ungated". The
+    // two are distinguishable, so one `get` answers both questions — no separate
+    // `has` probe, and one crossing of the native `node.type` getter.
+    if (operator === undefined)
+        return false;
+    if (operator === null)
+        return true;
+    // The operator is an anonymous token, so it is not in `namedChildren`; the
+    // node's own text is the reliable place to read it. Deliberately NOT
+    // `node.lastChild` — measured 3x SLOWER (the child wrapper allocation
+    // dominates), and the token surfaces with type `bang`, not `!`.
+    return node.text.trimEnd().endsWith(operator);
+}
+/**
+ * Iteration bound for the wrapper peel. Its OWN constant, not `MAX_CHAIN_DEPTH`.
+ *
+ * The two answer unrelated questions — "how many chain hops do we type?" versus
+ * "how many redundant parens might someone write?" — and sharing one number
+ * meant raising the chain cap silently widened this loop as a side effect. That
+ * coupling is easy to miss precisely because the shared name reads as
+ * intentional. `((x))` nests twice; nothing real nests deeply.
+ */
+const MAX_TRANSPARENT_WRAPPER_DEPTH = 3;
+/** Peel transparent wrappers off a base receiver node. */
+function unwrapTransparentReceiver(node) {
+    let current = node;
+    for (let i = 0; i < MAX_TRANSPARENT_WRAPPER_DEPTH && isTransparentReceiverWrapper(current); i++) {
+        const inner = current.namedChildren?.find((c) => c !== null);
+        if (inner === undefined || inner === null)
+            break;
+        current = inner;
+    }
+    return current;
+}
+function extractMixedChain(receiverNode) {
+    const chain = [];
+    let current = receiverNode;
+    while (chain.length < exports.MAX_CHAIN_DEPTH) {
+        // Peel transparent wrappers at LOOP ENTRY, not only where a base is
+        // returned. `(await svc.getUserAsync()).save()` hands this walk a
+        // `parenthesized_expression`, which matches no branch below, so the walk
+        // fell straight through to the base case with an empty chain and minted
+        // nothing — the await step could never be reached.
+        current = unwrapTransparentReceiver(current);
+        if (exports.CALL_EXPRESSION_TYPES.has(current.type)) {
+            // ── Call expression: extract method name + inner receiver ────────────
+            const funcNode = current.childForFieldName?.('function') ??
+                current.childForFieldName?.('name') ??
+                current.childForFieldName?.('method');
+            let methodName;
+            let innerReceiver = null;
+            if (funcNode) {
+                methodName = funcNode.lastNamedChild?.text ?? funcNode.text;
+            }
+            // Kotlin/Swift: call_expression → navigation_expression
+            if (!funcNode && current.type === 'call_expression') {
+                const callee = current.firstNamedChild;
+                if (callee?.type === 'navigation_expression') {
+                    const suffix = callee.lastNamedChild;
+                    if (suffix?.type === 'navigation_suffix') {
+                        methodName = suffix.lastNamedChild?.text;
+                        for (let i = 0; i < callee.namedChildCount; i++) {
+                            const child = callee.namedChild(i);
+                            if (child && child.type !== 'navigation_suffix') {
+                                innerReceiver = child;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!methodName)
+                break;
+            chain.unshift({ kind: 'call', name: methodName });
+            if (!innerReceiver && funcNode) {
+                innerReceiver =
+                    funcNode.childForFieldName?.('object') ??
+                        funcNode.childForFieldName?.('value') ??
+                        funcNode.childForFieldName?.('operand') ??
+                        funcNode.childForFieldName?.('argument') ?? // C/C++ field_expression
+                        funcNode.childForFieldName?.('expression') ??
+                        null;
+            }
+            if (!innerReceiver && current.type === 'method_invocation') {
+                innerReceiver = current.childForFieldName?.('object') ?? null;
+            }
+            if (!innerReceiver &&
+                (current.type === 'member_call_expression' ||
+                    current.type === 'nullsafe_member_call_expression')) {
+                innerReceiver = current.childForFieldName?.('object') ?? null;
+            }
+            if (!innerReceiver && current.type === 'call') {
+                innerReceiver = current.childForFieldName?.('receiver') ?? null;
+            }
+            if (!innerReceiver)
+                break;
+            if (isChainableReceiverNode(innerReceiver)) {
+                current = innerReceiver;
+            }
+            else {
+                return {
+                    chain,
+                    baseReceiverName: unwrapTransparentReceiver(innerReceiver).text || undefined,
+                };
+            }
+        }
+        else if (FIELD_ACCESS_NODE_TYPES.has(current.type)) {
+            // ── Field/member access: extract property name + inner object ─────────
+            let propertyName;
+            let innerObject = null;
+            if (current.type === 'navigation_expression') {
+                for (const child of current.children ?? []) {
+                    if (child.type === 'navigation_suffix') {
+                        for (const sc of child.children ?? []) {
+                            if (sc.isNamed && sc.type !== '.') {
+                                propertyName = sc.text;
+                                break;
+                            }
+                        }
+                    }
+                    else if (child.isNamed && !innerObject) {
+                        innerObject = child;
+                    }
+                }
+            }
+            else if (current.type === 'attribute') {
+                innerObject = current.childForFieldName?.('object') ?? null;
+                propertyName = current.childForFieldName?.('attribute')?.text;
+            }
+            else {
+                innerObject =
+                    current.childForFieldName?.('object') ??
+                        current.childForFieldName?.('value') ??
+                        current.childForFieldName?.('operand') ??
+                        current.childForFieldName?.('argument') ?? // C/C++ field_expression
+                        current.childForFieldName?.('expression') ??
+                        null;
+                propertyName = (current.childForFieldName?.('property') ??
+                    current.childForFieldName?.('field') ??
+                    current.childForFieldName?.('name'))?.text;
+            }
+            if (!propertyName)
+                break;
+            chain.unshift({ kind: 'field', name: propertyName });
+            if (!innerObject)
+                break;
+            if (isChainableReceiverNode(innerObject)) {
+                current = innerObject;
+            }
+            else {
+                return {
+                    chain,
+                    baseReceiverName: unwrapTransparentReceiver(innerObject).text || undefined,
+                };
+            }
+        }
+        else if (AWAIT_EXPRESSION_NODE_TYPES.has(current.type)) {
+            // Name-free: the awaited call's method name already lives on its own
+            // `call` step, so this records only that an await happened.
+            chain.unshift({ kind: 'await' });
+            const inner = current.childForFieldName?.('argument') ??
+                current.childForFieldName?.('expression') ??
+                current.namedChildren?.find((c) => c !== null) ??
+                null;
+            if (!inner)
+                break;
+            if (isChainableReceiverNode(inner)) {
+                current = inner;
+            }
+            else {
+                return {
+                    chain,
+                    baseReceiverName: unwrapTransparentReceiver(inner).text || undefined,
+                };
+            }
+        }
+        else if (SUBSCRIPT_NODE_TYPES.has(current.type)) {
+            // Name-free: a subscript key is a VALUE, not an identifier the resolver
+            // could look up, so there is no member name to record.
+            chain.unshift({ kind: 'index' });
+            // Shared per-grammar table — it knows Python's `value` and Java's `array`,
+            // which a locally-written ladder omitted (they worked only because the
+            // container happened to be the first named child, an ordering coincidence
+            // rather than a contract). Falls back for grammars whose subscript node
+            // carries no `index` field.
+            const obj = (0, callable_flow_captures_js_1.subscriptBase)(current) ??
+                current.childForFieldName?.('object') ??
+                current.childForFieldName?.('argument') ??
+                current.childForFieldName?.('operand') ??
+                current.childForFieldName?.('expression') ??
+                current.namedChildren?.find((c) => c !== null) ??
+                null;
+            if (!obj)
+                break;
+            if (isChainableReceiverNode(obj)) {
+                current = obj;
+            }
+            else {
+                return {
+                    chain,
+                    baseReceiverName: unwrapTransparentReceiver(obj).text || undefined,
+                };
+            }
+        }
+        else if (current.type === 'selector') {
+            // ── Dart: flat selector siblings (user.address.save() uses selector nodes) ──
+            // Extract field name from unconditional_assignable_selector child
+            const uas = current.namedChildren?.find((c) => c.type === 'unconditional_assignable_selector');
+            const propertyName = uas?.namedChildren?.find((c) => c.type === 'identifier')?.text;
+            if (!propertyName)
+                break;
+            chain.unshift({ kind: 'field', name: propertyName });
+            // Walk to previous sibling for the next step in the chain
+            const prev = current.previousNamedSibling;
+            if (!prev)
+                break;
+            if (prev.type === 'selector') {
+                current = prev;
+            }
+            else {
+                // Base receiver (identifier or other terminal)
+                return { chain, baseReceiverName: prev.text || undefined };
+            }
+        }
+        else {
+            // Simple identifier — this is the base receiver
+            return chain.length > 0 ? { chain, baseReceiverName: current.text || undefined } : undefined;
+        }
+    }
+    return chain.length > 0 ? { chain, baseReceiverName: undefined } : undefined;
+}
+/** Arg types per call position (literals + optional TypeEnv for ids); undefined if unusable */
+const extractCallArgTypes = (callNode, inferLiteralType, typeEnvLookup) => {
+    let argList = callNode.childForFieldName?.('arguments') ??
+        callNode.children.find((c) => c.type === 'arguments' || c.type === 'argument_list' || c.type === 'value_arguments');
+    if (!argList) {
+        const callSuffix = callNode.children.find((c) => c.type === 'call_suffix');
+        if (callSuffix) {
+            argList = callSuffix.children.find((c) => c.type === 'value_arguments');
+        }
+    }
+    if (!argList)
+        return undefined;
+    const argTypes = [];
+    for (const arg of argList.namedChildren) {
+        if (arg.type === 'comment')
+            continue;
+        const valueNode = arg.childForFieldName?.('value') ??
+            arg.childForFieldName?.('expression') ??
+            (arg.type === 'argument' || arg.type === 'value_argument'
+                ? (arg.firstNamedChild ?? arg)
+                : arg);
+        let inferred = inferLiteralType(valueNode);
+        if (!inferred && typeEnvLookup && valueNode.type === 'identifier') {
+            inferred = typeEnvLookup(valueNode.text, callNode);
+        }
+        argTypes.push(inferred);
+    }
+    if (argTypes.every((t) => t === undefined))
+        return undefined;
+    return argTypes;
+};
+exports.extractCallArgTypes = extractCallArgTypes;