ucn 5.1.1 → 5.2.1

package/languages/python.js

@@ -1076,6 +1076,35 @@ function assignmentTargetOf(callNode) {
     return undefined;
 }
 
+/**
+ * For-loop iteration target of a call used as the iterable:
+ * `for ep in entry_points(...)` / comprehension `for x in items()`.
+ * The loop variable holds an ELEMENT of the producer's result, never the
+ * return type itself — consumers must only use this for provenance
+ * (external-producer demotion), never positive typing (fix #294).
+ */
+function iterTargetOf(callNode) {
+    let n = callNode;
+    let p = n.parent;
+    if (p && p.type === 'await') { n = p; p = n.parent; }
+    if (!p || (p.type !== 'for_statement' && p.type !== 'for_in_clause')) return undefined;
+    const right = p.childForFieldName('right');
+    if (!right || right.id !== n.id) return undefined;
+    const left = p.childForFieldName('left');
+    if (!left) return undefined;
+    const names = [];
+    if (left.type === 'identifier') {
+        names.push(left.text);
+    } else if (left.type === 'pattern_list' || left.type === 'tuple_pattern') {
+        for (let i = 0; i < left.namedChildCount; i++) {
+            const c = left.namedChild(i);
+            if (c.type === 'identifier') names.push(c.text);
+        }
+    }
+    if (names.length === 0) return undefined;
+    return { first: names[0], rest: names.slice(1) };
+}
+
 function contextTargetOf(callNode) {
     const pattern = callNode?.parent;
     if (pattern?.type !== 'as_pattern' ||
@@ -1231,6 +1260,247 @@ function pickleRoundTripSource(node) {
     return value?.type === 'identifier' ? value.text : null;
 }
 
+function pythonTargetBindsName(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 i = 0; i < left.namedChildCount; i++) {
+            if (left.namedChild(i).type === 'identifier' &&
+                left.namedChild(i).text === name) return true;
+        }
+    }
+    return false;
+}
+
+function pythonScopeBindsName(scopeNode, name) {
+    for (let i = 0; i < scopeNode.namedChildCount; i++) {
+        const child = scopeNode.namedChild(i);
+        if (child.type === 'function_definition' ||
+            child.type === 'async_function_definition' ||
+            child.type === 'class_definition') {
+            // The nested body is a separate scope, but the declaration name
+            // binds in this scope.
+            if (child.childForFieldName('name')?.text === name) return true;
+            continue;
+        }
+        if (child.type === 'lambda') continue;
+        if (child.type === 'assignment' ||
+            child.type === 'augmented_assignment' ||
+            child.type === 'named_expression') {
+            if (pythonTargetBindsName(
+                child.childForFieldName('left') || child.childForFieldName('name'),
+                name)) return true;
+        } else if (child.type === 'for_statement') {
+            if (pythonTargetBindsName(child.childForFieldName('left'), name)) return true;
+        } else if (child.type === 'with_statement') {
+            const text = child.namedChild(0)?.text || '';
+            const match = text.match(/\bas\s+([A-Za-z_][A-Za-z0-9_]*)/);
+            if (match && match[1] === name) return true;
+        }
+        if (pythonScopeBindsName(child, name)) return true;
+    }
+    return false;
+}
+
+const PY_COMPREHENSIONS = new Set([
+    'generator_expression', 'list_comprehension', 'set_comprehension',
+    'dictionary_comprehension',
+]);
+
+// Python locals are function-scoped: an assignment anywhere in the function
+// shadows an imported module for every reference in that function. Keep this
+// shared between call records and reference records so plan cannot promote a
+// receiver that callers would reject as locally rebound.
+function isPythonNameShadowedAt(refNode, name) {
+    for (let parent = refNode.parent; parent; parent = parent.parent) {
+        if (PY_COMPREHENSIONS.has(parent.type)) {
+            for (let i = 0; i < parent.namedChildCount; i++) {
+                const clause = parent.namedChild(i);
+                if (clause.type === 'for_in_clause' &&
+                    pythonTargetBindsName(clause.childForFieldName('left'), name)) {
+                    return true;
+                }
+            }
+        }
+        if (parent.type === 'lambda') {
+            const params = parent.childForFieldName('parameters');
+            if (params) for (let i = 0; i < params.namedChildCount; i++) {
+                const param = params.namedChild(i);
+                if (param.type === 'identifier' && param.text === name) return true;
+                if (param.type === 'default_parameter' &&
+                    param.childForFieldName('name')?.text === name) return true;
+            }
+        }
+        if (parent.type === 'function_definition' ||
+            parent.type === 'async_function_definition') {
+            const params = parent.childForFieldName('parameters');
+            if (params) {
+                for (let i = 0; i < params.namedChildCount; i++) {
+                    const param = params.namedChild(i);
+                    const paramName = param.type === 'identifier'
+                        ? param
+                        : (param.childForFieldName('name') || param.namedChild(0));
+                    if (paramName?.type === 'identifier' &&
+                        paramName.text === name) return true;
+                }
+            }
+            const body = parent.childForFieldName('body');
+            return body ? pythonScopeBindsName(body, name) : false;
+        }
+    }
+    return false;
+}
+
+/**
+ * Whether an uppercase call target is a local VALUE binding rather than a
+ * class declaration.
+ *
+ * Python permits runtime class factories and decorators to be rebound under
+ * class-shaped names:
+ *
+ *     C2 = attrs.define(...)(Base)
+ *     value = C2()
+ *
+ * The capitalization convention alone cannot type `value` as an indexed
+ * `class C2` from another lexical scope.  Scan the nearest Python scope using
+ * AST bindings and reject constructor-name inference when a parameter,
+ * function, assignment, loop, or with-target owns the name.  A sole local
+ * class declaration is deliberately allowed; its exact declaration is
+ * selected later with the call site's enclosing-function range.
+ */
+function isPythonConstructorValueShadowedAt(refNode, name) {
+    let scope = null;
+    for (let parent = refNode?.parent; parent; parent = parent.parent) {
+        if (PY_COMPREHENSIONS.has(parent.type)) {
+            for (let i = 0; i < parent.namedChildCount; i++) {
+                const clause = parent.namedChild(i);
+                if (clause.type === 'for_in_clause' &&
+                    pythonTargetBindsName(
+                        clause.childForFieldName('left'), name)) return true;
+            }
+        }
+        if (parent.type === 'lambda') {
+            const params = parent.childForFieldName('parameters');
+            if (params) {
+                for (let i = 0; i < params.namedChildCount; i++) {
+                    const param = params.namedChild(i);
+                    const paramName = param.type === 'identifier'
+                        ? param
+                        : (param.childForFieldName('name') || param.namedChild(0));
+                    if (paramName?.type === 'identifier' &&
+                        paramName.text === name) return true;
+                }
+            }
+            scope = parent;
+            break;
+        }
+        if (parent.type === 'function_definition' ||
+            parent.type === 'async_function_definition') {
+            const params = parent.childForFieldName('parameters');
+            if (params) {
+                for (let i = 0; i < params.namedChildCount; i++) {
+                    const param = params.namedChild(i);
+                    const paramName = param.type === 'identifier'
+                        ? param
+                        : (param.childForFieldName('name') || param.namedChild(0));
+                    if (paramName?.type === 'identifier' &&
+                        paramName.text === name) return true;
+                }
+            }
+            scope = parent.childForFieldName('body');
+            break;
+        }
+        if (parent.type === 'class_definition') {
+            scope = parent.childForFieldName('body');
+            break;
+        }
+        if (parent.type === 'module') {
+            scope = parent;
+            break;
+        }
+    }
+    if (!scope) return false;
+
+    let classDeclarations = 0;
+    const stack = [scope];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node !== scope && (node.type === 'function_definition' ||
+            node.type === 'async_function_definition' ||
+            node.type === 'class_definition')) {
+            const declaredName = node.childForFieldName('name')?.text;
+            if (declaredName === name) {
+                if (node.type === 'class_definition') classDeclarations++;
+                else return true;
+            }
+            // The declaration name binds in this scope; its body does not.
+            continue;
+        }
+        if (node.type === 'decorated_definition') {
+            let declaration = null;
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child.type === 'function_definition' ||
+                    child.type === 'async_function_definition' ||
+                    child.type === 'class_definition') {
+                    declaration = child;
+                    break;
+                }
+            }
+            if (declaration) {
+                const declaredName = declaration.childForFieldName('name')?.text;
+                if (declaredName === name) {
+                    if (declaration.type === 'class_definition') classDeclarations++;
+                    else return true;
+                }
+                continue;
+            }
+        }
+        if (node.type === 'assignment' ||
+            node.type === 'augmented_assignment' ||
+            node.type === 'named_expression') {
+            if (pythonTargetBindsName(
+                node.childForFieldName('left') || node.childForFieldName('name'),
+                name)) return true;
+        } else if (node.type === 'for_statement' || node.type === 'for_in_clause') {
+            if (pythonTargetBindsName(node.childForFieldName('left'), name)) return true;
+        } else if (node.type === 'with_item') {
+            const value = node.childForFieldName('value') || node.namedChild(0);
+            const target = value?.type === 'as_pattern'
+                ? value.namedChild(value.namedChildCount - 1) : null;
+            if (pythonTargetBindsName(
+                target?.type === 'as_pattern_target' ? target.namedChild(0) : target,
+                name)) return true;
+        }
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            stack.push(node.namedChild(i));
+        }
+    }
+    // Two conditional/repeated local class declarations with the same name
+    // are not one stable identity.  Refuse the heuristic and leave the value
+    // on the visible unverified rail.
+    return classDeclarations > 1;
+}
+
+function pythonModuleAliases(tree) {
+    const aliases = new Set();
+    traverseTreeCached(tree.rootNode, node => {
+        if (node.type !== 'import_statement') return true;
+        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') aliases.add(first.text);
+            } else if (child.type === 'aliased_import') {
+                const alias = child.childForFieldName('alias');
+                if (alias?.type === 'identifier') aliases.add(alias.text);
+            }
+        }
+        return true;
+    });
+    return aliases;
+}
+
 function findCallsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const calls = [];
