ucn 5.0.6 → 5.2.0

package/languages/python.js

@@ -686,6 +686,67 @@ function typeNameFromAnnotation(typeNode) {
     return typeNameFromExpr(inner);
 }
 
+/**
+ * Companion to typeNameFromAnnotation: the dotted module qualifier that owns
+ * the annotated name (fix #286e, flask-measured: `app: flask.Flask` typed the
+ * receiver bare 'Flask', and with a second test-local Flask class the origin
+ * fell back to directory proximity and excluded a compiler-true caller).
+ * Returns undefined when the annotation carries no qualifier.
+ */
+function typeQualifierFromAnnotation(typeNode) {
+    if (!typeNode) return undefined;
+    const inner = typeNode.namedChildCount > 0 ? typeNode.namedChild(0) : null;
+    return typeQualifierFromExpr(inner);
+}
+
+function typeQualifierFromExpr(node) {
+    if (!node) return undefined;
+    switch (node.type) {
+        case 'attribute':
+            return node.childForFieldName('object')?.text;
+        case 'parenthesized_expression':
+            return node.namedChildCount === 1
+                ? typeQualifierFromExpr(node.namedChild(0)) : undefined;
+        case 'binary_operator': {
+            const left = node.namedChild(0);
+            const right = node.namedChild(1);
+            if (left?.type === 'none' && right?.type !== 'none') return typeQualifierFromExpr(right);
+            if (right?.type === 'none' && left?.type !== 'none') return typeQualifierFromExpr(left);
+            return undefined;
+        }
+        case 'subscript': {
+            const base = typeNameFromExpr(node.childForFieldName('value'));
+            if (PY_TYPE_WRAPPERS.has(base)) {
+                return typeQualifierFromExpr(node.childForFieldName('subscript'));
+            }
+            return undefined;
+        }
+        case 'generic_type': {
+            const base = typeNameFromExpr(node.namedChild(0));
+            if (PY_TYPE_WRAPPERS.has(base)) {
+                const params = node.namedChild(1);
+                const firstType = params && params.namedChildCount > 0 ? params.namedChild(0) : null;
+                return typeQualifierFromAnnotation(firstType);
+            }
+            return undefined;
+        }
+        case 'string': {
+            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) && txt.includes('.')) {
+                        return txt.split('.').slice(0, -1).join('.');
+                    }
+                }
+            }
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+
 function typeNamesFromAnnotation(typeNode) {
     if (!typeNode) return [];
     const inner = typeNode.namedChildCount > 0 ? typeNode.namedChild(0) : null;
@@ -1015,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' ||
@@ -1170,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 = [];
@@ -1312,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) => {
@@ -1470,6 +1734,15 @@ function findCallsInCode(code, parser) {
                 if (receiverType && !['self', 'cls'].includes(nameNode.text)) {
                     localVarTypes.set(nameNode.text, receiverType);
                     declaredVarTypes.set(nameNode.text, receiverType);
+                    // The annotation's module qualifier is identity (fix
+                    // #286e) — splat params got a builtin type, no qualifier.
+                    const annotationQualifier = receiverType === typeName
+                        ? typeQualifierFromAnnotation(typeNode) : undefined;
+                    if (annotationQualifier) {
+                        localVarTypeQualifiers.set(nameNode.text, annotationQualifier);
+                    } else {
+                        localVarTypeQualifiers.delete(nameNode.text);
+                    }
                 }
                 if (unionTypes.length > 1) localVarUnionTypes.set(nameNode.text, unionTypes);
                 else localVarUnionTypes.delete(nameNode.text);
@@ -1525,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);
                         }
@@ -1599,8 +1874,15 @@ function findCallsInCode(code, parser) {
                     if (declaredType) localVarTypes.set(left.text, declaredType);
                 } else {
                     // An annotation is the authoritative type source; a
-                    // previous constructor qualifier must not survive it.
-                    localVarTypeQualifiers.delete(left.text);
+                    // previous constructor qualifier must not survive it —
+                    // the annotation's OWN qualifier does (fix #286e).
+                    const annotationQualifier = typeNameFromAnnotation(typeNode)
+                        ? typeQualifierFromAnnotation(typeNode) : undefined;
+                    if (annotationQualifier) {
+                        localVarTypeQualifiers.set(left.text, annotationQualifier);
+                    } else {
+                        localVarTypeQualifiers.delete(left.text);
+                    }
                 }
                 // Preserve a declared collection contract through the common
                 // normalization idiom `x = {} if x is None else x`. The
@@ -1723,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);
                         }
@@ -1753,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
@@ -1793,6 +2096,7 @@ function findCallsInCode(code, parser) {
                         ...(recvType && { receiverType: recvType }),
                         ...(recvIsModule && { receiverIsModule: true }),
                         ...(assignedTo && { assignedTo }),
+                        ...assignedIterFields,
                         ...(assignedContext && { assignedContext: true }),
                         argCount,
                         ...(argSpread && { argSpread: true }),
@@ -1809,6 +2113,7 @@ function findCallsInCode(code, parser) {
                         line: node.startPosition.row + 1,
                         isMethod: false,
                         ...(assignedTo && { assignedTo }),
+                        ...assignedIterFields,
                         ...(assignedContext && { assignedContext: true }),
                         argCount,
                         ...(argSpread && { argSpread: true }),
@@ -1990,6 +2295,7 @@ function findCallsInCode(code, parser) {
                             receiverCapabilityGuard: capabilityGuard,
                         }),
                         ...(assignedTo && { assignedTo }),
+                        ...assignedIterFields,
                         ...(assignedContext && { assignedContext: true }),
                         argCount,
                         ...(argSpread && { argSpread: true }),
@@ -2024,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') {
@@ -2346,6 +2682,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
@@ -2417,7 +2754,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