ucn 5.4.2 → 5.5.1

package/languages/python.js

@@ -6,6 +6,7 @@
  */
 
 const { ReceiverTypeMap, typeOrigin } = require('./type-evidence');
+const { referenceScope, scopeFields } = require('./lexical-scope');
 
 
 const {
@@ -18,9 +19,63 @@ const {
     paramTypesFromStructured,
     visitNameNodes,
     sameNode,
+    containsOwnNode,
+    parseErrorRegions,
+    branchClausesExclusive,
+    getCachedNodeList,
 } = require('./utils');
+
+// A function whose OWN body yields is a generator: calling it returns an
+// iterator (an async iterator for `async def`), never a coroutine.
+const PY_YIELD_TYPES = new Set(['yield']);
+const PY_SCOPE_BOUNDARIES = new Set(['function_definition', 'lambda', 'class_definition']);
+function isPythonGenerator(fnNode) {
+    const body = fnNode.childForFieldName('body');
+    return !!body && body.text.includes('yield') &&
+        containsOwnNode(body, PY_YIELD_TYPES, PY_SCOPE_BOUNDARIES);
+}
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
+// Statements that run in the namespace of the scope holding them: a def
+// under `if`/`try`/`with`/`for`/`while`/`match` in a class body executes in
+// the class namespace and binds a class attribute (a method), exactly like
+// one written directly in the body (fix #402).
+const PY_CLASS_BODY_COMPOUNDS = new Set(['block', 'if_statement', 'elif_clause', 'else_clause',
+    'try_statement', 'except_clause', 'except_group_clause', 'finally_clause', 'with_statement',
+    'for_statement', 'while_statement', 'match_statement', 'case_clause', 'decorated_definition']);
+
+/** The class whose body declares `defNode` (a def or class, decorated or
+ * not), through compound statements; null for any other scope. */
+function pythonClassBodyOwner(defNode) {
+    for (let node = defNode?.parent; node; node = node.parent) {
+        if (node.type === 'class_definition') return node;
+        if (!PY_CLASS_BODY_COMPOUNDS.has(node.type)) return null;
+    }
+    return null;
+}
+
+/** Function definitions a class body declares (decorated ones as their
+ * `decorated_definition`), in source order, through compound statements;
+ * nested functions and classes are not entered. */
+function pythonClassBodyDefs(body) {
+    const out = [];
+    const visit = container => {
+        for (let i = 0; i < container.namedChildCount; i++) {
+            const child = container.namedChild(i);
+            if (child.type === 'function_definition') { out.push(child); continue; }
+            if (child.type === 'decorated_definition') {
+                const definition = child.childForFieldName('definition');
+                if (definition?.type === 'function_definition') out.push(child);
+                continue;
+            }
+            if (child.type === 'class_definition') continue;
+            if (PY_CLASS_BODY_COMPOUNDS.has(child.type)) visit(child);
+        }
+    };
+    if (body) visit(body);
+    return out;
+}
+
 function parseTree(parser, code) {
     return safeParse(parser, code, undefined, PARSE_OPTIONS);
 }
@@ -147,19 +202,9 @@ function _processFunction(node, functions, processedRanges, lines, code) {
         if (processedRanges.has(rangeKey)) return true;
         processedRanges.add(rangeKey);
 
-        // Skip functions that are inside a class (they're extracted as class members)
-        let parent = node.parent;
-        // Handle decorated_definition wrapper
-        if (parent && parent.type === 'decorated_definition') {
-            parent = parent.parent;
-        }
-        // Check if parent is a class body (block inside class_definition)
-        if (parent && parent.type === 'block') {
-            const grandparent = parent.parent;
-            if (grandparent && grandparent.type === 'class_definition') {
-                return true;  // Skip - this is a class method
-            }
-        }
+        // Skip functions a class body declares, directly or under its
+        // compound statements: they're extracted as class members.
+        if (pythonClassBodyOwner(node)) return true;
 
         const nameNode = node.childForFieldName('name');
         const paramsNode = node.childForFieldName('parameters');
@@ -182,6 +227,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
 
             // Check for async
             const isAsync = node.text.trimStart().startsWith('async ');
+            const isGenerator = isPythonGenerator(node);
 
             // Extract decorators
             const decorators = extractDecorators(node);
@@ -200,6 +246,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 endLine,
                 indent,
                 isAsync,
+                ...(isGenerator && { isGenerator }),
                 modifiers: isAsync ? ['async'] : [],
                 ...(returnType && { returnType }),
                 ...(returnedConstructors && { returnedConstructors }),
@@ -243,6 +290,7 @@ function _processClass(node, classes, processedRanges, lines) {
         const decorators = extractDecorators(node);
         const bases = extractBases(node);
         const nameLine = nameNode.startPosition.row + 1;
+        const lexicalScope = pythonFunctionLocalScope(node);
 
         classes.push({
             name: nameNode.text,
@@ -253,12 +301,34 @@ function _processClass(node, classes, processedRanges, lines) {
             ...(docstring && { docstring }),
             ...(decorators.length > 0 && { decorators }),
             ...(bases.length > 0 && { extends: bases.join(', ') }),
-            ...(nameLine !== startLine && { nameLine })
+            ...(nameLine !== startLine && { nameLine }),
+            ...lexicalScope,
         });
     }
     return true;
 }
 
+/**
+ * Lexical scope of a class declared inside a function (fix #381): the
+ * enclosing function's body. The name is a local of that function, so it
+ * is visible only there (including nested functions, which close over it).
+ * Module-level and class-body classes are unscoped.
+ */
+function pythonFunctionLocalScope(node) {
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        if (parent.type === 'class_definition') return {};
+        if (parent.type === 'function_definition' ||
+            parent.type === 'async_function_definition') {
+            const body = parent.childForFieldName('body') || parent;
+            return {
+                lexicalScopeStartLine: body.startPosition.row + 1,
+                lexicalScopeEndLine: body.endPosition.row + 1,
+            };
+        }
+    }
+    return {};
+}
+
 // Module-level state detection patterns
 const _STATE_PATTERN = /^(CONFIG|SETTINGS|[A-Z][A-Z0-9_]+|[A-Z][a-zA-Z]*(?:Config|Settings|Options|State|Store|Context))$/;
 // Pattern for UPPER_CASE constants that may have scalar values (string, number, bool, etc.)
@@ -336,6 +406,475 @@ function _processModuleAssign(node, names) {
     }
 }
 
