ucn 3.8.26 → 4.0.1

package/languages/python.js

@@ -11,7 +11,8 @@ const {
     nodeToLocation,
     parseStructuredParams,
     extractPythonDocstring,
-    paramTypesFromStructured
+    paramTypesFromStructured,
+    visitNameNodes,
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -228,6 +229,40 @@ function _processState(node, objects, lines) {
     return false;
 }
 
+/**
+ * Collect module-scope assignment target names (fix #217). A module-level
+ * `render = something` (including inside if/try/for blocks — module control
+ * flow still binds module attributes) or a `global name` declaration creates
+ * a module attribute the import-binding name-chase cannot model, so the
+ * chase must treat such names as undetermined rather than provably absent.
+ */
+function _processModuleAssign(node, names) {
+    if (node.type === 'global_statement') {
+        // `global X` declares that enclosing-function assignments of X bind
+        // the MODULE attribute — collect regardless of nesting.
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (c.type === 'identifier') names.add(c.text);
+        }
+        return;
+    }
+    if (node.type !== 'assignment' && node.type !== 'named_expression') return;
+    for (let p = node.parent; p; p = p.parent) {
+        // Function scope → local; class body → class attr. Either way, not a
+        // module attribute. if/try/for/with blocks at module level still are.
+        if (p.type === 'function_definition' || p.type === 'class_definition') return;
+    }
+    const left = node.childForFieldName('left') || node.childForFieldName('name');
+    if (!left) return;
+    if (left.type === 'identifier') names.add(left.text);
+    else if (left.type === 'tuple' || left.type === 'pattern_list') {
+        for (let i = 0; i < left.namedChildCount; i++) {
+            const c = left.namedChild(i);
+            if (c.type === 'identifier') names.add(c.text);
+        }
+    }
+}
+
 // --- End single-pass helpers ---
 
 /**
@@ -419,6 +454,7 @@ function parse(code, parser) {
     const functions = [];
     const classes = [];
     const stateObjects = [];
+    const moduleAssigned = new Set();
     const processedFn = new Set();
     const processedCls = new Set();
 
@@ -426,6 +462,7 @@ function parse(code, parser) {
         _processFunction(node, functions, processedFn, lines, code);
         _processClass(node, classes, processedCls, lines);
         _processState(node, stateObjects, lines);
+        _processModuleAssign(node, moduleAssigned);
         return true;
     });
 
@@ -439,6 +476,7 @@ function parse(code, parser) {
         functions,
         classes,
         stateObjects,
+        ...(moduleAssigned.size > 0 && { moduleAssignedNames: [...moduleAssigned].sort() }),
         imports: [],
         exports: []
     };
@@ -450,6 +488,120 @@ function parse(code, parser) {
  * @param {object} parser - Tree-sitter parser instance
  * @returns {Array<{name: string, line: number, isMethod: boolean, receiver?: string}>}
  */