@@ -1373,89 +1643,22 @@ function findCallsInCode(code, parser) {
         };
     };
 
-    // 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 params = p.childForFieldName('parameters');
-                if (params) {
-                    for (let i = 0; i < params.namedChildCount; i++) {
-                        const prm = params.namedChild(i);
-                        const prmName = prm.type === 'identifier'
-                            ? prm
-                            : (prm.childForFieldName('name') || prm.namedChild(0));
-                        if (prmName?.type === 'identifier' && prmName.text === name) return true;
-                    }
-                }
-                const body = p.childForFieldName('body');
-                return body ? _bindsNameInScope(body, name) : false;
-            }
-        }
-        return false; // module level — that's a module binding, not a shadow
+    const isShadowedByLocal = isPythonNameShadowedAt;
+    const exactConstructorInfo = funcNode => {
+        const ctor = constructorTypeInfo(funcNode);
+        if (!ctor) return undefined;
+        if (!ctor.qualifier) {
+            return isPythonConstructorValueShadowedAt(funcNode, ctor.type)
+                ? undefined : ctor;
+        }
+        // Attribute calls are constructors only when the receiver is an
+        // unshadowed module alias. `self.Widget()` / `factory.Widget()` and a
+        // parameter shadowing `import pkg` are dynamic attribute dispatch,
+        // not type identity. Previously their qualifier was discarded and
+        // the terminal name could borrow an unrelated project class.
+        const root = ctor.qualifier.split('.')[0];
+        return moduleAliases.has(root) && !isShadowedByLocal(funcNode, root)
+            ? ctor : undefined;
     };
 
     traverseTree(tree.rootNode, (node) => {
@@ -1595,12 +1798,14 @@ function findCallsInCode(code, parser) {
                 };
                 recordWithTargets(targetId || target);
                 if (ctx?.type === 'call' && targetId?.type === 'identifier') {
-                    const ctor = constructorTypeInfo(ctx.childForFieldName('function'));
-                    if (ctor) {
-                        localVarTypes.set(targetId.text, ctor.type);
+                    const constructorNode = ctx.childForFieldName('function');
+                    const exactCtor = exactConstructorInfo(constructorNode);
+                    if (exactCtor) {
+                        localVarTypes.set(targetId.text, exactCtor.type);
                         constructedReceiverVars.add(targetId.text);
-                        if (ctor.qualifier && moduleAliases.has(ctor.qualifier.split('.')[0])) {
-                            localVarTypeQualifiers.set(targetId.text, ctor.qualifier);
+                        if (exactCtor.qualifier &&
+                            moduleAliases.has(exactCtor.qualifier.split('.')[0])) {
+                            localVarTypeQualifiers.set(targetId.text, exactCtor.qualifier);
                         } else {
                             localVarTypeQualifiers.delete(targetId.text);
                         }
@@ -1800,12 +2005,14 @@ function findCallsInCode(code, parser) {
                     nonCallableNames.add(left.text);
                     // Infer type from constructor call: x = ClassName(...) or
                     // x = pkg.ClassName(...). Python convention: classes start uppercase
-                    const ctor = constructorTypeInfo(right.childForFieldName('function'));
-                    if (ctor) {
-                        localVarTypes.set(left.text, ctor.type);
+                    const constructorNode = right.childForFieldName('function');
+                    const exactCtor = exactConstructorInfo(constructorNode);
+                    if (exactCtor) {
+                        localVarTypes.set(left.text, exactCtor.type);
                         constructedReceiverVars.add(left.text);
-                        if (ctor.qualifier && moduleAliases.has(ctor.qualifier.split('.')[0])) {
-                            localVarTypeQualifiers.set(left.text, ctor.qualifier);
+                        if (exactCtor.qualifier &&
+                            moduleAliases.has(exactCtor.qualifier.split('.')[0])) {
+                            localVarTypeQualifiers.set(left.text, exactCtor.qualifier);
                         } else {
                             localVarTypeQualifiers.delete(left.text);
                         }
@@ -1830,7 +2037,26 @@ function findCallsInCode(code, parser) {
             const enclosingFunction = getCurrentEnclosingFunction();
             let uncertain = false;
             const assignedContext = contextTargetOf(node);
-            const assignedTo = assignmentTargetOf(node) || assignedContext;
+            let assignedTo = assignmentTargetOf(node) || assignedContext;
+            // For-loop iterable producer (fix #294): the loop variable's
+            // provenance comes from this call. assignedIter marks that the
+            // variable holds an ELEMENT, not the return value — the flow map
+            // uses it for external-producer demotion only, never typing.
+            let assignedIter = false;
+            let assignedIterRest = null;
+            if (!assignedTo) {
+                const iterTarget = iterTargetOf(node);
+                if (iterTarget) {
+                    assignedTo = iterTarget.first;
+                    assignedIterRest = iterTarget.rest;
+                    assignedIter = true;
+                }
+            }
+            const assignedIterFields = {
+                ...(assignedIter && { assignedIter: true }),
+                ...(assignedIter && assignedIterRest && assignedIterRest.length > 0 &&
+                    { assignedTupleRest: assignedIterRest }),
+            };
 
             // Call-site arg count (positional + keyword) for arity pruning.
             // *args/**kwargs splats make the count open-ended — flag them so
@@ -1870,6 +2096,7 @@ function findCallsInCode(code, parser) {
                         ...(recvType && { receiverType: recvType }),
                         ...(recvIsModule && { receiverIsModule: true }),
                         ...(assignedTo && { assignedTo }),
+                        ...assignedIterFields,
                         ...(assignedContext && { assignedContext: true }),
                         argCount,
                         ...(argSpread && { argSpread: true }),
@@ -1886,6 +2113,7 @@ function findCallsInCode(code, parser) {
                         line: node.startPosition.row + 1,
                         isMethod: false,
                         ...(assignedTo && { assignedTo }),
+                        ...assignedIterFields,
                         ...(assignedContext && { assignedContext: true }),
                         argCount,
                         ...(argSpread && { argSpread: true }),
@@ -2067,6 +2295,7 @@ function findCallsInCode(code, parser) {
                             receiverCapabilityGuard: capabilityGuard,
                         }),
                         ...(assignedTo && { assignedTo }),
+                        ...assignedIterFields,
                         ...(assignedContext && { assignedContext: true }),
                         argCount,
                         ...(argSpread && { argSpread: true }),
@@ -2101,6 +2330,36 @@ function findCallsInCode(code, parser) {
                             enclosingFunction
                         });
                     }
+                    // Method-value references (fix #295, flask-check-measured):
+                    // `pytest.raises(NIE, t.check, None)` passes the bound
+                    // method t.check — an attribute argument on a one-hop
+                    // identifier receiver is a potential method value, typed
+                    // from the same localVarTypes evidence method calls use.
+                    // No isPotentialCallback: the record rides the MAIN path's
+                    // full receiver physics (the JS HOF member-value
+                    // convention), not the bare-name callback fast path.
+                    // self/cls receivers (same-class values) and module-alias
+                    // receivers (name-level ownership physics) are
+                    // classified-deferred families — not emitted.
+                    if (arg.type === 'attribute') {
+                        const mvObj = arg.childForFieldName('object');
+                        const mvAttr = arg.childForFieldName('attribute');
+                        if (mvObj?.type === 'identifier' && mvAttr &&
+                            !PYTHON_SKIP.has(mvObj.text) &&
+                            !moduleAliases.has(mvObj.text) &&
+                            !PYTHON_SKIP.has(mvAttr.text)) {
+                            const mvType = localVarTypes.get(mvObj.text);
+                            calls.push({
+                                name: mvAttr.text,
+                                line: mvAttr.startPosition.row + 1,
+                                isMethod: true,
+                                receiver: mvObj.text,
+                                ...(mvType && { receiverType: mvType }),
+                                isFunctionReference: true,
+                                enclosingFunction
+                            });
+                        }
+                    }
                     // Scan dict literal args for function refs in values
                     // e.g., do_request({'on_success': handle_success})
                     if (arg.type === 'dictionary') {
@@ -2209,10 +2468,24 @@ function findImportsInCode(code, parser) {
     const imports = [];
     let importAliases = null;  // {original, local}[] — tracks renamed imports
 
+    // Imports nested in a function/lambda do not execute during ordinary
+    // module initialization. Preserve that AST fact so dependency-cycle
+    // reporting can distinguish an eager import loop from a deliberate lazy
+    // edge without deleting either edge from the graph.
+    const isDeferredImport = (node) => {
+        for (let parent = node.parent; parent; parent = parent.parent) {
+            if (parent.type === 'function_definition' || parent.type === 'lambda') {
+                return true;
+            }
+        }
+        return false;
+    };
+
     traverseTreeCached(tree.rootNode, (node) => {
         // import statement: import os, import sys as system
         if (node.type === 'import_statement') {
             const line = node.startPosition.row + 1;
+            const deferred = isDeferredImport(node);
 
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
@@ -2228,20 +2501,23 @@ function findImportsInCode(code, parser) {
                             module: parts[0],
                             names: [parts[0]],
                             type: 'import',
-                            line
+                            line,
+                            ...(deferred && { deferred: true })
                         });
                         imports.push({
                             module: child.text,
                             names: [],
                             type: 'import-submodule',
-                            line
+                            line,
+                            ...(deferred && { deferred: true })
                         });
                     } else {
                         imports.push({
                             module: child.text,
                             names: [child.text],
                             type: 'import',
-                            line
+                            line,
+                            ...(deferred && { deferred: true })
                         });
                     }
                 } else if (child.type === 'aliased_import') {
@@ -2253,7 +2529,8 @@ function findImportsInCode(code, parser) {
                             module: nameNode.text,
                             names: [aliasNode ? aliasNode.text : nameNode.text.split('.').pop()],
                             type: 'import',
-                            line
+                            line,
+                            ...(deferred && { deferred: true })
                         });
                         if (aliasNode && aliasNode.text !== nameNode.text) {
                             if (!importAliases) importAliases = [];
@@ -2268,6 +2545,7 @@ function findImportsInCode(code, parser) {
         // from ... import statement
         if (node.type === 'import_from_statement') {
             const line = node.startPosition.row + 1;
+            const deferred = isDeferredImport(node);
             let modulePath = '';
             const names = [];
 
@@ -2300,7 +2578,8 @@ function findImportsInCode(code, parser) {
                     module: modulePath,
                     names,
                     type: isRelative ? 'relative' : 'from',
-                    line
+                    line,
+                    ...(deferred && { deferred: true })
                 });
             }
             return true;
@@ -2315,13 +2594,15 @@ function findImportsInCode(code, parser) {
                 const firstArg = argsNode.namedChild(0);
                 if ((funcName === 'importlib.import_module' || funcName === '__import__') && firstArg) {
                     const line = node.startPosition.row + 1;
+                    const deferred = isDeferredImport(node);
                     const isLiteral = firstArg.type === 'string';
                     imports.push({
                         module: isLiteral ? firstArg.text.replace(/^['"]|['"]$/g, '') : firstArg.text,
                         names: [],
                         type: 'dynamic',
                         line,
-                        dynamic: !isLiteral
+                        dynamic: !isLiteral,
+                        ...(deferred && { deferred: true })
                     });
                 }
             }
@@ -2423,6 +2704,7 @@ function findExportsInCode(code, parser) {
 function findUsagesInCode(code, name, parser, tree) {
     tree = tree || parseTree(parser, code);
     const usages = [];
+    const moduleAliases = pythonModuleAliases(tree);
 
     visitNameNodes(tree, code, name, (node) => {
         // Only look for identifiers with the matching name
@@ -2494,7 +2776,16 @@ function findUsagesInCode(code, name, parser, tree) {
                 // Track receiver for member expressions (obj.name → receiver = 'obj')
                 const object = parent.childForFieldName('object');
                 if (object && object.type === 'identifier') {
-                    usages.push({ line, column, usageType, receiver: object.text });
+                    usages.push({
+                        line,
+                        column,
+                        usageType,
+                        receiver: object.text,
+                        ...(moduleAliases.has(object.text) && { receiverIsModule: true }),
+                        ...(isPythonNameShadowedAt(object, object.text) && {
+                            receiverLocalBinding: true,
+                        }),
+                    });
                     return true;
                 }
                 // Constructed receiver: ColorTriplet(...).normalized is a