+/**
+ * Module-level names bound exactly once, to another name (fix #389):
+ * `Alias = Box`, `Alias = models.Box`. Query time decides whether the
+ * target is a class; such an alias then denotes it in annotations and
+ * constructor calls. A name bound again at module scope (assignment,
+ * augmented assignment, loop/with/except target, import, def, class, walrus,
+ * del) or declared `global` in any function is not an alias.
+ */
+function pythonModuleValueAliases(root) {
+    // Cheap first pass: a module-level statement `Name = other.name` at all
+    // (directly, or in a module-level if/try/with block).
+    const aliasShaped = (expr) => expr?.type === 'assignment' &&
+        expr.childForFieldName('left')?.type === 'identifier' &&
+        ['identifier', 'attribute'].includes(expr.childForFieldName('right')?.type);
+    let shaped = false;
+    const probe = (node) => {
+        for (const statement of node.namedChildren) {
+            if (shaped) return;
+            if (statement.type === 'expression_statement') {
+                if (statement.namedChildren.some(aliasShaped)) shaped = true;
+            } else if (/^(if_statement|elif_clause|else_clause|try_statement|except_clause|finally_clause|with_statement|block)$/.test(statement.type)) {
+                probe(statement);
+            }
+        }
+    };
+    probe(root);
+    if (!shaped) return [];
+    // Every module-level binding of each name (fix #392): an alias
+    // assignment, an import, or anything else.
+    const bindings = new Map();
+    const bind = (name, entry) => {
+        if (!name) return;
+        if (!bindings.has(name)) bindings.set(name, []);
+        bindings.get(name).push(entry);
+    };
+    const bindTarget = (node) => {
+        if (!node) return;
+        if (node.type === 'identifier') { bind(node.text, { kind: 'other' }); return; }
+        if (['pattern_list', 'tuple_pattern', 'list_pattern', 'tuple', 'list', 'expression_list',
+            'parenthesized_expression', 'list_splat_pattern', 'list_splat', 'as_pattern_target'].includes(node.type)) {
+            for (const child of node.namedChildren) bindTarget(child);
+        }
+    };
+    const visit = (node) => {
+        for (const child of node.namedChildren) {
+            switch (child.type) {
+                case 'function_definition':
+                case 'class_definition':
+                    bind(child.childForFieldName('name')?.text, { kind: 'other' });
+                    continue;
+                case 'decorated_definition':
+                    bind(child.childForFieldName('definition')?.childForFieldName('name')?.text, { kind: 'other' });
+                    continue;
+                case 'import_statement':
+                case 'future_import_statement':
+                    for (const part of child.namedChildren) {
+                        if (part.type === 'aliased_import') bind(part.childForFieldName('alias')?.text, { kind: 'other' });
+                        else if (part.type === 'dotted_name') bind(part.namedChild(0)?.text, { kind: 'other' });
+                    }
+                    continue;
+                case 'import_from_statement': {
+                    const moduleName = child.childForFieldName('module_name')?.text;
+                    for (const part of child.namedChildren) {
+                        if (sameNode(part, child.childForFieldName('module_name'))) continue;
+                        if (part.type === 'wildcard_import') { bind('*', { kind: 'other' }); continue; }
+                        const imported = part.type === 'aliased_import'
+                            ? part.childForFieldName('name')?.text : part.type === 'dotted_name' ? part.text : null;
+                        const local = part.type === 'aliased_import'
+                            ? part.childForFieldName('alias')?.text : part.type === 'dotted_name'
+                                ? part.namedChild(part.namedChildCount - 1)?.text : null;
+                        if (!local) continue;
+                        // A from-import binds the imported object: one binding
+                        // site of a class the name may alias.
+                        bind(local, moduleName && imported && !imported.includes('.')
+                            ? { kind: 'import', module: moduleName, imported, line: child.startPosition.row + 1 }
+                            : { kind: 'other' });
+                    }
+                    continue;
+                }
+                case 'expression_statement':
+                    for (let expr of child.namedChildren) {
+                        while (expr?.type === 'assignment' || expr?.type === 'augmented_assignment') {
+                            const left = expr.childForFieldName('left');
+                            const right = expr.childForFieldName('right');
+                            if (expr.type === 'assignment' && left?.type === 'identifier' &&
+                                !expr.childForFieldName('type') &&
+                                (right?.type === 'identifier' || right?.type === 'attribute') &&
+                                /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(right.text) &&
+                                right.text !== left.text) {
+                                bind(left.text, { kind: 'alias', target: right.text,
+                                    line: expr.startPosition.row + 1 });
+                            } else if (expr.type === 'assignment' && left?.type === 'identifier' &&
+                                !expr.childForFieldName('type') && right?.type === 'call' &&
+                                right.childForFieldName('function')?.type === 'identifier') {
+                                // `registry = Registry()` (fix #398F): a module value
+                                // built by calling a name, read when an alias names
+                                // one of its attributes.
+                                bind(left.text, { kind: 'constructed',
+                                    callee: right.childForFieldName('function').text,
+                                    line: expr.startPosition.row + 1 });
+                            } else {
+                                bindTarget(left);
+                            }
+                            expr = expr.type === 'assignment' ? right : null;
+                        }
+                    }
+                    continue;
+                case 'delete_statement':
+                    for (const target of child.namedChildren) bindTarget(target);
+                    continue;
+                case 'for_statement':
+                    bindTarget(child.childForFieldName('left'));
+                    break;
+                case 'with_statement':
+                case 'try_statement':
+                    for (const target of child.descendantsOfType('as_pattern_target')) bindTarget(target);
+                    break;
+                default:
+                    break;
+            }
+            if (child.namedChildCount > 0 && child.type !== 'expression_statement') visit(child);
+        }
+    };
+    visit(root);
+    for (const walrus of root.descendantsOfType('named_expression')) {
+        let inFunction = false;
+        for (let p = walrus.parent; p; p = p.parent) {
+            if (p.type === 'function_definition' || p.type === 'class_definition' || p.type === 'lambda') {
+                inFunction = true;
+                break;
+            }
+        }
+        if (!inFunction) bind(walrus.childForFieldName('name')?.text, { kind: 'other' });
+    }
+    const declaredGlobal = new Set();
+    for (const statement of root.descendantsOfType('global_statement')) {
+        for (const name of statement.namedChildren) declaredGlobal.add(name.text);
+    }
+    const aliases = [];
+    const constructed = new Map();
+    for (const [name, sites] of bindings) {
+        if (declaredGlobal.has(name) || sites.some(site => site.kind === 'other')) continue;
+        if (sites.length === 1 && sites[0].kind === 'constructed') {
+            constructed.set(name, { name, callee: sites[0].callee, line: sites[0].line });
+            continue;
+        }
+        const assignments = sites.filter(site => site.kind === 'alias');
+        if (assignments.length === 0 || sites.some(site => site.kind === 'constructed')) continue;
+        if (sites.length === 1) {
+            // Bound once (also inside a module-level block, fix #392).
+            aliases.push({ name, target: assignments[0].target, line: assignments[0].line });
+            continue;
+        }
+        // Bound on several paths (if/else, try/except): an alias only when
+        // every binding site names the same class, decided where it resolves.
+        aliases.push({
+            name, target: assignments[0].target, line: assignments[0].line,
+            alternatives: sites.map(site => site.kind === 'alias'
+                ? { target: site.target } : { module: site.module, imported: site.imported }),
+        });
+    }
+    // Constructed values an alias reads an attribute of (`loads =
+    // registry.loads`, fix #398F).
+    const roots = new Set(aliases.flatMap(alias => [alias.target, ...(alias.alternatives || [])
+        .map(alternative => alternative.target)]).filter(Boolean)
+        .map(target => String(target).split('.')).filter(parts => parts.length === 2).map(parts => parts[0]));
+    const values = [...roots].filter(root => constructed.has(root)).sort().map(root => constructed.get(root));
+    if (values.length > 0) Object.defineProperty(aliases, 'constructed', { value: values });
+    return aliases;
+}
+
+const PY_SCOPE_NODES = new Set(['function_definition', 'class_definition', 'lambda', 'module']);
+const PY_BRANCH_CLAUSES = new Set(['elif_clause', 'else_clause', 'except_clause', 'except_group_clause',
+    'finally_clause', 'case_clause']);
+
+/** Does a statement list (descending compound statements, never into
+ * nested scopes) bind `name`? */
+function pythonClauseBindsName(node, name) {
+    for (const child of node.namedChildren) {
+        switch (child.type) {
+            case 'function_definition':
+            case 'class_definition':
+                if (child.childForFieldName('name')?.text === name) return true;
+                continue;
+            case 'decorated_definition':
+                if (child.childForFieldName('definition')?.childForFieldName('name')?.text === name) return true;
+                continue;
+            case 'import_statement':
+            case 'import_from_statement':
+            case 'expression_statement':
+            case 'delete_statement':
+            case 'for_statement':
+            case 'with_statement':
+                if (child.descendantsOfType('identifier').some(id => id.text === name)) return true;
+                if (child.type === 'for_statement' || child.type === 'with_statement') {
+                    for (const part of child.namedChildren) {
+                        if ((part.type === 'block' || part.type === 'else_clause') && pythonClauseBindsName(part, name)) return true;
+                    }
+                }
+                continue;
+            default:
+                if (child.type === 'block' || child.type.endsWith('_statement') || PY_BRANCH_CLAUSES.has(child.type)) {
+                    if (pythonClauseBindsName(child, name)) return true;
+                }
+        }
+    }
+    return false;
+}
+
+/**
+ * Cheap gate for configuration items: a def, class or import inside a
+ * branch whose statement binds the same name in another clause. Files
+ * without one (nearly all) skip the scope walk.
+ */
+function pythonConfigurationCandidateScopes(root, bindingNodes) {
+    const scopes = new Set();
+    const nodes = bindingNodes || getCachedNodeList(root).nodes.filter(node =>
+        node.type === 'function_definition' || node.type === 'class_definition' ||
+        node.type === 'import_statement' || node.type === 'import_from_statement');
+    for (const node of nodes) {
+        // Directly in a scope body: no branch can hold it.
+        const holder = node.parent?.type === 'decorated_definition' ? node.parent.parent : node.parent;
+        if (holder?.type === 'module' || (holder?.type === 'block' && PY_SCOPE_NODES.has(holder.parent?.type))) continue;
+        let names = null;
+        const start = node.parent?.type === 'decorated_definition' ? node.parent : node;
+        for (let parent = start.parent; parent && !PY_SCOPE_NODES.has(parent.type); parent = parent.parent) {
+            const statement = parent.type === 'block' ? null
+                : ['if_statement', 'try_statement'].includes(parent.type) ? parent
+                    : PY_BRANCH_CLAUSES.has(parent.type) ? (parent.type === 'case_clause' ? parent.parent?.parent : parent.parent)
+                        : null;
+            if (!statement) continue;
+            if (!names) {
+                if (node.type === 'function_definition' || node.type === 'class_definition') {
+                    names = [node.childForFieldName('name')?.text].filter(Boolean);
+                } else {
+                    names = [];
+                    for (const part of node.namedChildren) {
+                        if (part.type === 'aliased_import') names.push(part.childForFieldName('alias')?.text);
+                        else if (part.type === 'dotted_name' && !sameNode(part, node.childForFieldName('module_name'))) {
+                            names.push(node.type === 'import_statement' ? part.namedChild(0)?.text
+                                : part.namedChild(part.namedChildCount - 1)?.text);
+                        }
+                    }
+                    names = names.filter(Boolean);
+                }
+                if (names.length === 0) break;
+            }
+            // Another clause of this statement (or its match body) binding
+            // one of the names.
+            const holder = statement.type === 'match_statement' ? statement.childForFieldName('body') : statement;
+            let found = false;
+            for (const clause of holder?.namedChildren || []) {
+                if (clause.startIndex <= node.startIndex && clause.endIndex >= node.endIndex) continue;
+                if (clause.type !== 'block' && !PY_BRANCH_CLAUSES.has(clause.type)) continue;
+                if (names.some(name => pythonClauseBindsName(clause, name))) { found = true; break; }
+            }
+            if (found) {
+                let scope = statement.parent;
+                while (scope && !PY_SCOPE_NODES.has(scope.type)) scope = scope.parent;
+                if (scope) scopes.add(scope);
+                break;
+            }
+        }
+    }
+    return scopes;
+}
+
+/**
+ * Configuration items (fix #398F): a name bound in one scope (module, class
+ * body or function body) only in mutually exclusive branches of `if` /
+ * `try` / `match` statements - `if sys.platform == "win32": def getchar` /
+ * `else: def getchar`, `try: from ._speedups import f` / `except
+ * ImportError: def f` - is ONE item with an alternative per configuration.
+ * Every binding of the name in that scope must sit in a different exclusive
+ * branch (a later unconditional rebinding, a loop target or a `global` /
+ * `nonlocal` write breaks the item), and one of them must be a def, class or
+ * import. Sites carry their branch path (statement line + clause tag, outer
+ * first); `clauses` holds the line range of every clause of those
+ * statements, so a call inside another branch is placed without the tree.
+ */
+function pythonConfigurationItems(root, bindingNodes = null, reboundNodes = null) {
+    const candidateScopes = pythonConfigurationCandidateScopes(root, bindingNodes);
+    if (candidateScopes.size === 0) return [];
+    const scopes = new Map();   // scope line -> Map(name -> sites)
+    const clauseRanges = new Map(); // statement line -> [[tag, start, end]]
+    const rebound = new Set();  // `global` / `nonlocal` names
+    const lineOf = node => node.startPosition.row + 1;
+    const endOf = node => node.endPosition.row + 1;
+    const add = (scope, name, kind, line, branch) => {
+        if (!name) return;
+        let names = scopes.get(scope);
+        if (!names) scopes.set(scope, names = new Map());
+        if (!names.has(name)) names.set(name, []);
+        names.get(name).push({ kind, line, branch });
+    };
+    const bindTarget = (scope, node, branch) => {
+        if (!node) return;
+        if (node.type === 'identifier') { add(scope, node.text, 'value', lineOf(node), branch); return; }
+        if (['pattern_list', 'tuple_pattern', 'list_pattern', 'tuple', 'list', 'expression_list',
+            'parenthesized_expression', 'list_splat_pattern', 'list_splat', 'as_pattern_target'].includes(node.type)) {
+            for (const child of node.namedChildren) bindTarget(scope, child, branch);
+        }
+    };
+    const noteClauses = (statement, clauses) => {
+        clauseRanges.set(lineOf(statement), clauses.map(([tag, node]) => [tag, lineOf(node), endOf(node)]));
+    };
+    const visitBlock = (block, scope, branch) => {
+        if (!block) return;
+        for (const child of block.namedChildren) visitStatement(child, scope, branch);
+    };
+    const visitStatement = (node, scope, branch) => {
+        switch (node.type) {
+            case 'decorated_definition': {
+                const definition = node.childForFieldName('definition');
+                if (!definition) return;
+                add(scope, definition.childForFieldName('name')?.text,
+                    definition.type === 'class_definition' ? 'class' : 'def', lineOf(node), branch);
+                return;
+            }
+            case 'function_definition':
+            case 'class_definition':
+                add(scope, node.childForFieldName('name')?.text,
+                    node.type === 'class_definition' ? 'class' : 'def', lineOf(node), branch);
+                return;
+            case 'import_statement':
+                for (const part of node.namedChildren) {
+                    if (part.type === 'aliased_import') add(scope, part.childForFieldName('alias')?.text, 'import', lineOf(node), branch);
+                    else if (part.type === 'dotted_name') add(scope, part.namedChild(0)?.text, 'import', lineOf(node), branch);
+                }
+                return;
+            case 'import_from_statement': {
+                const moduleName = node.childForFieldName('module_name');
+                for (const part of node.namedChildren) {
+                    if (moduleName && part.id === moduleName.id) continue;
+                    if (part.type === 'wildcard_import') { add(scope, '*', 'import', lineOf(node), branch); continue; }
+                    const local = part.type === 'aliased_import' ? part.childForFieldName('alias')?.text
+                        : part.type === 'dotted_name' ? part.namedChild(part.namedChildCount - 1)?.text : null;
+                    add(scope, local, 'import', lineOf(node), branch);
+                }
+                return;
+            }
+            case 'global_statement':
+            case 'nonlocal_statement':
+                return;
+            case 'expression_statement':
+                for (let expr of node.namedChildren) {
+                    while (expr?.type === 'assignment' || expr?.type === 'augmented_assignment') {
+                        bindTarget(scope, expr.childForFieldName('left'), branch);
+                        expr = expr.type === 'assignment' ? expr.childForFieldName('right') : null;
+                    }
+                }
+                return;
+            case 'delete_statement':
+                for (const target of node.namedChildren) bindTarget(scope, target, branch);
+                return;
+            case 'if_statement': {
+                const line = lineOf(node);
+                const consequence = node.childForFieldName('consequence');
+                const clauses = consequence ? [['if', consequence]] : [];
+                let elif = 0;
+                for (const alternative of node.childrenForFieldName('alternative')) {
+                    if (alternative.type === 'elif_clause') clauses.push([`elif:${elif++}`, alternative]);
+                    else if (alternative.type === 'else_clause') clauses.push(['else', alternative]);
+                }
+                noteClauses(node, clauses);
+                // `if TYPE_CHECKING:` branches exist for type checkers, not
+                // for one runtime configuration: their names form no item.
+                const typeChecking = /^(?:\w+\.)?TYPE_CHECKING$/.test(node.childForFieldName('condition')?.text || '');
+                for (const [tag, clause] of clauses) {
+                    const block = clause.type === 'block' ? clause
+                        : clause.childForFieldName('consequence') || clause.childForFieldName('body');
+                    visitBlock(block, scope, [...branch, typeChecking ? [line, tag, 'type-checking'] : [line, tag]]);
+                }
+                return;
+            }
+            case 'try_statement': {
+                const line = lineOf(node);
+                const clauses = [];
+                let handler = 0;
+                for (const child of node.namedChildren) {
+                    if (child.type === 'block') clauses.push(['try', child]);
+                    else if (child.type === 'except_clause' || child.type === 'except_group_clause') {
+                        clauses.push([`except:${handler++}`, child]);
+                    } else if (child.type === 'else_clause') clauses.push(['try-else', child]);
+                    else if (child.type === 'finally_clause') clauses.push(['finally', child]);
+                }
+                noteClauses(node, clauses);
+                for (const [tag, clause] of clauses) {
+                    const path = [...branch, [line, tag]];
+                    if (clause.type === 'block') { visitBlock(clause, scope, path); continue; }
+                    for (const target of clause.descendantsOfType('as_pattern_target')) {
+                        if (target.parent?.parent && sameNode(target.parent.parent, clause)) bindTarget(scope, target, path);
+                    }
+                    for (const child of clause.namedChildren) if (child.type === 'block') visitBlock(child, scope, path);
+                }
+                return;
+            }
+            case 'match_statement': {
+                const line = lineOf(node);
+                const body = node.childForFieldName('body');
+                const cases = body ? body.namedChildren.filter(child => child.type === 'case_clause') : [];
+                const clauses = cases.map((clause, i) => [`case:${i}`, clause]);
+                noteClauses(node, clauses);
+                for (const [tag, clause] of clauses) {
+                    for (const child of clause.namedChildren) if (child.type === 'block') visitBlock(child, scope, [...branch, [line, tag]]);
+                }
+                return;
+            }
+            case 'for_statement':
+                bindTarget(scope, node.childForFieldName('left'), branch);
+                // A loop body may run several times or not at all: its
+                // bindings are sequential, never exclusive alternatives.
+                for (const child of node.namedChildren) if (child.type === 'block' || child.type === 'else_clause') visitBlock(child.type === 'block' ? child : child.namedChildren.find(c => c.type === 'block'), scope, [...branch, [lineOf(node), 'loop']]);
+                return;
+            case 'while_statement':
+                for (const child of node.namedChildren) if (child.type === 'block' || child.type === 'else_clause') visitBlock(child.type === 'block' ? child : child.namedChildren.find(c => c.type === 'block'), scope, [...branch, [lineOf(node), 'loop']]);
+                return;
+            case 'with_statement':
+                for (const target of node.descendantsOfType('as_pattern_target')) {
+                    if (target.parent?.parent?.parent && sameNode(target.parent.parent.parent, node.namedChildren[0])) bindTarget(scope, target, branch);
+                }
+                visitBlock(node.childForFieldName('body'), scope, branch);
+                return;
+            default:
+                return;
+        }
+    };
+    // Only the scopes holding a candidate are walked (their own statements;
+    // nested scopes are walked when they are candidates themselves).
+    for (const scope of candidateScopes) {
+        if (scope.type === 'module') { visitBlock(scope, 0, []); continue; }
+        const head = scope.parent?.type === 'decorated_definition' ? scope.parent : scope;
+        visitBlock(scope.childForFieldName('body'), lineOf(head), []);
+    }
+    // A `global` / `nonlocal` write anywhere rebinds the name at run time.
+    for (const node of reboundNodes || getCachedNodeList(root).nodes) {
+        if (node.type !== 'global_statement' && node.type !== 'nonlocal_statement') continue;
+        for (const name of node.namedChildren) if (name.type === 'identifier') rebound.add(name.text);
+    }
+    const exclusive = (a, b) => {
+        for (let k = 0; k < Math.min(a.length, b.length); k++) {
+            if (a[k][0] !== b[k][0]) return false;
+            if (a[k][1] !== b[k][1]) return branchClausesExclusive(a[k][1], b[k][1]);
+        }
+        return false;
+    };
+    const items = [];
+    for (const [scope, names] of scopes) {
+        for (const [name, sites] of names) {
+            if (sites.length < 2 || name === '*' || rebound.has(name)) continue;
+            if (!sites.some(site => site.kind !== 'value')) continue;
+            if (sites.some(site => site.branch.some(step => step.length > 2))) continue;
+            let all = true;
+            for (let i = 0; all && i < sites.length; i++) {
+                for (let j = i + 1; all && j < sites.length; j++) all = exclusive(sites[i].branch, sites[j].branch);
+            }
+            if (!all) continue;
+            const statements = new Set(sites.flatMap(site => site.branch.map(([line]) => line)));
+            items.push({
+                name, scope,
+                sites: sites.map(site => ({ kind: site.kind, line: site.line, branch: site.branch })),
+                clauses: [...statements].sort((a, b) => a - b).map(line => [line, clauseRanges.get(line) || []]),
+            });
+        }
+    }
+    items.sort((a, b) => a.scope - b.scope || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return items;
+}
+
 // --- End single-pass helpers ---
 
 /**
@@ -530,9 +1069,7 @@ function extractClassMembers(classNode, code) {
     const bodyNode = classNode.childForFieldName('body');
     if (!bodyNode) return members;
 
-    for (let i = 0; i < bodyNode.namedChildCount; i++) {
-        const child = bodyNode.namedChild(i);
-
+    for (const child of pythonClassBodyDefs(bodyNode)) {
         let funcNode = child;
         let decoratorStart = null;
         const memberDecorators = [];
@@ -586,6 +1123,7 @@ function extractClassMembers(classNode, code) {
                 }
 
                 const isAsync = funcNode.text.trimStart().startsWith('async ');
+                const isGenerator = isPythonGenerator(funcNode);
                 const returnType = extractReturnType(funcNode);
                 const returnedConstructors = extractReturnedConstructors(funcNode);
                 const defLine = getDefLine(funcNode);
@@ -603,6 +1141,7 @@ function extractClassMembers(classNode, code) {
                     endLine,
                     memberType,
                     isAsync,
+                    ...(isGenerator && { isGenerator }),
                     isMethod: true,  // Mark as method for context() lookups
                     // Match top-level Python functions: `async def` → ['async'] modifiers.
                     modifiers: isAsync ? ['async'] : [],
@@ -649,18 +1188,28 @@ function parse(code, parser) {
     const processedFn = new Set();
     const processedCls = new Set();
 
+    // Binding statements and `global`/`nonlocal` declarations seen by the
+    // one traversal feed the configuration-item gate (fix #398F).
+    const bindingNodes = [];
+    const reboundNodes = [];
     traverseTreeCached(tree.rootNode, (node) => {
         _processFunction(node, functions, processedFn, lines, code);
         _processClass(node, classes, processedCls, lines) ||
             _processTypeAlias(node, classes, processedCls, lines);
         _processState(node, stateObjects, lines);
         _processModuleAssign(node, moduleAssigned);
+        const type = node.type;
+        if (type === 'function_definition' || type === 'class_definition' ||
+            type === 'import_statement' || type === 'import_from_statement') bindingNodes.push(node);
+        else if (type === 'global_statement' || type === 'nonlocal_statement') reboundNodes.push(node);
         return true;
     });
 
     functions.sort((a, b) => a.startLine - b.startLine);
     classes.sort((a, b) => a.startLine - b.startLine);
     stateObjects.sort((a, b) => a.startLine - b.startLine);
+    const moduleValueAliases = moduleAssigned.size > 0 ? pythonModuleValueAliases(tree.rootNode) : [];
+    const configurationItems = pythonConfigurationItems(tree.rootNode, bindingNodes, reboundNodes);
 
     return {
         language: 'python',
@@ -668,7 +1217,10 @@ function parse(code, parser) {
         functions,
         classes,
         stateObjects,
-        ...(tree.rootNode.hasError && { parseRecovery: true }),
+        ...(moduleValueAliases.length > 0 && { moduleValueAliases: [...moduleValueAliases] }),
+        ...(moduleValueAliases.constructed && { moduleConstructedValues: moduleValueAliases.constructed }),
+        ...(configurationItems.length > 0 && { configurationItems }),
+        ...(tree.rootNode.hasError && { parseRecovery: true, parseErrorRegions: parseErrorRegions(tree.rootNode) }),
         ...(moduleAssigned.size > 0 && { moduleAssignedNames: [...moduleAssigned].sort() }),
         imports: [],
         exports: []
@@ -843,6 +1395,40 @@ function iterableBindingTypes(typeNode) {
     return typeName ? [typeName] : [];
 }
 
+// Subscript contracts of builtin/typing containers (fix #359, starlette-
+// measured): `params: dict[str, Convertor]` makes `params[key]` a Convertor;
+// `items: list[Conv]` makes `items[0]` a Conv. The element is the declared
+// value slot of the annotation, never guessed: unions, Any/object, bare
+// type variables and heterogeneous tuples abstain.
+const PY_MAPPING_ANNOTATIONS = new Set([
+    'dict', 'Dict', 'Mapping', 'MutableMapping', 'OrderedDict', 'defaultdict',
+    'DefaultDict',
+]);
+const PY_SEQUENCE_ANNOTATIONS = new Set([
+    'list', 'List', 'Sequence', 'MutableSequence', 'deque', 'Deque',
+]);
+function subscriptElementContract(typeNode) {
+    const outerRaw = typeNode && typeNode.type === 'type' && typeNode.namedChildCount > 0
+        ? typeNode.namedChild(0) : typeNode;
+    const outer = genericTypeParts(outerRaw);
+    if (!outer) return null;
+    let element = null;
+    if (PY_MAPPING_ANNOTATIONS.has(outer.base) && outer.args.length === 2) {
+        element = outer.args[1];
+    } else if (PY_SEQUENCE_ANNOTATIONS.has(outer.base) && outer.args.length === 1) {
+        element = outer.args[0];
+    } else if (['tuple', 'Tuple'].includes(outer.base) && outer.args.length === 2 &&
+        outer.args[1]?.type === 'ellipsis') {
+        element = outer.args[0];
+    }
+    if (!element) return null;
+    const type = typeNameFromExpr(unwrapTypeNode(element));
+    if (!type || type === 'Any' || type === 'object' || type === 'None' ||
+        /^[A-Z][A-Z0-9]?$/.test(type)) return null;
+    const qualifier = typeQualifierFromExpr(unwrapTypeNode(element));
+    return { type, ...(qualifier && { qualifier }), node: element };
+}
+
 function patternIdentifiers(node, out = []) {
     if (!node) return out;
     if (node.type === 'identifier') {
@@ -864,6 +1450,12 @@ function enclosingPythonClassName(node) {
     return null;
 }
 
+const FIELD_CONTRACT_VALUE_NODES = new Set([
+    'call', 'attribute', 'subscript', 'binary_operator', 'boolean_operator',
+    'comparison_operator', 'list', 'dictionary', 'set', 'tuple', 'string',
+    'concatenated_string', 'parameters', 'decorator',
+]);
+
 function explicitInstanceFieldContracts(tree, parser) {
     const result = new Map();
     const parseCommentType = comment => {
@@ -877,16 +1469,20 @@ function explicitInstanceFieldContracts(tree, parser) {
         const assignment = statement?.namedChild(0);
         return assignment?.childForFieldName('type') || null;
     };
-    traverseTreeCached(tree.rootNode, node => {
+    traverseTree(tree.rootNode, node => {
+        // Only statements can declare an annotated instance field. Value
+        // expressions and parameter/default/decorator trees contain no
+        // such statements, so do not materialize all their descendants.
+        if (FIELD_CONTRACT_VALUE_NODES.has(node.type)) return false;
         if (node.type !== 'expression_statement') return true;
         const assignment = node.namedChild(0);
-        if (assignment?.type !== 'assignment') return true;
+        if (assignment?.type !== 'assignment') return false;
         const left = assignment.childForFieldName('left');
         if (left?.type !== 'attribute' ||
-            left.childForFieldName('object')?.text !== 'self') return true;
+            left.childForFieldName('object')?.text !== 'self') return false;
         const field = left.childForFieldName('attribute')?.text;
         const className = enclosingPythonClassName(node);
-        if (!field || !className) return true;
+        if (!field || !className) return false;
         let typeNode = assignment.childForFieldName('type');
         if (!typeNode) {
             const parent = node.parent;
@@ -899,16 +1495,16 @@ function explicitInstanceFieldContracts(tree, parser) {
                 }
             }
         }
-        if (!typeNode) return true;
+        if (!typeNode) return false;
         const type = typeNameFromAnnotation(typeNode);
         const itemTypes = iterableBindingTypes(typeNode);
-        if (!type && itemTypes.length === 0) return true;
+        if (!type && itemTypes.length === 0) return false;
         if (!result.has(className)) result.set(className, new Map());
         result.get(className).set(field, {
             ...(type && { type }),
             ...(itemTypes.length > 0 && { itemTypes }),
         });
-        return true;
+        return false;
     });
     return result;
 }
@@ -1050,6 +1646,13 @@ function narrowedReceiverType(refNode, receiverName, declaredUnion) {
     return undefined;
 }
 
+/** `Union[Foo, None]` names Foo (fix #402); a union of several types names none. */
+function unionMemberName(node) {
+    const members = (genericTypeParts(node)?.args || []).filter(arg => arg &&
+        arg.type !== 'none' && !(arg.type === 'identifier' && arg.text === 'None'));
+    return members.length === 1 ? typeNameFromExpr(members[0]) : undefined;
+}
+
 function typeNameFromExpr(node) {
     if (!node) return undefined;
     switch (node.type) {
@@ -1074,6 +1677,7 @@ function typeNameFromExpr(node) {
         case 'subscript': {
             // typing.Optional[Foo] parses as subscript when base is dotted
             const base = typeNameFromExpr(node.childForFieldName('value'));
+            if (base === 'Union') return unionMemberName(node);
             if (PY_TYPE_WRAPPERS.has(base)) {
                 return typeNameFromExpr(node.childForFieldName('subscript'));
             }
@@ -1082,6 +1686,7 @@ function typeNameFromExpr(node) {
         case 'generic_type': {
             // Optional[Foo] / Mapping[str, int] in annotation position
             const base = typeNameFromExpr(node.namedChild(0));
+            if (base === 'Union') return unionMemberName(node);
             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;
@@ -1372,6 +1977,108 @@ function pythonScopeBoundNames(scopeNode) {
     return names;
 }
 
+/** Type of the innermost scope node (function, lambda, class, module). */
+function pythonEnclosingScopeType(node) {
+    for (let parent = node?.parent; parent; parent = parent.parent) {
+        if (['function_definition', 'async_function_definition', 'lambda',
+            'class_definition', 'module'].includes(parent.type)) return parent.type;
+    }
+    return 'module';
+}
+
+/** Innermost enclosing function of a node; null at module/class/lambda level. */
+function pythonEnclosingFunctionNode(node) {
+    for (let parent = node?.parent; parent; parent = parent.parent) {
+        if (parent.type === 'function_definition' ||
+            parent.type === 'async_function_definition') return parent;
+        if (parent.type === 'lambda' || parent.type === 'class_definition') return null;
+    }
+    return null;
+}
+
+const scopeBindingCountsByTree = new WeakMap();
+
+/**
+ * How many times a function binds each local name (fix #381): parameters,
+ * assignment/augmented/walrus targets, loop and comprehension-free for
+ * targets, with/except `as` targets, imports, nested def/class names; a
+ * `global`/`nonlocal`/`del` of the name counts as two (never a single local
+ * binding). Nested functions, lambdas and classes are their own scopes.
+ */
+function pythonBindingCount(fnNode, name) {
+    let byId = scopeBindingCountsByTree.get(fnNode.tree);
+    if (!byId) { byId = new Map(); scopeBindingCountsByTree.set(fnNode.tree, byId); }
+    let counts = byId.get(fnNode.id);
+    if (!counts) {
+        counts = new Map();
+        const add = (id, n = 1) => { if (id) counts.set(id, (counts.get(id) || 0) + n); };
+        // Only names in binding position: `self.x = ...` / `a[i] = ...`
+        // bind no local.
+        const addTarget = (target) => {
+            if (!target) return;
+            if (target.type === 'identifier') { add(target.text); return; }
+            if (['pattern_list', 'tuple_pattern', 'list_pattern', 'tuple', 'list',
+                'parenthesized_expression', 'list_splat_pattern', 'list_splat'].includes(target.type)) {
+                for (const item of target.namedChildren) addTarget(item);
+            }
+        };
+        const params = fnNode.childForFieldName('parameters');
+        if (params) {
+            for (const param of params.namedChildren) {
+                const id = param.type === 'identifier' ? param
+                    : (param.childForFieldName('name') || param.namedChild(0));
+                if (id?.type === 'identifier') add(id.text);
+            }
+        }
+        const walk = (node) => {
+            for (const child of node.namedChildren) {
+                if (child.type === 'function_definition' ||
+                    child.type === 'async_function_definition' ||
+                    child.type === 'class_definition') {
+                    add(child.childForFieldName('name')?.text);
+                    continue;
+                }
+                if (child.type === 'lambda') continue;
+                if (child.type === 'assignment' || child.type === 'augmented_assignment') {
+                    addTarget(child.childForFieldName('left'));
+                } else if (child.type === 'named_expression') {
+                    addTarget(child.childForFieldName('name'));
+                } else if (child.type === 'for_statement' || child.type === 'for_in_clause') {
+                    addTarget(child.childForFieldName('left'));
+                } else if (child.type === 'as_pattern') {
+                    addTarget(child.childForFieldName('alias') || child.namedChild(child.namedChildCount - 1));
+                } else if (child.type === 'except_clause') {
+                    for (const part of child.namedChildren) {
+                        if (part.type === 'as_pattern') continue;
+                        if (part.type === 'identifier' && part.previousSibling?.type === 'as') add(part.text);
+                    }
+                } else if (child.type === 'import_statement' || child.type === 'import_from_statement') {
+                    for (const part of child.namedChildren) {
+                        if (part.type === 'aliased_import') {
+                            add(part.childForFieldName('alias')?.text);
+                        } else if (part.type === 'dotted_name' &&
+                            !(child.type === 'import_from_statement' && part === child.childForFieldName('module_name'))) {
+                            add(part.text.split('.')[0]);
+                        }
+                    }
+                } else if (child.type === 'global_statement' || child.type === 'nonlocal_statement' ||
+                    child.type === 'delete_statement') {
+                    for (const id of patternIdentifiers(child)) add(id, 2);
+                }
+                walk(child);
+            }
+        };
+        const body = fnNode.childForFieldName('body');
+        if (body) walk(body);
+        byId.set(fnNode.id, counts);
+    }
+    return counts.get(name) || 0;
+}
+
+function pythonSingleLocalBinding(fnNode, name) {
+    return pythonBindingCount(fnNode, name) === 1;
+}
+
 function pythonScopeBindsName(scopeNode, name) {
     return pythonScopeBoundNames(scopeNode).has(name);
 }
@@ -1481,12 +2188,100 @@ function isPythonNameShadowedAt(refNode, name) {
                 }
             }
             const body = parent.childForFieldName('body');
-            return body ? pythonScopeBindsName(body, name) : false;
+            if (body && pythonScopeBindsName(body, name)) {
+                // `global name` makes the function's binding the module's.
+                return !pythonDeclaresScopeName(body, name);
+            }
+            // Unbound here: a nested function reads the enclosing function
+            // scopes (closures) before the module (fix #402); class bodies
+            // are skipped, as Python skips them.
+            if (body && pythonDeclaresScopeName(body, name)) return false;
         }
     }
     return false;
 }
 
+/**
+ * The start line (decorators included) of the enclosing function a closure
+ * reference binds `name` in (fix #402): null when the reference's own
+ * function (or a comprehension or loop around it) binds it, or no enclosing
+ * function does. A lambda is a function of its own (fix #403): the call
+ * records name it as the reference's enclosing function, so a name its
+ * enclosing def binds is a closure name.
+ */
+function pythonClosureScopeLine(refNode, name) {
+    let first = true;
+    for (let parent = refNode.parent; parent; parent = parent.parent) {
+        if (parent.type === 'lambda') {
+            const params = parent.childForFieldName('parameters');
+            if (params?.namedChildren.some(param => (param.type === 'identifier' ? param
+                : param.childForFieldName('name'))?.text === name)) return null;
+            first = false;
+            continue;
+        }
+        if (PY_COMPREHENSIONS.has(parent.type)) {
+            if (parent.namedChildren.some(clause => clause.type === 'for_in_clause' &&
+                pythonTargetBindsName(clause.childForFieldName('left'), name))) return null;
+            continue;
+        }
+        if (parent.type !== 'function_definition' && parent.type !== 'async_function_definition') continue;
+        const params = parent.childForFieldName('parameters');
+        const body = parent.childForFieldName('body');
+        const bindsParam = !!params && params.namedChildren.some(param => {
+            const id = param.type === 'identifier' ? param : (param.childForFieldName('name') || param.namedChild(0));
+            return id?.type === 'identifier' && id.text === name;
+        });
+        if (body && pythonDeclaresScopeName(body, name)) return null;
+        if (bindsParam || (body && pythonScopeBindsName(body, name))) {
+            if (first) return null;
+            const start = parent.parent?.type === 'decorated_definition' ? parent.parent : parent;
+            return start.startPosition.row + 1;
+        }
+        first = false;
+    }
+    return null;
+}
+
+/** Shadow fields of a bare reference: `localShadow`, and the enclosing
+ * function a closure binds it in. */
+function pythonShadowFields(refNode, name) {
+    if (!isPythonNameShadowedAt(refNode, name)) return null;
+    const scope = pythonClosureScopeLine(refNode, name);
+    return scope ? { localShadow: true, localShadowScope: scope } : { localShadow: true };
+}
+
+/** Names a function body declares `global` (not in nested scopes),
+ * memoized per tree and body node (fix #402). */
+const globalNamesByTree = new WeakMap();
+function pythonGlobalNames(body) {
+    let byId = globalNamesByTree.get(body.tree);
+    if (!byId) { byId = new Map(); globalNamesByTree.set(body.tree, byId); }
+    let names = byId.get(body.id);
+    if (names) return names;
+    names = new Set();
+    // Prefilter: no `global` keyword in the body, no declaration.
+    if (body.text.includes('global')) {
+        const stack = [body];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (node.type === 'global_statement') {
+                for (const child of node.namedChildren) if (child.type === 'identifier') names.add(child.text);
+                continue;
+            }
+            if (node !== body && (node.type === 'function_definition' || node.type === 'class_definition' ||
+                node.type === 'lambda')) continue;
+            for (let i = node.namedChildCount - 1; i >= 0; i--) stack.push(node.namedChild(i));
+        }
+    }
+    byId.set(body.id, names);
+    return names;
+}
+
+/** Whether a function body declares `global name` (not in nested scopes). */
+function pythonDeclaresScopeName(body, name) {
+    return pythonGlobalNames(body).has(name);
+}
+
 /**
  * Whether an uppercase call target is a local VALUE binding rather than a
  * class declaration.
@@ -1637,8 +2432,145 @@ function pythonModuleAliases(tree) {
     return aliases;
 }
 
-function findCallsInCode(code, parser) {
+// Annotation positions whose value Python evaluates as an expression.
+const PY_ANNOTATION_OWNERS = new Set(['typed_parameter', 'typed_default_parameter', 'function_definition', 'assignment']);
+
+/**
+ * String annotations holding calls (fix #398F): `def f(v: "Annotated[int,
+ * typer.Argument()]")`. A forward reference is an expression the runtime
+ * evaluates (`typing.get_type_hints`), so the calls it spells are calls.
+ * Plain one-line string literals only (no prefix, escape or
+ * interpolation); the result lists the byte ranges of their quotes.
+ */
+function annotationStringQuotes(tree) {
+    const quotes = [];
+    for (const holder of getCachedNodeList(tree.rootNode).nodes) {
+        if (holder.type !== 'type') continue;
+        const string = holder.namedChildCount === 1 ? holder.namedChild(0) : null;
+        if (string?.type !== 'string' || string.startPosition.row !== string.endPosition.row) continue;
+        const owner = holder.parent;
+        if (!owner || !PY_ANNOTATION_OWNERS.has(owner.type)) continue;
+        const field = owner.type === 'function_definition' ? 'return_type' : 'type';
+        if (!sameNode(owner.childForFieldName(field), holder)) continue;
+        const parts = string.children;
+        if (parts.length !== 3 || parts[0].type !== 'string_start' || parts[1].type !== 'string_content' ||
+            parts[2].type !== 'string_end') continue;
+        const start = parts[0].text;
+        if (start !== '"' && start !== "'") continue;
+        const content = parts[1];
+        if (content.namedChildCount > 0 || !content.text.includes('(')) continue;
+        quotes.push({ open: parts[0].startIndex, close: parts[2].startIndex,
+            contentStart: content.startIndex, contentEnd: content.endIndex });
+    }
+    return quotes;
+}
+
+/**
+ * References to the file's function-local classes (fix #398F): the row of
+ * the one class declaration the name binds at the call (the receiver's
+ * constructor, a class qualifier, a bare constructor call), or 0 when a
+ * parameter, assignment or second declaration binds it too. Query-time
+ * identity proofs read this instead of parsing the file again.
+ */
+function annotateLocalClassReferences(tree, calls, classNodes) {
+    const names = new Set();
+    for (const definition of classNodes) {
+        if (definition.parent?.type === 'module') continue;
+        for (let parent = definition.parent; parent; parent = parent.parent) {
+            if (parent.type === 'function_definition' || parent.type === 'lambda') {
+                const name = definition.childForFieldName('name')?.text;
+                if (name) names.add(name);
+                break;
+            }
+        }
+    }
+    if (names.size === 0) return;
+    const memo = new Map();
+    const rowAt = (start, name) => {
+        if (!Number.isInteger(start)) return undefined;
+        let node = tree.rootNode.descendantForIndex(start);
+        if (node?.text !== name) {
+            for (let owner = node?.parent; owner && owner.startIndex === start; owner = owner.parent) {
+                const value = owner.childForFieldName('right') || owner.childForFieldName('value');
+                if (value?.type === 'call') {
+                    node = value.childForFieldName('function');
+                    break;
+                }
+            }
+        }
+        if (node?.text !== name && node?.parent?.type === 'attribute') {
+            node = node.parent.childForFieldName('object');
+        }
+        if (!node || node.text !== name) return 0;
+        const scope = referenceScope(node, 'python', memo, name, { includeClasses: true });
+        return scope?.defRows?.length === 1 ? scope.defRows[0] + 1 : 0;
+    };
+    for (const call of calls) {
+        if (!call.isMethod && !call.receiver && names.has(call.name)) {
+            const row = rowAt(call.callSite?.start, call.name);
+            if (row !== undefined) call.localClassRow = row;
+        }
+        if (call.isMethod && call.receiver && !call.receiverType && names.has(call.receiver)) {
+            const row = rowAt(call.callSite?.start ?? call.callStart, call.receiver);
+            if (row !== undefined) call.receiverLocalClassRow = row;
+        }
+        // Kept beside the evidence (never inside it: the evidence object is
+        // a provenance fact), tied to the evidence position it was read at.
+        const evidence = call.receiverTypeEvidence;
+        if (call.receiverTypeSource === 'constructor' && evidence && names.has(call.receiverType)) {
+            const row = rowAt(evidence.start, call.receiverType);
+            if (row !== undefined) call.receiverTypeLocalClassRef = { start: evidence.start, row };
+        }
+    }
+}
+
+function findCallsInCode(code, parser, options = {}) {
     const tree = parseTree(parser, code);
+    const sink = { classNodes: [] };
+    const calls = findCallsInTree(code, tree, parser, sink);
+    annotateLocalClassReferences(tree, calls, sink.classNodes);
+    if (options.stringAnnotations === false || !/(?::|->)\s*["'][^"'\n]*\(/.test(code)) return calls;
+    const quotes = annotationStringQuotes(tree);
+    if (quotes.length === 0) return calls;
+    // The same source with those quotes blanked parses the annotation as
+    // the expression it is, at the same offsets; only calls inside the
+    // blanked strings are taken from it, and only where it parses clean.
+    const chars = code.split('');
+    for (const quote of quotes) {
+        chars[quote.open] = ' ';
+        chars[quote.close] = ' ';
+    }
+    const masked = chars.join('');
+    const maskedTree = parseTree(parser, masked);
+    const clean = quotes.filter(quote => {
+        const node = maskedTree.rootNode.descendantForIndex(quote.contentStart, quote.contentEnd);
+        return node && !node.hasError && !node.isMissing;
+    });
+    if (clean.length === 0) return calls;
+    const inside = call => {
+        const start = call.callSite?.start;
+        return Number.isInteger(start) &&
+            clean.some(quote => start >= quote.contentStart && start < quote.contentEnd);
+    };
+    const extra = findCallsInTree(masked, maskedTree, parser)
+        .filter(inside).map(call => ({ ...call, stringAnnotation: true }));
+    if (extra.length === 0) return calls;
+    const position = call => [call.line, call.callSite?.column ?? call.column ?? 0];
+    const merged = [...calls];
+    for (const call of extra) {
+        const [line, column] = position(call);
+        let at = merged.length;
+        while (at > 0) {
+            const [l, c] = position(merged[at - 1]);
+            if (l < line || (l === line && c <= column)) break;
+            at--;
+        }
+        merged.splice(at, 0, call);
+    }
+    return merged;
+}
+
+function findCallsInTree(code, tree, parser, sink = null) {
     const calls = [];
     const instanceFieldContracts = explicitInstanceFieldContracts(tree, parser);
     // Same-file callable return contracts are a closed type source for loop
@@ -1646,6 +2578,7 @@ function findCallsInCode(code, parser) {
     // `parse_items() -> list[Item]` without guessing about external code.
     const callableIterableTypes = new Map();
     traverseTreeCached(tree.rootNode, node => {
+        if (sink && node.type === 'class_definition') sink.classNodes.push(node);
         if (node.type !== 'function_definition') return true;
         const name = node.childForFieldName('name')?.text;
         const returnType = node.childForFieldName('return_type');
@@ -1676,6 +2609,8 @@ function findCallsInCode(code, parser) {
     const localIterationSources = new Map(); // loop variable -> declared iterable path + tuple index
     const localDictValueTypes = new Map(); // local dict -> exact string-key value types
     const localSubscriptSources = new Map(); // local value -> exact typed container selected by []
+    const localSubscriptElements = new Map(); // container binding -> declared element contract (fix #359)
+    const localSubscriptElementsStack = [];
     const localVarStdlibContracts = new Map(); // variable -> stdlib module proving its type flow
     const assignmentRhsReceiverTypes = new Map(); // call-node id -> pre-assignment type and origin
     const constructedReceiverVars = new Set(); // exact constructor-result bindings
@@ -1688,6 +2623,10 @@ function findCallsInCode(code, parser) {
     // 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();
+    // One-hop local aliases of attribute paths (fix #381):
+    // `config = self.config; config.load()` receives through `self.config`.
+    // name -> { node: the aliased attribute node, scope: function node id }.
+    const localFieldAliases = new Map();
     const memberAliasesStack = [];  // function-scoped save/restore, like localVarTypes
     // Exact class-value aliases: `_Segment = Segment` makes later
     // `_Segment.line()` dispatch through the imported/local class object.
@@ -1719,25 +2658,61 @@ function findCallsInCode(code, parser) {
         for (let i = 0; i < argsNode.namedChildCount; i++) {
             const arg = argsNode.namedChild(i);
             if (arg.type.endsWith('comment')) continue;
-            // Handle f-string explicitly
-            if (arg.type === 'string') {
-                // f-string detection: tree-sitter-python wraps interpolations as 'interpolation' children.
-                // If any interpolation child exists, this is interpolated; extract literal prefix.
-                let interp = false;
-                let prefix = '';
-                for (let j = 0; j < arg.namedChildCount; j++) {
-                    const sc = arg.namedChild(j);
-                    if (sc.type === 'interpolation') { interp = true; break; }
-                    if (sc.type === 'string_content') prefix += sc.text;
+            return stringValueOf(arg);
+        }
+        return null;
+    };
+    const stringValueOf = (arg) => {
+        // Handle f-string explicitly
+        if (arg.type === 'string') {
+            // f-string detection: tree-sitter-python wraps interpolations as 'interpolation' children.
+            // If any interpolation child exists, this is interpolated; extract literal prefix.
+            let interp = false;
+            let prefix = '';
+            for (let j = 0; j < arg.namedChildCount; j++) {
+                const sc = arg.namedChild(j);
+                if (sc.type === 'interpolation') { interp = true; break; }
+                if (sc.type === 'string_content') prefix += sc.text;
+            }
+            if (interp) {
+                return { value: prefix + (prefix.endsWith('*') ? '' : '*'), interp: true };
+            }
+        }
+        return _extractStringArg(arg);
+    };
+
+    // fix #366: keyword request configuration — `session.request(
+    // method="POST", url="/api/items")`, `send(url="/x")`. Returns
+    // { url, interp, method? } when a `url=` keyword carries a string.
+    // Whether the callee performs HTTP is decided at query time.
+    const getRequestConfig = (callNode) => {
+        const argsNode = callNode.childForFieldName('arguments');
+        if (!argsNode) return null;
+        let url = null;
+        let method = null;
+        for (let i = 0; i < argsNode.namedChildCount; i++) {
+            const arg = argsNode.namedChild(i);
+            if (arg.type !== 'keyword_argument') continue;
+            const nameNode = arg.childForFieldName('name');
+            const valueNode = arg.childForFieldName('value');
+            if (!nameNode || !valueNode || valueNode.type !== 'string') continue;
+            // `path=` is overwhelmingly a filesystem path in Python APIs;
+            // only `url=` names a request target.
+            if (nameNode.text === 'url' && !url) {
+                const v = stringValueOf(valueNode);
+                if (v && typeof v.value === 'string' && v.value.length > 0) {
+                    url = { value: v.value, interp: !!v.interp, key: nameNode.text };
                 }
-                if (interp) {
-                    return { value: prefix + (prefix.endsWith('*') ? '' : '*'), interp: true };
+            } else if (nameNode.text === 'method') {
+                const v = _extractStringArg(valueNode);
+                if (v && !v.interp && typeof v.value === 'string' && v.value.length > 0) {
+                    method = v.value.toUpperCase();
                 }
-                return _extractStringArg(arg);
             }
-            return _extractStringArg(arg);
         }
-        return null;
+        if (!url) return null;
+        return { url: url.value, key: url.key, ...(url.interp && { interp: true }),
+            ...(method && { method }) };
     };
 
     // Helper to check if a node is a non-callable literal
@@ -2075,6 +3050,7 @@ function findCallsInCode(code, parser) {
                 [...localDictValueTypes].map(([name, values]) =>
                     [name, new Map(values)])));
             localSubscriptSourcesStack.push(new Map(localSubscriptSources));
+            localSubscriptElementsStack.push(new Map(localSubscriptElements));
             localVarStdlibContractsStack.push(new Map(localVarStdlibContracts));
             constructedReceiverVarsStack.push(new Set(constructedReceiverVars));
             withBindingVarsStack.push(new Set(withBindingVars));
@@ -2109,6 +3085,12 @@ function findCallsInCode(code, parser) {
                     localSubscriptSources.delete(name);
                 }
             }
+            for (const name of localSubscriptElements.keys()) {
+                if ((body && pythonScopeBindsName(body, name)) ||
+                    functionParameterBindsName(node, name)) {
+                    localSubscriptElements.delete(name);
+                }
+            }
             for (const name of classValueAliases.keys()) {
                 if ((body && pythonScopeBindsName(body, name)) ||
                     functionParameterBindsName(node, name)) {
@@ -2151,6 +3133,10 @@ function findCallsInCode(code, parser) {
                 else localVarUnionTypes.delete(nameNode.text);
                 if (itemTypes.length > 0) localIterableTypes.set(nameNode.text, itemTypes);
                 else localIterableTypes.delete(nameNode.text);
+                const elementContract = parameterPattern?.type === 'identifier'
+                    ? subscriptElementContract(typeNode) : null;
+                if (elementContract) localSubscriptElements.set(nameNode.text, elementContract);
+                else localSubscriptElements.delete(nameNode.text);
             }
         }
 
@@ -2257,6 +3243,9 @@ function findCallsInCode(code, parser) {
                     else localVarUnionTypes.delete(left.text);
                     if (itemTypes.length > 0) localIterableTypes.set(left.text, itemTypes);
                     else localIterableTypes.delete(left.text);
+                    const elementContract = subscriptElementContract(typeNode);
+                    if (elementContract) localSubscriptElements.set(left.text, elementContract);
+                    else localSubscriptElements.delete(left.text);
                 }
                 memberAliases.delete(left.text); // any assignment rebinds the name
                 constructedReceiverVars.delete(left.text);
@@ -2270,6 +3259,7 @@ function findCallsInCode(code, parser) {
                     localVarTypeQualifiers.delete(left.text);
                     localVarUnionTypes.delete(left.text);
                     localIterableTypes.delete(left.text);
+                    localSubscriptElements.delete(left.text);
                     localIterationSources.delete(left.text);
                     localDictValueTypes.delete(left.text);
                     localVarStdlibContracts.delete(left.text);
@@ -2357,6 +3347,21 @@ function findCallsInCode(code, parser) {
                 }
                 if (!typeNode && right?.type === 'subscript') {
                     const base = right.childForFieldName('value');
+                    // Declared container element (fix #359): `c = params[k]`
+                    // with `params: dict[str, Convertor]` types c. A slice
+                    // (`items[1:]`) is a container, not an element.
+                    const element = base?.type === 'identifier' && base.text !== left.text
+                        ? localSubscriptElements.get(base.text) : null;
+                    const subscriptKey = right.childForFieldName('subscript');
+                    if (element && subscriptKey?.type !== 'slice' &&
+                        !declaredVarTypes.get(left.text)) {
+                        localVarTypes.set(left.text, element.type, 'annotation', element.node);
+                        if (element.qualifier) {
+                            localVarTypeQualifiers.set(left.text, element.qualifier);
+                        } else {
+                            localVarTypeQualifiers.delete(left.text);
+                        }
+                    }
                     if (base?.type === 'identifier' && base.text !== left.text) {
                         const rootType = localVarTypes.get(base.text);
                         if (rootType) {
@@ -2376,7 +3381,14 @@ function findCallsInCode(code, parser) {
                     localVarTypes.set(left.text, roundTripType, 'flow', node);
                     localVarStdlibContracts.set(left.text, 'pickle');
                 }
-                if (right?.type === 'identifier') {
+                // A class-body assignment binds a class attribute, never a
+                // name of the enclosing function (fix #381): `Connection =
+                // Mock` inside a local class leaves the function's
+                // `Connection(...)` calls alone.
+                const classBodyAssignment = pythonEnclosingScopeType(node) === 'class_definition';
+                if (right?.type === 'identifier' && classBodyAssignment) {
+                    // attribute binding only
+                } else if (right?.type === 'identifier') {
                     aliases.set(left.text, right.text);
                     const classValue = !typeNode && isDirectScopeAssignment(node)
                         ? exactConstructorInfo(right) : null;
@@ -2393,6 +3405,49 @@ function findCallsInCode(code, parser) {
                             receiver: objNode?.type === 'identifier' ? objNode.text : null,
                             attr: attrName.text,
                         });
+                        // A bound method read through a typed receiver
+                        // (`loads = registry.loads`, `run = Client().run`,
+                        // fix #400) references the method: a rename edits
+                        // the attribute, never the variable holding it.
+                        let valueType = null;
+                        let valueFields = null;
+                        if (objNode?.type === 'identifier' && !['self', 'cls'].includes(objNode.text) &&
+                            !moduleAliases.has(objNode.text)) {
+                            valueType = localVarTypes.get(objNode.text) || null;
+                            if (valueType) valueFields = localVarTypes.fields(objNode.text, valueType);
+                        } else if (objNode?.type === 'call') {
+                            const ctor = exactConstructorInfo(objNode.childForFieldName('function'));
+                            if (ctor && !ctor.qualifier) {
+                                valueType = ctor.type;
+                                valueFields = { receiverTypeSource: 'constructor',
+                                    receiverTypeEvidence: { ...typeOrigin('constructor', objNode), type: ctor.type } };
+                            }
+                        }
+                        if (valueType) {
+                            // The receiver context a call on it carries.
+                            const recv = objNode.type === 'identifier' ? objNode.text : null;
+                            calls.push({
+                                callSite: typeOrigin('call', attrName),
+                                name: attrName.text,
+                                line: attrName.startPosition.row + 1,
+                                isMethod: true,
+                                ...(recv && { receiver: recv }),
+                                receiverType: valueType,
+                                ...valueFields,
+                                ...(recv && localVarTypeQualifiers.get(recv) && {
+                                    receiverTypeQualifier: localVarTypeQualifiers.get(recv),
+                                }),
+                                ...(recv && localVarStdlibContracts.has(recv) && {
+                                    receiverTypeStdlibModule: localVarStdlibContracts.get(recv),
+                                }),
+                                ...((!recv || constructedReceiverVars.has(recv)) && { receiverConstructed: true }),
+                                ...(recv && withBindingVars.has(recv) && { receiverWithBinding: true }),
+                                ...(recv && isShadowedByLocal(objNode, recv) && { receiverLocalBinding: true }),
+                                isFunctionReference: true,
+                                memberRead: true,
+                                enclosingFunction: getCurrentEnclosingFunction(),
+                            });
+                        }
                     }
                 }
                 // Track partial(fn, ...) aliases: fast_process = partial(process, mode='fast')
@@ -2423,6 +3478,37 @@ function findCallsInCode(code, parser) {
                         }
                     }
                 }
+                // One-hop local alias (fix #381): a function local bound
+                // exactly once, by `x = y` or `x = self.attr`, receives
+                // like its initializer. A second binding anywhere in the
+                // function (reassignment, loop target, global/nonlocal)
+                // leaves it untyped.
+                localFieldAliases.delete(left.text);
+                if (!typeNode && right && right.text !== left.text &&
+                    (right.type === 'identifier' || right.type === 'attribute')) {
+                    const scope = pythonEnclosingFunctionNode(node);
+                    if (scope && pythonSingleLocalBinding(scope, left.text)) {
+                        if (right.type === 'identifier' && localVarTypes.has(right.text) &&
+                            !localVarUnionTypes.has(right.text)) {
+                            localVarTypes.set(left.text, localVarTypes.get(right.text),
+                                localVarTypes.origins.get(right.text) || 'flow');
+                            if (localVarTypeQualifiers.has(right.text)) {
+                                localVarTypeQualifiers.set(left.text, localVarTypeQualifiers.get(right.text));
+                            }
+                            if (constructedReceiverVars.has(right.text)) constructedReceiverVars.add(left.text);
+                            if (localVarStdlibContracts.has(right.text)) {
+                                localVarStdlibContracts.set(left.text, localVarStdlibContracts.get(right.text));
+                            }
+                        } else if (right.type === 'attribute') {
+                            const path = attributeReceiverPath(right);
+                            if (path && path.root !== left.text &&
+                                (path.root === 'self' || path.root === 'cls' ||
+                                    pythonBindingCount(scope, path.root) <= 1)) {
+                                localFieldAliases.set(left.text, { node: right, scope: scope.id });
+                            }
+                        }
+                    }
+                }
                 // Track non-callable assignments.
                 // First: explicit literal check (handles dicts-with-lambdas correctly)
                 if (right && isNonCallableInit(right)) {
@@ -2538,6 +3624,7 @@ function findCallsInCode(code, parser) {
                     // Direct call: foo()
                     const resolvedName = aliases.get(funcNode.text);
                     const firstArg = getFirstStringArg(node);
+                    const requestConfig = argCount > 0 ? getRequestConfig(node) : null;
                     calls.push({
                         callSite: typeOrigin('call', funcNode),
                         name: funcNode.text,
@@ -2551,14 +3638,22 @@ function findCallsInCode(code, parser) {
                         ...(argSpread && { argSpread: true }),
                         enclosingFunction,
                         uncertain,
-                        ...(isShadowedByLocal(funcNode, funcNode.text) && { localShadow: true }),
-                        ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
+                        ...pythonShadowFields(funcNode, funcNode.text),
+                        ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
+                        ...(requestConfig && { requestConfig })
                     });
                 }
             } else if (funcNode.type === 'attribute') {
                 // Method/attribute call: obj.foo() or self.attr.foo()
                 const attrNode = funcNode.childForFieldName('attribute');
-                const objNode = funcNode.childForFieldName('object');
+                let objNode = funcNode.childForFieldName('object');
+                // fix #381: `config.load()` after `config = self.config`
+                // receives exactly like `self.config.load()`.
+                if (objNode?.type === 'identifier' && localFieldAliases.has(objNode.text) &&
+                    !localVarTypes.has(objNode.text)) {
+                    const alias = localFieldAliases.get(objNode.text);
+                    if (alias.scope === pythonEnclosingFunctionNode(objNode)?.id) objNode = alias.node;
+                }
 
                 if (attrNode) {
                     let receiver = objNode?.type === 'identifier' ? objNode.text : undefined;
@@ -2629,6 +3724,7 @@ function findCallsInCode(code, parser) {
                     // Literal receivers carry their builtin type: {}.get() can
                     // never be a project class method
                     let subscriptReceiverType;
+                    let subscriptElementReceiver = null;
                     let receiverSubscriptRoot;
                     let receiverSubscriptRootType;
                     let receiverSubscriptRootTypeQualifier;
@@ -2645,6 +3741,12 @@ function findCallsInCode(code, parser) {
                                 subscriptReceiverType =
                                     localDictValueTypes.get(base.text)?.get(key);
                             }
+                            const element = localSubscriptElements.get(base.text);
+                            if (!subscriptReceiverType && element &&
+                                objNode.childForFieldName('subscript')?.type !== 'slice') {
+                                subscriptReceiverType = element.type;
+                                subscriptElementReceiver = element;
+                            }
                         }
                     }
                     if (!receiverSubscriptRoot && receiver) {
@@ -2695,7 +3797,7 @@ function findCallsInCode(code, parser) {
                     }
                     const receiverTypeQualifier = receiver
                         ? localVarTypeQualifiers.get(receiver)
-                        : undefined;
+                        : subscriptElementReceiver?.qualifier;
                     const receiverRootType = receiverPath
                         ? localVarTypes.get(receiverPath.root) : undefined;
                     const dottedReceiver = receiverPath
@@ -2710,8 +3812,11 @@ function findCallsInCode(code, parser) {
                     const receiverIsModule = !!receiver && moduleAliases.has(receiver) &&
                         !localVarTypes.has(receiver);
                     const firstArg = getFirstStringArg(node);
+                    const requestConfig = argCount > 0 ? getRequestConfig(node) : null;
                     const capabilityGuard = receiverCapabilityGuard(
                         node, objNode, attrNode.text);
+                    let awaitParent = node.parent;
+                    while (awaitParent?.type === 'parenthesized_expression') awaitParent = awaitParent.parent;
                     calls.push({
                         callSite: typeOrigin('call', attrNode),
                         name: attrNode.text,
@@ -2720,6 +3825,11 @@ function findCallsInCode(code, parser) {
                         // the account's ground set is keyed by the name's line
                         line: attrNode.startPosition.row + 1,
                         isMethod: true,
+                        // `await x.m()` and `f(x.m())` (fix #402): the value
+                        // is awaited or passed on; audit-async skips them.
+                        ...(awaitParent?.type === 'await' && { awaited: true }),
+                        ...((awaitParent?.type === 'argument_list' || awaitParent?.type === 'keyword_argument') &&
+                            { passedAsArgument: true }),
                         receiver,
                         ...(receiverType && { receiverType,
                             ...(narrowedType || comprehensionType ? {
@@ -2733,7 +3843,11 @@ function findCallsInCode(code, parser) {
                                 receiver && !localVarTypes.has(receiver) && rhsReceiver?.type === receiverType
                                     ? { receiverTypeSource: rhsReceiver.receiverTypeSource,
                                         receiverTypeEvidence: rhsReceiver.receiverTypeEvidence } :
-                                receiver ? localVarTypes.fields(receiver, receiverType) : {
+                                receiver ? localVarTypes.fields(receiver, receiverType) :
+                                subscriptElementReceiver ? {
+                                    receiverTypeSource: 'annotation',
+                                    receiverTypeEvidence: typeOrigin('annotation', subscriptElementReceiver.node),
+                                } : {
                                     receiverTypeSource: 'literal', receiverTypeEvidence: typeOrigin('literal', objNode),
                                 }),
                         }),
@@ -2788,7 +3902,8 @@ function findCallsInCode(code, parser) {
                         ...(argSpread && { argSpread: true }),
                         enclosingFunction,
                         uncertain,
-                        ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
+                        ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
+                        ...(requestConfig && { requestConfig })
                     });
                 }
             }
@@ -2820,7 +3935,7 @@ function findCallsInCode(code, parser) {
                             isMethod: false,
                             isFunctionReference: true,
                             isPotentialCallback: true,
-                            ...(isShadowedByLocal(arg, arg.text) && { localShadow: true }),
+                            ...pythonShadowFields(arg, arg.text),
                             enclosingFunction
                         });
                     }
@@ -2868,7 +3983,7 @@ function findCallsInCode(code, parser) {
                                         isMethod: false,
                                         isFunctionReference: true,
                                         isPotentialCallback: true,
-                                        ...(isShadowedByLocal(val, val.text) && { localShadow: true }),
+                                        ...pythonShadowFields(val, val.text),
                                         enclosingFunction
                                     });
                                 }
@@ -2925,6 +4040,13 @@ function findCallsInCode(code, parser) {
                         localDictValueTypes.set(name, values);
                     }
                 }
+                const savedSubscriptElements = localSubscriptElementsStack.pop();
+                if (savedSubscriptElements) {
+                    localSubscriptElements.clear();
+                    for (const [name, element] of savedSubscriptElements) {
+                        localSubscriptElements.set(name, element);
+                    }
+                }
                 const savedSubscriptSources = localSubscriptSourcesStack.pop();
                 if (savedSubscriptSources) {
                     localSubscriptSources.clear();
@@ -3326,10 +4448,43 @@ function findExportsInCode(code, parser) {
  * @param {object} [tree] - Pre-parsed tree (per-operation cache); parsed here when absent
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
-function findUsagesInCode(code, name, parser, tree) {
+function findUsagesInCode(code, name, parser, tree, options = {}) {
     tree = tree || parseTree(parser, code);
+    const usages = findUsagesInTree(code, name, parser, tree, options);
+    // Names inside string annotations that spell calls (fix #398F) are code:
+    // the annotation's expression, parsed from the same source with the
+    // quotes blanked (offsets unchanged).
+    if (!/(?::|->)\s*["'][^"'\n]*\(/.test(code)) return usages;
+    const quotes = annotationStringQuotes(tree).filter(quote =>
+        code.slice(quote.contentStart, quote.contentEnd).includes(name));
+    if (quotes.length === 0) return usages;
+    const chars = code.split('');
+    for (const quote of quotes) {
+        chars[quote.open] = ' ';
+        chars[quote.close] = ' ';
+    }
+    const masked = chars.join('');
+    const maskedTree = parseTree(parser, masked);
+    const ranges = [];
+    for (const quote of quotes) {
+        const node = maskedTree.rootNode.descendantForIndex(quote.contentStart, quote.contentEnd);
+        if (!node || node.hasError || node.isMissing) continue;
+        const start = maskedTree.rootNode.descendantForIndex(quote.contentStart).startPosition;
+        ranges.push({ row: start.row, from: start.column, to: start.column + (quote.contentEnd - quote.contentStart) });
+    }
+    if (ranges.length === 0) return usages;
+    const extra = findUsagesInTree(masked, name, parser, maskedTree, options).filter(usage =>
+        ranges.some(range => usage.line === range.row + 1 && usage.column >= range.from && usage.column < range.to));
+    if (extra.length === 0) return usages;
+    return [...usages, ...extra.map(usage => ({ ...usage, stringAnnotation: true }))]
+        .sort((a, b) => a.line - b.line || a.column - b.column);
+}
+
+function findUsagesInTree(code, name, parser, tree, options = {}) {
     const usages = [];
     const moduleAliases = pythonModuleAliases(tree);
+    // Lexical scope verdicts (fix #392) only for refactoring internals.
+    const scopeMemo = options.lexicalScopes ? new Map() : null;
 
     visitNameNodes(tree, code, name, (node) => {
         // Only look for identifiers with the matching name
@@ -3372,11 +4527,19 @@ function findUsagesInCode(code, name, parser, tree) {
                      sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
-            // Definition: parameter
+            // Definition: parameter name. A default VALUE is a reference
+            // evaluated in the enclosing scope (fix #392).
             else if (parent.type === 'parameter' ||
-                     parent.type === 'default_parameter' ||
-                     parent.type === 'typed_parameter' ||
-                     parent.type === 'typed_default_parameter') {
+                     parent.type === 'parameters' ||
+                     parent.type === 'lambda_parameters' ||
+                     ((parent.type === 'default_parameter' ||
+                       parent.type === 'typed_default_parameter') &&
+                      sameNode(parent.childForFieldName('name'), node)) ||
+                     (parent.type === 'typed_parameter' &&
+                      sameNode(parent.namedChild(0), node)) ||
+                     ((parent.type === 'list_splat_pattern' ||
+                       parent.type === 'dictionary_splat_pattern') &&
+                      /^(parameters|lambda_parameters|typed_parameter)$/.test(parent.parent?.type || ''))) {
                 usageType = 'definition';
             }
             // Definition: assignment target (x = ...)
@@ -3439,7 +4602,11 @@ function findUsagesInCode(code, name, parser, tree) {
             }
         }
 
-        usages.push({ line, column, usageType });
+        // Where a bare reference resolves (fix #392): plan edits it only
+        // when the language's scoping proves it names the renamed binding.
+        const scope = scopeMemo && usageType === 'reference'
+            ? scopeFields(referenceScope(node, 'python', scopeMemo)) : null;
+        usages.push({ line, column, usageType, ...scope });
         return true;
     });
 
@@ -3454,7 +4621,7 @@ function findUsagesInCode(code, name, parser, tree) {
  * @returns {Map<string, Map<string, string>>} className -> (attrName -> typeName)
  */
 function findInstanceAttributeTypes(code, parser, options = {}) {
-    const tree = parseTree(parser, code);
+    const tree = options.tree || parseTree(parser, code);
     const result = new Map(); // className -> Map(attrName -> typeName)
     const explicitContracts = explicitInstanceFieldContracts(tree, parser);
 
@@ -3504,8 +4671,10 @@ function findInstanceAttributeTypes(code, parser, options = {}) {
         return valueType === narrowedTypes[0] ? valueType : null;
     };
 
-    traverseTreeCached(tree.rootNode, (node) => {
-        if (node.type !== 'class_definition') return true;
+    traverseTree(tree.rootNode, (node) => {
+        if (node.type !== 'class_definition') {
+            return node.type !== 'expression_statement' && !FIELD_CONTRACT_VALUE_NODES.has(node.type);
+        }
 
         const classNameNode = node.childForFieldName('name');
         if (!classNameNode) return true;
@@ -3519,12 +4688,22 @@ function findInstanceAttributeTypes(code, parser, options = {}) {
         Object.defineProperty(attrTypes, 'origins', { value: attrOrigins });
         const externalFlows = new Map();
         Object.defineProperty(attrTypes, 'externalFlows', { value: externalFlows });
+        // Lines of the writes that typed each field (fix #381): a class name
+        // resolves where it is written, so a function-local class assigned
+        // to self.x names that local class, not a same-name module class.
+        const typeWrites = new Map();
+        const writeLines = new Map();
+        Object.defineProperty(attrTypes, 'writeLines', { value: writeLines });
+        const noteTypeWrite = (field, type, node) => {
+            if (!typeWrites.has(field)) typeWrites.set(field, []);
+            typeWrites.get(field).push({ type, line: node.startPosition.row + 1 });
+        };
         for (const [field, contract] of explicitContracts.get(className) || []) {
             if (contract.type) attrTypes.set(field, contract.type);
         }
         const methodReturns = new Map();
-        for (let i = 0; i < body.namedChildCount; i++) {
-            let member = body.namedChild(i);
+        const memberDefs = pythonClassBodyDefs(body);
+        for (let member of memberDefs) {
             if (member.type === 'decorated_definition') {
                 member = Array.from({ length: member.namedChildCount },
                     (_, index) => member.namedChild(index))
@@ -3581,8 +4760,7 @@ function findInstanceAttributeTypes(code, parser, options = {}) {
         }
 
         // Scan __init__ for self.X = ClassName(...) assignments
-        for (let i = 0; i < body.childCount; i++) {
-            let child = body.child(i);
+        for (let child of memberDefs) {
             // Handle decorated_definition wrapper
             if (child.type === 'decorated_definition') {
                 for (let j = 0; j < child.childCount; j++) {
@@ -3662,6 +4840,7 @@ function findInstanceAttributeTypes(code, parser, options = {}) {
                     extractConstructorName(rhs);
                 if (typeName) {
                     attrTypes.set(attrName, typeName);
+                    noteTypeWrite(attrName, typeName, assign);
                 } else if (rhs.type === 'call') {
                     const fn = rhs.childForFieldName('function');
                     if (fn?.type === 'attribute') {
@@ -3678,6 +4857,7 @@ function findInstanceAttributeTypes(code, parser, options = {}) {
                 } else if (rhs.type === 'identifier' && paramTypes.has(rhs.text)) {
                     // self.X = param where param has type annotation
                     attrTypes.set(attrName, paramTypes.get(rhs.text));
+                    noteTypeWrite(attrName, paramTypes.get(rhs.text), assign);
                 }
 
                 return true;
@@ -3694,8 +4874,7 @@ function findInstanceAttributeTypes(code, parser, options = {}) {
         const runtimeFieldWrites = new Map();
         const externalFieldWrites = new Map();
         const invalidRuntimeFields = new Set();
-        for (let i = 0; i < body.namedChildCount; i++) {
-            let member = body.namedChild(i);
+        for (let member of memberDefs) {
             if (member.type === 'decorated_definition') {
                 member = Array.from({ length: member.namedChildCount },
                     (_, index) => member.namedChild(index))
@@ -3715,7 +4894,7 @@ function findInstanceAttributeTypes(code, parser, options = {}) {
                 if (!field) return true;
                 let enclosing = assignment.parent;
                 while (enclosing && !['function_definition', 'lambda', 'class_definition'].includes(enclosing.type)) enclosing = enclosing.parent;
-                if (assignment.type !== 'assignment' || enclosing !== member) {
+                if (assignment.type !== 'assignment' || !sameNode(enclosing, member)) {
                     invalidRuntimeFields.add(field);
                     return true;
                 }
@@ -3772,6 +4951,9 @@ function findInstanceAttributeTypes(code, parser, options = {}) {
                 }
                 if (!runtimeFieldTypes.has(field)) runtimeFieldTypes.set(field, new Set());
                 runtimeFieldTypes.get(field).add(runtimeType);
+                if (directConstructor && runtimeType === directConstructor) {
+                    noteTypeWrite(field, runtimeType, assignment);
+                }
                 if (!runtimeFieldWrites.has(field)) runtimeFieldWrites.set(field, []);
                 runtimeFieldWrites.get(field).push({ type: runtimeType,
                     assignment: typeOrigin('field', assignment), expression: typeOrigin('field', right),
@@ -3797,6 +4979,11 @@ function findInstanceAttributeTypes(code, parser, options = {}) {
             }
         }
 
+        for (const [field, writes] of typeWrites) {
+            const lines = writes.filter(write => write.type === attrTypes.get(field))
+                .map(write => write.line);
+            if (lines.length > 0) writeLines.set(field, [...new Set(lines)].sort((a, b) => a - b));
+        }
         if (attrTypes.size > 0 || externalFlows.size > 0) {
             result.set(className, attrTypes);
         }
@@ -3807,6 +4994,119 @@ function findInstanceAttributeTypes(code, parser, options = {}) {
     return result;
 }
 
+const PY_STORE_CONTAINERS = new Set(['pattern_list', 'tuple_pattern', 'list_pattern', 'tuple', 'list',
+    'parenthesized_expression', 'list_splat_pattern', 'list_splat', 'expression_list']);
+
+/** Whether an attribute node is written (assigned, deleted, a loop or
+ * `with ... as` target), not read. */
+function isPythonStoreTarget(node) {
+    let target = node;
+    while (target.parent && PY_STORE_CONTAINERS.has(target.parent.type)) target = target.parent;
+    const parent = target.parent;
+    if (!parent) return false;
+    switch (parent.type) {
+        case 'assignment':
+        case 'augmented_assignment':
+        case 'for_statement':
+        case 'for_in_clause':
+            return sameNode(parent.childForFieldName('left'), target);
+        case 'as_pattern_target':
+        case 'delete_statement':
+            return true;
+        default:
+            return false;
+    }
+}
+
+/**
+ * What a class body does to its instance fields (fix #402): the class
+ * members it declares (defs, class-level assignments, nested classes,
+ * through compound statements), the fields its methods write on the
+ * instance or class (`self.x = ..`, `cls.x = ..`, augmented, deleted, loop
+ * and `with ... as` targets, nested functions included), and whether it
+ * writes fields dynamically (`setattr(self, ..)`, `self.__dict__`,
+ * `vars(self)`). Null when no class is declared at `line`.
+ */
+function findClassFieldFacts(tree, line, name) {
+    if (!tree) return null;
+    const row = line - 1;
+    let classNode = null;
+    const stack = [tree.rootNode];
+    while (stack.length > 0 && !classNode) {
+        const node = stack.pop();
+        if (node.startPosition.row > row || node.endPosition.row < row) continue;
+        if (node.type === 'class_definition') {
+            const nameNode = node.childForFieldName('name');
+            const start = node.parent?.type === 'decorated_definition' ? node.parent : node;
+            if (nameNode?.text === name && (start.startPosition.row === row || node.startPosition.row === row ||
+                nameNode.startPosition.row === row)) { classNode = node; break; }
+        }
+        for (let i = node.namedChildCount - 1; i >= 0; i--) stack.push(node.namedChild(i));
+    }
+    const body = classNode?.childForFieldName('body');
+    if (!body) return null;
+    const members = new Set();
+    const receivers = new Set(['self', 'cls']);
+    const addTargets = target => {
+        if (!target) return;
+        if (target.type === 'identifier') { members.add(target.text); return; }
+        if (PY_STORE_CONTAINERS.has(target.type)) {
+            for (let i = 0; i < target.namedChildCount; i++) addTargets(target.namedChild(i));
+        }
+    };
+    const visitBody = container => {
+        for (let i = 0; i < container.namedChildCount; i++) {
+            const child = container.namedChild(i);
+            const definition = child.type === 'decorated_definition' ? child.childForFieldName('definition') : child;
+            if (definition?.type === 'function_definition' || definition?.type === 'class_definition') {
+                const declared = definition.childForFieldName('name')?.text;
+                if (declared) members.add(declared);
+                if (definition.type === 'function_definition') {
+                    const params = definition.childForFieldName('parameters');
+                    const first = params?.namedChild(0);
+                    const firstName = first?.type === 'identifier' ? first.text
+                        : (first?.childForFieldName?.('name') || first?.namedChild(0))?.text;
+                    if (firstName) receivers.add(firstName);
+                }
+                continue;
+            }
+            if (child.type === 'expression_statement') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const expression = child.namedChild(j);
+                    if (expression.type === 'assignment' || expression.type === 'augmented_assignment') {
+                        addTargets(expression.childForFieldName('left'));
+                    }
+                }
+                continue;
+            }
+            if (PY_CLASS_BODY_COMPOUNDS.has(child.type)) visitBody(child);
+        }
+    };
+    visitBody(body);
+    const written = new Set();
+    let dynamic = false;
+    const pending = [body];
+    while (pending.length > 0) {
+        const node = pending.pop();
+        if (node.type === 'class_definition') continue;
+        if (node.type === 'attribute') {
+            const object = node.childForFieldName('object');
+            const attribute = node.childForFieldName('attribute');
+            if (object?.type === 'identifier' && receivers.has(object.text) && attribute) {
+                if (attribute.text === '__dict__') dynamic = true;
+                else if (isPythonStoreTarget(node)) written.add(attribute.text);
+            }
+        } else if (node.type === 'call') {
+            const fn = node.childForFieldName('function');
+            const first = node.childForFieldName('arguments')?.namedChild(0);
+            if (fn?.type === 'identifier' && (fn.text === 'setattr' || fn.text === 'vars' ||
+                fn.text === 'delattr') && first?.type === 'identifier' && receivers.has(first.text)) dynamic = true;
+        }
+        for (let i = node.namedChildCount - 1; i >= 0; i--) pending.push(node.namedChild(i));
+    }
+    return { members, written, dynamic };
+}
+
 /**
  * Extract constructor class name from an expression node.
  * Handles: ClassName(...), param or ClassName(...), (param or ClassName(...)),
@@ -3899,8 +5199,8 @@ function isEntryPoint(symbol) {
 /** Module-level pytest declarations. Decorator ownership is resolved by the
  * index; a decorator merely spelled `fixture` is not sufficient evidence.
  */
-function findPythonModuleEvidence(code, parser) {
-    const tree = parseTree(parser, code), references = [], wildcards = [];
+function findPythonModuleEvidence(code, parser, parsedTree) {
+    const tree = parsedTree || parseTree(parser, code), references = [], wildcards = [];
     traverseTree(tree.rootNode, node => {
         if (node.type === 'identifier' && node.text === '__all__') references.push(node);
         if (node.type === 'import_from_statement' && node.namedChildren.some(child => child.type === 'wildcard_import')) {
@@ -3913,7 +5213,7 @@ function findPythonModuleEvidence(code, parser) {
     let exports = null;
     if (references.length === 1) {
         const name = references[0], assignment = name.parent, value = assignment.childForFieldName('right');
-        if (assignment.type === 'assignment' && assignment.childForFieldName('left') === name &&
+        if (assignment.type === 'assignment' && sameNode(assignment.childForFieldName('left'), name) &&
             assignment.parent?.parent?.type === 'module' && ['list', 'tuple'].includes(value?.type)) {
             const literals = value.namedChildren.map(item => {
                 const content = item.type === 'string' && item.namedChildren.find(child => child.type === 'string_content');
@@ -3927,8 +5227,8 @@ function findPythonModuleEvidence(code, parser) {
     return { exports, wildcards };
 }
 
-function findPytestFunctions(code, parser) {
-    const tree = parseTree(parser, code);
+function findPytestFunctions(code, parser, parsedTree) {
+    const tree = parsedTree || parseTree(parser, code);
     const pathOf = node => {
         if (node?.type === 'identifier') return [node.text];
         if (node?.type !== 'attribute') return null;
@@ -4015,7 +5315,191 @@ function getBuiltinFieldType(moduleName, fieldName) {
     return PY_BUILTIN_FIELD_TYPES[`${moduleName}.${fieldName}`] || null;
 }
 
+/**
+ * Other bindings of `name` in the scope that holds the definition on
+ * `defLine` (fix #376). Python binds names at run time: every `def`,
+ * `class`, assignment target and import of the name in one scope (module,
+ * class body or function body, through if/elif/else, try/except/finally,
+ * with and loop blocks) is the SAME variable, so version-conditional
+ * definitions (`if sys.version_info >= ...: f = lib.f else: def f(...)`),
+ * try/except import fallbacks and class-body rebindings are alternatives a
+ * rename must change together. In a class body, bare reads of the name
+ * (`close = release`, `@prop.setter`) bind to the class-scope variable and
+ * are references to the member.
+ * @returns {{line, column, kind: 'definition'|'assignment'|'import'|'import-name'|'reference'}[]}
+ *   column is the byte column of the name token; 'import-name' is an
+ *   unaliased `from m import name` (its alias must be added, not renamed).
+ */
+function findScopeAlternativeBindings(tree, defLine, name) {
+    if (!tree || !name) return [];
+    const row = defLine - 1;
+    let defNode = null;
+    const stack = [tree.rootNode];
+    while (stack.length > 0 && !defNode) {
+        const node = stack.pop();
+        if (node.startPosition.row > row || node.endPosition.row < row) continue;
+        if ((node.type === 'function_definition' || node.type === 'class_definition')) {
+            const nameNode = node.childForFieldName('name');
+            if (nameNode && nameNode.text === name && nameNode.startPosition.row === row) {
+                defNode = node;
+                break;
+            }
+        }
+        for (let i = node.namedChildCount - 1; i >= 0; i--) stack.push(node.namedChild(i));
+    }
+    if (!defNode) return [];
+    let container = null;
+    for (let cur = defNode; cur.parent; cur = cur.parent) {
+        const parent = cur.parent;
+        if (parent.type === 'module') { container = parent; break; }
+        if (parent.type === 'block' && parent.parent &&
+            (parent.parent.type === 'class_definition' ||
+                parent.parent.type === 'function_definition')) {
+            container = parent;
+            break;
+        }
+    }
+    if (!container) return [];
+    const classBody = container.parent?.type === 'class_definition';
+    const out = [];
+    const push = (node, kind) => out.push({
+        line: node.startPosition.row + 1, column: node.startPosition.column, kind,
+    });
+    const references = expr => {
+        if (!classBody || !expr) return;
+        const refStack = [expr];
+        while (refStack.length > 0) {
+            const node = refStack.pop();
+            if (node.type === 'lambda' || node.type === 'function_definition' ||
+                node.type === 'class_definition' || node.type.endsWith('comprehension') ||
+                node.type === 'generator_expression') continue;
+            if (node.type === 'identifier') {
+                if (node.text === name) push(node, 'reference');
+                continue;
+            }
+            if (node.type === 'attribute') {
+                refStack.push(node.childForFieldName('object'));
+                continue;
+            }
+            if (node.type === 'keyword_argument') {
+                refStack.push(node.childForFieldName('value'));
+                continue;
+            }
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child) refStack.push(child);
+            }
+        }
+    };
+    const targets = (target, kind) => {
+        if (!target) return;
+        if (target.type === 'identifier') {
+            if (target.text === name) push(target, kind);
+            return;
+        }
+        if (['pattern_list', 'tuple_pattern', 'list_pattern', 'expression_list', 'tuple',
+            'list', 'parenthesized_expression'].includes(target.type)) {
+            for (let i = 0; i < target.namedChildCount; i++) targets(target.namedChild(i), kind);
+            return;
+        }
+        references(target);
+    };
+    const visit = node => {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (!child) continue;
+            switch (child.type) {
+                case 'function_definition':
+                case 'class_definition': {
+                    const nameNode = child.childForFieldName('name');
+                    if (nameNode && nameNode.text === name && child.startIndex !== defNode.startIndex) {
+                        push(nameNode, 'definition');
+                    }
+                    // Evaluated in this scope: base classes, return and
+                    // parameter annotations, parameter defaults - never the
+                    // parameter names themselves.
+                    references(child.childForFieldName('superclasses'));
+                    references(child.childForFieldName('return_type'));
+                    const params = child.childForFieldName('parameters');
+                    for (let j = 0; j < (params?.namedChildCount || 0); j++) {
+                        const param = params.namedChild(j);
+                        references(param.childForFieldName?.('type'));
+                        references(param.childForFieldName?.('value'));
+                    }
+                    break;
+                }
+                case 'decorated_definition':
+                    for (let j = 0; j < child.namedChildCount; j++) {
+                        const part = child.namedChild(j);
+                        if (part.type === 'decorator') references(part);
+                    }
+                    visit({ namedChildCount: 1, namedChild: () => child.childForFieldName('definition') });
+                    break;
+                case 'expression_statement':
+                    visit(child);
+                    break;
+                case 'assignment':
+                case 'augmented_assignment': {
+                    targets(child.childForFieldName('left'), 'assignment');
+                    references(child.childForFieldName('type'));
+                    const right = child.childForFieldName('right');
+                    if (right && right.type === 'assignment') visit({ namedChildCount: 1, namedChild: () => right });
+                    else references(right);
+                    break;
+                }
+                case 'import_from_statement':
+                case 'import_statement':
+                    for (let j = 0; j < child.namedChildCount; j++) {
+                        const item = child.namedChild(j);
+                        if (item.type === 'aliased_import') {
+                            const alias = item.childForFieldName('alias');
+                            if (alias && alias.text === name) push(alias, 'import');
+                        } else if (item.type === 'dotted_name' &&
+                            (child.type === 'import_statement' ||
+                                !sameNode(item, child.childForFieldName('module_name')))) {
+                            const parts = item.namedChildren || [];
+                            if (parts.length === 1 && parts[0].text === name) {
+                                push(parts[0], 'import-name');
+                            }
+                        }
+                    }
+                    break;
+                case 'if_statement':
+                case 'elif_clause':
+                case 'else_clause':
+                case 'try_statement':
+                case 'except_clause':
+                case 'except_group_clause':
+                case 'finally_clause':
+                case 'with_statement':
+                case 'for_statement':
+                case 'while_statement':
+                case 'block':
+                case 'match_statement':
+                case 'case_clause':
+                    if (child.type === 'for_statement') {
+                        targets(child.childForFieldName('left'), 'assignment');
+                        references(child.childForFieldName('right'));
+                        for (const field of ['body', 'alternative']) {
+                            const part = child.childForFieldName(field);
+                            if (part) visit({ namedChildCount: 1, namedChild: () => part });
+                        }
+                        break;
+                    }
+                    visit(child);
+                    break;
+                default:
+                    if (child.type !== 'comment' && child.type !== 'pass_statement') references(child);
+            }
+        }
+    };
+    visit(container);
+    out.sort((a, b) => a.line - b.line || a.column - b.column);
+    return out;
+}
+
 module.exports = {
+    findScopeAlternativeBindings,
     findPythonModuleEvidence,
     findFunctions,
     findClasses,
@@ -4025,6 +5509,7 @@ module.exports = {
     findExportsInCode,
     findUsagesInCode,
     findInstanceAttributeTypes,
+    findClassFieldFacts,
     getBuiltinCallReturnType,
     getBuiltinFieldType,
     findPytestFunctions,