+// Builtin types for literal method receivers: {'a': 1}.get('a') is dict.get,
+// never a project class method. Keys are tree-sitter node types.
+const PY_LITERAL_RECEIVER_TYPES = {
+    dictionary: 'dict',
+    dictionary_comprehension: 'dict',
+    list: 'list',
+    list_comprehension: 'list',
+    set: 'set',
+    set_comprehension: 'set',
+    string: 'str',
+    concatenated_string: 'str',
+    tuple: 'tuple',
+};
+
+// typing wrappers whose first argument is the actual value type
+const PY_TYPE_WRAPPERS = new Set(['Optional', 'Annotated', 'Final', 'ClassVar']);
+
+/**
+ * Extract a single concrete type name from an annotation's `type` node.
+ * Conservative by design: a wrong type would exclude true callers downstream
+ * (receiver-type-mismatch), so anything ambiguous returns undefined.
+ * Handles: Foo · pkg.Foo · Foo | None · Optional[Foo] · "Foo" · dict[str, int]
+ */
+function typeNameFromAnnotation(typeNode) {
+    if (!typeNode) return undefined;
+    const inner = typeNode.namedChildCount > 0 ? typeNode.namedChild(0) : null;
+    return typeNameFromExpr(inner);
+}
+
+function typeNameFromExpr(node) {
+    if (!node) return undefined;
+    switch (node.type) {
+        case 'identifier':
+            return node.text;
+        case 'attribute': {
+            // dotted name: classes match by name in the symbol table → last segment
+            const attr = node.childForFieldName('attribute');
+            return attr?.text;
+        }
+        case 'binary_operator': {
+            // PEP 604 union: X | None → X; unions of two real types are ambiguous
+            const left = node.namedChild(0);
+            const right = node.namedChild(1);
+            if (left?.type === 'none' && right?.type !== 'none') return typeNameFromExpr(right);
+            if (right?.type === 'none' && left?.type !== 'none') return typeNameFromExpr(left);
+            return undefined;
+        }
+        case 'subscript': {
+            // typing.Optional[Foo] parses as subscript when base is dotted
+            const base = typeNameFromExpr(node.childForFieldName('value'));
+            if (PY_TYPE_WRAPPERS.has(base)) {
+                return typeNameFromExpr(node.childForFieldName('subscript'));
+            }
+            return base; // dict[str, int] → the receiver IS a dict
+        }
+        case 'generic_type': {
+            // Optional[Foo] / Mapping[str, int] in annotation position
+            const base = typeNameFromExpr(node.namedChild(0));
+            if (PY_TYPE_WRAPPERS.has(base)) {
+                const params = node.namedChild(1); // type_parameter → type wrappers
+                const firstType = params && params.namedChildCount > 0 ? params.namedChild(0) : null;
+                return typeNameFromAnnotation(firstType);
+            }
+            return base;
+        }
+        case 'string': {
+            // forward reference: "Foo" — only accept a bare dotted name
+            for (let i = 0; i < node.childCount; i++) {
+                const c = node.child(i);
+                if (c.type === 'string_content') {
+                    const txt = c.text.trim();
+                    if (/^[A-Za-z_][\w.]*$/.test(txt)) return txt.split('.').pop();
+                }
+            }
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Variable receiving this call's result: `x = foo(...)` / `x = await foo(...)`
+ * → 'x'. Identifier targets only (no tuples/attributes). Compared by node id —
+ * tree-sitter wrapper objects are not identity-stable.
+ */
+function assignmentTargetOf(callNode) {
+    let n = callNode;
+    let p = n.parent;
+    if (p && p.type === 'await') { n = p; p = n.parent; }
+    if (p && p.type === 'assignment') {
+        const right = p.childForFieldName('right');
+        const left = p.childForFieldName('left');
+        if (right && right.id === n.id && left?.type === 'identifier') return left.text;
+    }
+    return undefined;
+}
+
+/**
+ * Type name from a constructor-call callee: ClassName(...) or pkg.ClassName(...).
+ * Uppercase-first heuristic (Python class naming convention).
+ */
+function constructorTypeName(funcNode) {
+    if (!funcNode) return undefined;
+    if (funcNode.type === 'identifier') {
+        return /^[A-Z]/.test(funcNode.text) ? funcNode.text : undefined;
+    }
+    if (funcNode.type === 'attribute') {
+        const attr = funcNode.childForFieldName('attribute');
+        return attr && /^[A-Z]/.test(attr.text) ? attr.text : undefined;
+    }
+    return undefined;
+}
+
 function findCallsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const calls = [];
@@ -457,6 +609,16 @@ function findCallsInCode(code, parser) {
     const aliases = new Map();  // Track local aliases: aliasName -> originalName
     const nonCallableNames = new Set();  // Track names assigned non-callable values
     const localVarTypes = new Map();  // Track local variable types: varName -> typeName (for receiverType inference)
+    // Member-access aliases (fix #218): `append = output.append` makes a later
+    // bare `append(part)` a METHOD call on `output` — it must carry the
+    // receiver's evidence, never bind by bare name to a same-file def
+    // (rich text.py: 7 list.append calls confirmed exact-binding against
+    // Text.append). aliasName -> { receiver: string|null, attr: string };
+    // receiver is null for chained/deep objects (self._text.append) — the
+    // rewritten call is then receiver-blind and routes through dispatch tiering.
+    const memberAliases = new Map();
+    const memberAliasesStack = [];  // function-scoped save/restore, like localVarTypes
+    const moduleAliases = new Set();  // Names bound to MODULES (import httpx / import numpy as np)
     const localVarTypesStack = [];  // Stack for function-scoped save/restore of localVarTypes
 
     // Helper: extract first string-arg literal from a call node.
@@ -541,7 +703,99 @@ function findCallsInCode(code, parser) {
             : null;
     };
 
+    // fix #203: is a bare-identifier function REFERENCE shadowed by a local of
+    // the enclosing function? Python locals are FUNCTION-scoped and an
+    // assignment ANYWHERE in the function makes the name local for ALL its
+    // references (UnboundLocalError semantics) — so scan the whole enclosing
+    // function subtree (excluding nested function bodies, which are separate
+    // scopes) for assignment/for/with-as/walrus bindings of the name.
+    // Enclosing-function PARAMS are checked at query time in findCallers.
+    const _targetBindsName = (left, name) => {
+        if (!left) return false;
+        if (left.type === 'identifier' && left.text === name) return true;
+        if (left.type === 'pattern_list' || left.type === 'tuple_pattern') {
+            for (let j = 0; j < left.namedChildCount; j++) {
+                if (left.namedChild(j).type === 'identifier' && left.namedChild(j).text === name) return true;
+            }
+        }
+        return false;
+    };
+    const _bindsNameInScope = (scopeNode, name) => {
+        for (let i = 0; i < scopeNode.namedChildCount; i++) {
+            const c = scopeNode.namedChild(i);
+            if (c.type === 'function_definition' || c.type === 'async_function_definition' ||
+                c.type === 'class_definition') {
+                // The body is a separate scope, but the DEF NAME itself is an
+                // assignment in THIS scope (fix #218: a nested `def get_style`
+                // shadows the name for sibling references).
+                if (c.childForFieldName('name')?.text === name) return true;
+                continue;
+            }
+            if (c.type === 'lambda') continue; // separate scope, no name
+            if (c.type === 'assignment' || c.type === 'augmented_assignment' || c.type === 'named_expression') {
+                if (_targetBindsName(c.childForFieldName('left') || c.childForFieldName('name'), name)) return true;
+            } else if (c.type === 'for_statement') {
+                if (_targetBindsName(c.childForFieldName('left'), name)) return true;
+            } else if (c.type === 'with_statement') {
+                // with open(f) as fh: — as-target is inside with_clause/with_item
+                const text = c.namedChild(0)?.text || '';
+                const m = text.match(/\bas\s+([A-Za-z_][A-Za-z0-9_]*)/);
+                if (m && m[1] === name) return true;
+            }
+            if (_bindsNameInScope(c, name)) return true;
+        }
+        return false;
+    };
+    const PY_COMPREHENSIONS = new Set([
+        'generator_expression', 'list_comprehension', 'set_comprehension', 'dictionary_comprehension',
+    ]);
+    const isShadowedByLocal = (refNode, name) => {
+        for (let p = refNode.parent; p; p = p.parent) {
+            // Comprehension for-clause targets are scoped to the comprehension
+            // itself (PEP 3110-era scoping): `cell_len(line) for line in lines`
+            // binds `line` ONLY inside the comprehension — block-accurate, so
+            // check on the way up rather than function-wide (fix #218).
+            if (PY_COMPREHENSIONS.has(p.type)) {
+                for (let i = 0; i < p.namedChildCount; i++) {
+                    const c = p.namedChild(i);
+                    if (c.type === 'for_in_clause' && _targetBindsName(c.childForFieldName('left'), name)) return true;
+                }
+            }
+            // Lambda params shadow their body the same way (fix #218).
+            if (p.type === 'lambda') {
+                const params = p.childForFieldName('parameters');
+                if (params) for (let i = 0; i < params.namedChildCount; i++) {
+                    const c = params.namedChild(i);
+                    if (c.type === 'identifier' && c.text === name) return true;
+                    if (c.type === 'default_parameter' && c.childForFieldName('name')?.text === name) return true;
+                }
+            }
+            if (p.type === 'function_definition' || p.type === 'async_function_definition') {
+                const body = p.childForFieldName('body');
+                return body ? _bindsNameInScope(body, name) : false;
+            }
+        }
+        return false; // module level — that's a module binding, not a shadow
+    };
+
     traverseTree(tree.rootNode, (node) => {
+        // Track module-alias bindings: `import httpx` binds 'httpx' (a module),
+        // `import numpy as np` binds 'np'. Method calls through these receivers
+        // dispatch to module functions, never to class methods. `from x import y`
+        // is skipped — y may be a symbol, not a module.
+        if (node.type === 'import_statement') {
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child.type === 'dotted_name') {
+                    const first = child.namedChild(0);
+                    if (first?.type === 'identifier') moduleAliases.add(first.text);
+                } else if (child.type === 'aliased_import') {
+                    const alias = child.childForFieldName('alias');
+                    if (alias?.type === 'identifier') moduleAliases.add(alias.text);
+                }
+            }
+        }
+
         // Track function entry
         if (isFunctionNode(node)) {
             // Use decorated_definition start line if present, to match symbol index
@@ -556,6 +810,7 @@ function findCallsInCode(code, parser) {
             });
             // Save localVarTypes so inner declarations don't leak to sibling functions
             localVarTypesStack.push(new Map(localVarTypes));
+            memberAliasesStack.push(new Map(memberAliases));
         }
 
         // Track parameter type annotations: def foo(x: Foo) → x is Foo
@@ -564,9 +819,24 @@ function findCallsInCode(code, parser) {
             const nameNode = node.childForFieldName('name') || node.namedChild(0);
             const typeNode = node.childForFieldName('type');
             if (nameNode?.type === 'identifier' && typeNode) {
-                const typeId = typeNode.namedChildCount > 0 ? typeNode.namedChild(0) : null;
-                if (typeId?.type === 'identifier' && !['self', 'cls'].includes(nameNode.text)) {
-                    localVarTypes.set(nameNode.text, typeId.text);
+                const typeName = typeNameFromAnnotation(typeNode);
+                if (typeName && !['self', 'cls'].includes(nameNode.text)) {
+                    localVarTypes.set(nameNode.text, typeName);
+                }
+            }
+        }
+
+        // Track with-statement bindings: with Client() as c → c is Client
+        // (covers async with too — same with_item/as_pattern node shape)
+        if (node.type === 'with_item') {
+            const value = node.childForFieldName('value') || node.namedChild(0);
+            if (value?.type === 'as_pattern') {
+                const ctx = value.namedChild(0);
+                const target = value.namedChildCount > 1 ? value.namedChild(value.namedChildCount - 1) : null;
+                const targetId = target?.type === 'as_pattern_target' ? target.namedChild(0) : null;
+                if (ctx?.type === 'call' && targetId?.type === 'identifier') {
+                    const ctorName = constructorTypeName(ctx.childForFieldName('function'));
+                    if (ctorName) localVarTypes.set(targetId.text, ctorName);
                 }
             }
         }
@@ -579,15 +849,39 @@ function findCallsInCode(code, parser) {
                 // Track type annotation: x: Foo = ... → x is Foo
                 const typeNode = node.childForFieldName('type');
                 if (typeNode) {
-                    // type node wraps the actual type identifier
-                    const typeId = typeNode.namedChildCount > 0 ? typeNode.namedChild(0) : null;
-                    if (typeId?.type === 'identifier') {
-                        localVarTypes.set(left.text, typeId.text);
+                    const typeName = typeNameFromAnnotation(typeNode);
+                    if (typeName) {
+                        localVarTypes.set(left.text, typeName);
                     }
                 }
+                memberAliases.delete(left.text); // any assignment rebinds the name
+                // Rebinding without a known type makes any previously inferred
+                // type stale — nearest-preceding-assignment semantics (#199's
+                // documented rule). Without this, `x = ""; x = render(); x.m()`
+                // would carry str and falsely exclude project methods.
+                if (!typeNode) localVarTypes.delete(left.text);
+                // Literal assignment types the variable (fix #218):
+                // ansi_bytes = b"…" → bytes; out = [] → list. Compiler-true,
+                // same trust grade as literal receivers ({}.get() → dict).
+                if (!typeNode && right && PY_LITERAL_RECEIVER_TYPES[right.type]) {
+                    let litType = PY_LITERAL_RECEIVER_TYPES[right.type];
+                    if (litType === 'str' && /^[rRuU]*[bB]/.test(right.text)) litType = 'bytes';
+                    localVarTypes.set(left.text, litType);
+                }
                 if (right?.type === 'identifier') {
                     aliases.set(left.text, right.text);
                 }
+                // Member-access alias (fix #218): append = output.append
+                else if (right?.type === 'attribute') {
+                    const attrName = right.childForFieldName('attribute');
+                    const objNode = right.childForFieldName('object');
+                    if (attrName?.type === 'identifier') {
+                        memberAliases.set(left.text, {
+                            receiver: objNode?.type === 'identifier' ? objNode.text : null,
+                            attr: attrName.text,
+                        });
+                    }
+                }
                 // Track partial(fn, ...) aliases: fast_process = partial(process, mode='fast')
                 else if (right?.type === 'call') {
                     const callFunc = right.childForFieldName('function');
@@ -626,11 +920,11 @@ function findCallsInCode(code, parser) {
                 // Exception: partial() already handled above via alias tracking.
                 else if (right?.type === 'call' && !aliases.has(left.text)) {
                     nonCallableNames.add(left.text);
-                    // Infer type from constructor call: x = ClassName(...)
-                    // Python convention: classes start with uppercase
-                    const callFunc = right.childForFieldName('function');
-                    if (callFunc?.type === 'identifier' && /^[A-Z]/.test(callFunc.text)) {
-                        localVarTypes.set(left.text, callFunc.text);
+                    // Infer type from constructor call: x = ClassName(...) or
+                    // x = pkg.ClassName(...). Python convention: classes start uppercase
+                    const ctorName = constructorTypeName(right.childForFieldName('function'));
+                    if (ctorName) {
+                        localVarTypes.set(left.text, ctorName);
                     }
                 }
                 // Third: subscript/attribute access results are non-callable data
@@ -651,20 +945,68 @@ function findCallsInCode(code, parser) {
 
             const enclosingFunction = getCurrentEnclosingFunction();
             let uncertain = false;
+            const assignedTo = assignmentTargetOf(node);
+
+            // Call-site arg count (positional + keyword) for arity pruning.
+            // *args/**kwargs splats make the count open-ended — flag them so
+            // pruning skips the site.
+            const callArgsNode = node.childForFieldName('arguments');
+            let argCount = 0;
+            let argSpread = false;
+            if (callArgsNode) {
+                for (let i = 0; i < callArgsNode.namedChildCount; i++) {
+                    const arg = callArgsNode.namedChild(i);
+                    if (arg.type === 'comment') continue;
+                    if (arg.type === 'list_splat' || arg.type === 'dictionary_splat') argSpread = true;
+                    argCount++;
+                }
+            }
 
             if (funcNode.type === 'identifier') {
-                // Direct call: foo()
-                const resolvedName = aliases.get(funcNode.text);
-                const firstArg = getFirstStringArg(node);
-                calls.push({
-                    name: funcNode.text,
-                    ...(resolvedName && { resolvedName }),
-                    line: node.startPosition.row + 1,
-                    isMethod: false,
-                    enclosingFunction,
-                    uncertain,
-                    ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
-                });
+                // Member-alias call (fix #218): `append = output.append` makes
+                // this bare call a METHOD call on the alias's receiver — emit
+                // it as one so receiver typing/dispatch tiering applies.
+                // Restricted to self-named aliases (alias === attr, the local
+                // bound-method optimization idiom): a renamed alias's line
+                // doesn't contain the method name, so it sits outside the
+                // account's text ground set — and never matched the target
+                // name before either (no FP to fix there).
+                const memberAlias = memberAliases.get(funcNode.text);
+                if (memberAlias && memberAlias.attr === funcNode.text) {
+                    const recvType = memberAlias.receiver ? localVarTypes.get(memberAlias.receiver) : undefined;
+                    const recvIsModule = !!memberAlias.receiver && moduleAliases.has(memberAlias.receiver) &&
+                        !localVarTypes.has(memberAlias.receiver);
+                    calls.push({
+                        name: memberAlias.attr,
+                        line: node.startPosition.row + 1,
+                        isMethod: true,
+                        aliasCall: true,
+                        ...(memberAlias.receiver && { receiver: memberAlias.receiver }),
+                        ...(recvType && { receiverType: recvType }),
+                        ...(recvIsModule && { receiverIsModule: true }),
+                        ...(assignedTo && { assignedTo }),
+                        argCount,
+                        ...(argSpread && { argSpread: true }),
+                        enclosingFunction,
+                        uncertain,
+                    });
+                } else {
+                    // Direct call: foo()
+                    const resolvedName = aliases.get(funcNode.text);
+                    const firstArg = getFirstStringArg(node);
+                    calls.push({
+                        name: funcNode.text,
+                        ...(resolvedName && { resolvedName }),
+                        line: node.startPosition.row + 1,
+                        isMethod: false,
+                        ...(assignedTo && { assignedTo }),
+                        argCount,
+                        ...(argSpread && { argSpread: true }),
+                        enclosingFunction,
+                        uncertain,
+                        ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
+                    });
+                }
             } else if (funcNode.type === 'attribute') {
                 // Method/attribute call: obj.foo() or self.attr.foo()
                 const attrNode = funcNode.childForFieldName('attribute');
@@ -673,6 +1015,13 @@ function findCallsInCode(code, parser) {
                 if (attrNode) {
                     let receiver = objNode?.type === 'identifier' ? objNode.text : undefined;
                     let selfAttribute = undefined;
+                    // Chained receiver (fix #219): the receiver IS a call —
+                    // fetch_data().json() — record the producer so findCallers
+                    // can type the receiver from its declared return
+                    // annotation. `(await f()).m()` unwraps to the call and
+                    // marks awaited (an un-awaited async producer's value is a
+                    // coroutine, not the annotation's type).
+                    let receiverCall, receiverCallIsMethod, receiverCallAwaited;
 
                     // Detect super().method() pattern
                     if (objNode?.type === 'call') {
@@ -681,6 +1030,27 @@ function findCallsInCode(code, parser) {
                             receiver = 'super';
                         }
                     }
+                    {
+                        let recvNode = objNode;
+                        if (recvNode?.type === 'parenthesized_expression' &&
+                            recvNode.namedChild(0)?.type === 'await') {
+                            receiverCallAwaited = true;
+                            recvNode = recvNode.namedChild(0).namedChild(0);
+                        }
+                        if (recvNode?.type === 'call' && receiver !== 'super') {
+                            const prodFunc = recvNode.childForFieldName('function');
+                            if (prodFunc?.type === 'identifier') {
+                                receiverCall = prodFunc.text;
+                            } else if (prodFunc?.type === 'attribute') {
+                                const prodAttr = prodFunc.childForFieldName('attribute');
+                                if (prodAttr) {
+                                    receiverCall = prodAttr.text;
+                                    receiverCallIsMethod = true;
+                                }
+                            }
+                        }
+                        if (!receiverCall) receiverCallAwaited = undefined;
+                    }
 
                     // Detect self.X.method() pattern: objNode is attribute access on self/cls
                     if (objNode?.type === 'attribute') {
@@ -694,15 +1064,33 @@ function findCallsInCode(code, parser) {
                         }
                     }
 
-                    const receiverType = receiver ? localVarTypes.get(receiver) : undefined;
+                    // Literal receivers carry their builtin type: {}.get() can
+                    // never be a project class method
+                    const receiverType = receiver
+                        ? localVarTypes.get(receiver)
+                        : (objNode ? PY_LITERAL_RECEIVER_TYPES[objNode.type] : undefined);
+                    // Module receiver (httpx.get()) — unless locally shadowed
+                    // by a typed instance binding
+                    const receiverIsModule = !!receiver && moduleAliases.has(receiver) &&
+                        !localVarTypes.has(receiver);
                     const firstArg = getFirstStringArg(node);
                     calls.push({
                         name: attrNode.text,
-                        line: node.startPosition.row + 1,
+                        // Multi-line chains (obj.x()\n.y()) must report each
+                        // method's OWN name line, not the chain-start line —
+                        // the account's ground set is keyed by the name's line
+                        line: attrNode.startPosition.row + 1,
                         isMethod: true,
                         receiver,
                         ...(receiverType && { receiverType }),
+                        ...(receiverIsModule && { receiverIsModule: true }),
                         ...(selfAttribute && { selfAttribute }),
+                        ...(receiverCall && { receiverCall }),
+                        ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
+                        ...(receiverCallAwaited && { receiverCallAwaited: true }),
+                        ...(assignedTo && { assignedTo }),
+                        argCount,
+                        ...(argSpread && { argSpread: true }),
                         enclosingFunction,
                         uncertain,
                         ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
@@ -730,6 +1118,7 @@ function findCallsInCode(code, parser) {
                             isMethod: false,
                             isFunctionReference: true,
                             isPotentialCallback: true,
+                            ...(isShadowedByLocal(arg, arg.text) && { localShadow: true }),
                             enclosingFunction
                         });
                     }
@@ -747,6 +1136,7 @@ function findCallsInCode(code, parser) {
                                         isMethod: false,
                                         isFunctionReference: true,
                                         isPotentialCallback: true,
+                                        ...(isShadowedByLocal(val, val.text) && { localShadow: true }),
                                         enclosingFunction
                                     });
                                 }
@@ -770,6 +1160,11 @@ function findCallsInCode(code, parser) {
                     localVarTypes.clear();
                     for (const [k, v] of saved) localVarTypes.set(k, v);
                 }
+                const savedAliases = memberAliasesStack.pop();
+                if (savedAliases) {
+                    memberAliases.clear();
+                    for (const [k, v] of savedAliases) memberAliases.set(k, v);
+                }
             }
         }
     });
@@ -955,7 +1350,7 @@ function findUsagesInCode(code, name, parser) {
     const tree = parseTree(parser, code);
     const usages = [];
 
-    traverseTreeCached(tree.rootNode, (node) => {
+    visitNameNodes(tree, code, name, (node) => {
         // Only look for identifiers with the matching name
         if (node.type !== 'identifier' || node.text !== name) {
             return true;