ucn 5.5.1 → 5.5.2

package/languages/python.js

@@ -76,6 +76,94 @@ function pythonClassBodyDefs(body) {
     return out;
 }
 
+/** The nodes an assignment target binds, through tuple and list targets:
+ * identifiers (`kind` 'identifier') or attributes ('attribute'). */
+function pythonTargetNames(target, kind) {
+    const out = [];
+    const visit = node => {
+        if (!node) return;
+        if (node.type === kind) { out.push(node); return; }
+        if (['pattern_list', 'tuple_pattern', 'list_pattern', 'expression_list', 'tuple', 'list',
+            'parenthesized_expression'].includes(node.type)) {
+            for (let i = 0; i < node.namedChildCount; i++) visit(node.namedChild(i));
+        }
+    };
+    visit(target);
+    return out;
+}
+
+/** The first positional parameter's name of a function definition. */
+function pythonReceiverName(fn) {
+    const params = fn.childForFieldName('parameters');
+    for (let i = 0; i < (params?.namedChildCount || 0); i++) {
+        const param = params.namedChild(i);
+        if (param.type === 'identifier') return param.text;
+        if (['typed_parameter', 'default_parameter', 'typed_default_parameter'].includes(param.type)) {
+            const name = param.childForFieldName('name') || param.namedChild(0);
+            return name?.type === 'identifier' ? name.text : null;
+        }
+        if (param.type !== 'positional_separator') return null;
+    }
+    return null;
+}
+
+/** Whether a nested function or lambda binds `name` as a parameter. */
+function pythonParamsBind(fn, name) {
+    const params = fn.childForFieldName('parameters');
+    for (let i = 0; i < (params?.namedChildCount || 0); i++) {
+        let param = params.namedChild(i);
+        if (param.type === 'default_parameter' || param.type === 'typed_default_parameter') {
+            param = param.childForFieldName('name');
+        } else if (param.type === 'typed_parameter') {
+            param = param.namedChild(0);
+        }
+        if (param?.type === 'list_splat_pattern' || param?.type === 'dictionary_splat_pattern') {
+            param = param.namedChild(0);
+        }
+        if (param?.type === 'identifier' && param.text === name) return true;
+    }
+    return false;
+}
+
+/** Instance attributes the methods of a class body assign on their receiver,
+ * one per name in source order, names in `declared` excluded (fix #430).
+ * A static method has no receiver; a nested class has its own; a nested
+ * function or lambda that rebinds the receiver's name assigns another value. */
+function pythonInstanceAttributes(bodyNode, declared) {
+    const out = [];
+    const seen = new Set(declared);
+    for (const def of pythonClassBodyDefs(bodyNode)) {
+        const fn = def.type === 'decorated_definition' ? def.childForFieldName('definition') : def;
+        if (def.type === 'decorated_definition' && def.namedChildren.some(child =>
+            child.type === 'decorator' && /^@\s*staticmethod\b/.test(child.text))) continue;
+        const receiver = fn && pythonReceiverName(fn);
+        const body = fn?.childForFieldName('body');
+        if (!receiver || !body) continue;
+        traverseTree(body, node => {
+            if (node.type === 'class_definition') return false;
+            if ((node.type === 'function_definition' || node.type === 'lambda') &&
+                pythonParamsBind(node, receiver)) return false;
+            if (node.type !== 'assignment' && node.type !== 'augmented_assignment') return true;
+            const type = node.type === 'assignment' ? node.childForFieldName('type') : null;
+            for (const target of pythonTargetNames(node.childForFieldName('left'), 'attribute')) {
+                const object = target.childForFieldName('object');
+                const attr = target.childForFieldName('attribute');
+                if (object?.type !== 'identifier' || object.text !== receiver || !attr) continue;
+                if (seen.has(attr.text)) continue;
+                // Reading the previous member on the RHS does not change
+                // the assignment's storage: `self.m = wrap(self.m)` creates
+                // an instance attribute even if the class inherits `m`.
+                seen.add(attr.text);
+                out.push({ name: attr.text, startLine: attr.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1, memberType: 'field', instanceAttribute: true,
+                    ...(type && { returnType: type.text, fieldType: type.text }) });
+            }
+            return true;
+        });
+    }
+    return out;
+}
+
 function parseTree(parser, code) {
     return safeParse(parser, code, undefined, PARSE_OPTIONS);
 }
@@ -243,6 +331,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 params: extractPythonParams(paramsNode),
                 paramsStructured,
                 startLine: decoratorStartLine,
+                sourceSpan: nodeToLocation(node.parent?.type === 'decorated_definition' ? node.parent : node, lines).sourceSpan,
                 endLine,
                 indent,
                 isAsync,
@@ -329,47 +418,33 @@ function pythonFunctionLocalScope(node) {
     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.)
-const _CONSTANT_PATTERN = /^[A-Z][A-Z0-9_]{1,}$/;
-// RHS types that are scalar/simple values (not dict/list which are handled separately)
-const _SCALAR_TYPES = new Set([
-    'string', 'concatenated_string', 'integer', 'float', 'true', 'false', 'none',
-    'unary_operator', 'binary_operator', 'tuple', 'set', 'parenthesized_expression',
-    'call', 'attribute', 'identifier', 'subscript',
-]);
-
 /**
  * Process a node for state object extraction (single-pass helper)
  * Returns true if node was matched, false otherwise
  */
 function _processState(node, objects, lines) {
-    if (node.type === 'expression_statement' && node.parent && node.parent.parent === null) {
-        const child = node.namedChild(0);
-        if (child && child.type === 'assignment') {
-            const leftNode = child.childForFieldName('left');
-            const rightNode = child.childForFieldName('right');
-
-            if (leftNode && leftNode.type === 'identifier' && rightNode) {
-                const name = leftNode.text;
-                const isObject = rightNode.type === 'dictionary';
-                const isArray = rightNode.type === 'list';
-
-                if ((isObject || isArray) && _STATE_PATTERN.test(name)) {
-                    const { startLine, endLine } = nodeToLocation(node, lines);
-                    objects.push({ name, startLine, endLine });
-                    return true;
-                } else if (_CONSTANT_PATTERN.test(name) && _SCALAR_TYPES.has(rightNode.type)) {
-                    // Module-level UPPER_CASE constants with scalar values
-                    const { startLine, endLine } = nodeToLocation(node, lines);
-                    objects.push({ name, startLine, endLine, isConstant: true });
-                    return true;
-                }
-            }
+    if (node.type !== 'assignment') return false;
+    for (let scope = node.parent; scope; scope = scope.parent) {
+        if (scope.type === 'function_definition' || scope.type === 'lambda' ||
+            scope.type === 'class_definition') return false;
+    }
+    if (node.parent?.type === 'expression_statement' &&
+        _processTypeAlias(node.parent, [], new Set(), lines)) return false;
+    const target = node.childForFieldName('left');
+    if (!target) return false;
+    const bindings = [];
+    const collect = pattern => {
+        if (pattern.type === 'identifier') bindings.push(pattern);
+        else if (['pattern_list', 'tuple_pattern', 'list_pattern', 'list_splat_pattern'].includes(pattern.type)) {
+            for (const child of pattern.namedChildren) collect(child);
         }
+    };
+    collect(target);
+    for (const binding of bindings) {
+        objects.push({ name: binding.text, startLine: binding.startPosition.row + 1,
+            endLine: nodeToLocation(node, lines).endLine });
     }
-    return false;
+    return bindings.length > 0;
 }
 
 /**
@@ -694,12 +769,12 @@ function pythonConfigurationItems(root, bindingNodes = null, reboundNodes = null
     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) => {
+    const add = (scope, name, kind, line, branch, target = null) => {
         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 });
+        names.get(name).push({ kind, line, branch, ...(target && { target }) });
     };
     const bindTarget = (scope, node, branch) => {
         if (!node) return;
@@ -753,8 +828,20 @@ function pythonConfigurationItems(root, bindingNodes = null, reboundNodes = null
             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;
+                        const left = expr.childForFieldName('left');
+                        const right = expr.childForFieldName('right');
+                        // An alias value (`f = other`, `f = mod.other`)
+                        // names what it binds (fix #424): the chase follows it.
+                        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) {
+                            add(scope, left.text, 'value', lineOf(left), branch, right.text);
+                        } else {
+                            bindTarget(scope, left, branch);
+                        }
+                        expr = expr.type === 'assignment' ? right : null;
                     }
                 }
                 return;
@@ -866,7 +953,8 @@ function pythonConfigurationItems(root, bindingNodes = null, reboundNodes = null
             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 })),
+                sites: sites.map(site => ({ kind: site.kind, line: site.line, branch: site.branch,
+                    ...(site.target && { target: site.target }) })),
                 clauses: [...statements].sort((a, b) => a - b).map(line => [line, clauseRanges.get(line) || []]),
             });
         }
@@ -1007,7 +1095,7 @@ function _processTypeAlias(node, classes, processedRanges, lines) {
     const rangeKey = `${node.startIndex}-${node.endIndex}`;
     if (processedRanges.has(rangeKey)) return true;
     processedRanges.add(rangeKey);
-    const { startLine, endLine } = nodeToLocation(node, lines);
+    const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
     const aliasOf = pythonAliasBase(valueNode);
     const aliasMembers = pythonAliasMembers(valueNode);
     classes.push({
@@ -1015,6 +1103,7 @@ function _processTypeAlias(node, classes, processedRanges, lines) {
         type: 'type',
         startLine,
         endLine,
+        sourceSpan,
         methods: [],
         members: [],
         ...(aliasOf && { aliasOf }),
@@ -1069,6 +1158,36 @@ function extractClassMembers(classNode, code) {
     const bodyNode = classNode.childForFieldName('body');
     if (!bodyNode) return members;
 
+    // A class-body assignment declares an attribute, including an annotated
+    // dataclass field and each name of a tuple target. Function and
+    // nested-class bodies have their own owners.
+    const declared = new Set();
+    traverseTree(bodyNode, node => {
+        if (node.type === 'function_definition' || node.type === 'class_definition') return false;
+        if (node.type !== 'assignment') return true;
+        const type = node.childForFieldName('type');
+        for (const name of pythonTargetNames(node.childForFieldName('left'), 'identifier')) {
+            declared.add(name.text);
+            members.push({ name: name.text, startLine: name.startPosition.row + 1,
+                endLine: node.endPosition.row + 1, memberType: 'field',
+                ...(type && { returnType: type.text, fieldType: type.text }) });
+        }
+        return true;
+    });
+    // An attribute a method assigns on its receiver (`self.x = v`, `self.x:
+    // T = v`, `self.x += v`) is an instance attribute of the class (fix
+    // #430): one declaration per name, the first in source order, unless
+    // the class body declares the name.
+    // A property the class body declares is a data descriptor: assigning
+    // it on the receiver runs its setter, never declares an attribute.
+    for (const def of pythonClassBodyDefs(bodyNode)) {
+        if (def.type !== 'decorated_definition') continue;
+        const name = def.childForFieldName('definition')?.childForFieldName('name')?.text;
+        if (name && def.namedChildren.some(child => child.type === 'decorator' &&
+            /^@\s*(?:property|[A-Za-z_]\w*\.(?:setter|deleter))\s*$/.test(child.text))) declared.add(name);
+    }
+    for (const attribute of pythonInstanceAttributes(bodyNode, declared)) members.push(attribute);
+
     for (const child of pythonClassBodyDefs(bodyNode)) {
         let funcNode = child;
         let decoratorStart = null;
@@ -1138,6 +1257,7 @@ function extractClassMembers(classNode, code) {
                     params: extractPythonParams(paramsNode),
                     paramsStructured,
                     startLine,
+                    sourceSpan: nodeToLocation(child, code).sourceSpan,
                     endLine,
                     memberType,
                     isAsync,
@@ -1625,6 +1745,30 @@ function narrowedReceiverType(refNode, receiverName, declaredUnion) {
                 if (remaining.length === 1) return remaining[0];
             }
         }
+        // A class pattern (fix #425, the Go type-switch rule): in `case
+        // Sq() as s:` the capture s is a Sq instance, and `match x: case
+        // Sq():` narrows x to Sq, in the clause's body. A union of class
+        // patterns names no single type.
+        if (parent.type === 'case_clause' && sameNode(parent.childForFieldName('consequence'), current)) {
+            const casePatterns = parent.namedChildren.filter(child => child.type === 'case_pattern');
+            const pattern = casePatterns.length === 1 ? casePatterns[0].namedChild(0) : null;
+            let classPattern = null;
+            if (pattern?.type === 'as_pattern') {
+                const target = pattern.namedChild(pattern.namedChildCount - 1);
+                const targetName = target?.type === 'as_pattern_target' ? target.namedChild(0)?.text : target?.text;
+                const inner = pattern.namedChild(0);
+                if (targetName === receiverName && inner?.type === 'case_pattern' &&
+                    inner.namedChild(0)?.type === 'class_pattern') classPattern = inner.namedChild(0);
+            } else if (pattern?.type === 'class_pattern') {
+                const subject = parent.parent?.parent?.type === 'match_statement'
+                    ? parent.parent.parent.childForFieldName('subject') : null;
+                if (subject?.type === 'identifier' && subject.text === receiverName) classPattern = pattern;
+            }
+            const dotted = classPattern?.namedChild(0);
+            if (dotted?.type === 'dotted_name' && dotted.namedChildCount > 0) {
+                return dotted.namedChild(dotted.namedChildCount - 1).text;
+            }
+        }
         if (parent.type === 'conditional_expression' &&
             parent.namedChildCount >= 3) {
             const consequence = parent.namedChild(0);
@@ -2242,6 +2386,102 @@ function pythonClosureScopeLine(refNode, name) {
     return null;
 }
 
+// Methods Python calls with the class as their first argument without a
+// decorator (data model: implicit classmethods).
+const PY_IMPLICIT_CLASS_METHODS = new Set(['__init_subclass__', '__class_getitem__']);
+
+/**
+ * A construction through a method's own receiver (fix #434): `cls(..)` in a
+ * classmethod, `type(self)(..)` and `self.__class__(..)` in an instance
+ * method build the method's class or a subclass of it. The receiver must be
+ * the method's first parameter, never rebound, and read from the method
+ * itself or a closure inside it. Returns the class (by its name line), the
+ * method, the receiver binding ('class' or 'instance') and the spelling of
+ * the callee, or null.
+ */
+function pythonOwnClassConstruction(callNode) {
+    const funcNode = callNode.childForFieldName('function');
+    let receiver = null, binding = null, spelling = null;
+    if (funcNode?.type === 'identifier') {
+        receiver = funcNode; binding = 'class'; spelling = funcNode.text;
+    } else if (funcNode?.type === 'call') {
+        const inner = funcNode.childForFieldName('function');
+        const args = funcNode.childForFieldName('arguments');
+        const named = args?.type === 'argument_list'
+            ? args.namedChildren.filter(child => !child.type.endsWith('comment')) : [];
+        if (inner?.type === 'identifier' && inner.text === 'type' && named.length === 1 &&
+            named[0].type === 'identifier') {
+            receiver = named[0]; binding = 'instance'; spelling = funcNode.text;
+        }
+    } else if (funcNode?.type === 'attribute' &&
+        funcNode.childForFieldName('attribute')?.text === '__class__' &&
+        funcNode.childForFieldName('object')?.type === 'identifier') {
+        receiver = funcNode.childForFieldName('object'); binding = 'instance'; spelling = '__class__';
+    }
+    if (!receiver) return null;
+    const name = receiver.text;
+    let method = null;
+    for (let parent = callNode.parent; parent && !method; parent = parent.parent) {
+        if (parent.type === 'class_definition' || parent.type === 'module') return null;
+        if (parent.type === 'lambda') {
+            const params = parent.childForFieldName('parameters');
+            if (params && pythonParametersBindName(params, name)) return null;
+        } else if (PY_COMPREHENSIONS.has(parent.type)) {
+            for (const clause of parent.namedChildren) {
+                if (clause.type === 'for_in_clause' &&
+                    pythonTargetBindsName(clause.childForFieldName('left'), name)) return null;
+            }
+        } else if (parent.type === 'function_definition' || parent.type === 'async_function_definition') {
+            const params = parent.childForFieldName('parameters');
+            const body = parent.childForFieldName('body');
+            if (params && pythonParametersBindName(params, name)) method = parent;
+            else if (body && pythonScopeBindsName(body, name)) return null;
+        }
+    }
+    if (!method) return null;
+    const params = method.childForFieldName('parameters');
+    const first = params?.namedChildren.find(child => !child.type.endsWith('comment'));
+    const body = method.childForFieldName('body');
+    if (first?.type !== 'identifier' || first.text !== name || (body && pythonScopeBindsName(body, name)) ||
+        isPythonIterationBindingAt(receiver, name)) return null;
+    const holder = method.parent?.type === 'decorated_definition' ? method.parent : method;
+    const classNode = holder.parent?.type === 'block' && holder.parent.parent?.type === 'class_definition'
+        ? holder.parent.parent : null;
+    const className = classNode?.childForFieldName('name');
+    const methodName = method.childForFieldName('name');
+    if (!className || !methodName) return null;
+    const decorators = holder.type === 'decorated_definition'
+        ? holder.namedChildren.filter(child => child.type === 'decorator').map(child => child.namedChild(0)?.text)
+        : [];
+    const classMethod = decorators.includes('classmethod') || PY_IMPLICIT_CLASS_METHODS.has(methodName.text);
+    if (binding === 'class' ? !classMethod
+        : classMethod || decorators.includes('staticmethod') || methodName.text === '__new__') return null;
+    const own = { name: className.text, line: className.startPosition.row + 1, method: methodName.text,
+        methodLine: methodName.startPosition.row + 1, receiver: name, binding, spelling };
+    // The receiver token names the class at the site (`self` of `type(self)`).
+    Object.defineProperty(own, 'receiverNode', { value: receiver, enumerable: false });
+    return own;
+}
+
+/** The `ownClass` field of a call record (fix #434). */
+function ownClassFields(callNode) {
+    const ownClass = pythonOwnClassConstruction(callNode);
+    return ownClass ? { ownClass } : null;
+}
+
+/** Whether a parameter list binds `name`. */
+function pythonParametersBindName(params, name) {
+    for (const param of params.namedChildren) {
+        let paramName = param.type === 'identifier' ? param
+            : (param.childForFieldName('name') || param.namedChild(0));
+        if (paramName && ['dictionary_splat_pattern', 'list_splat_pattern'].includes(paramName.type)) {
+            paramName = paramName.namedChild(0);
+        }
+        if (paramName?.type === 'identifier' && paramName.text === name) return true;
+    }
+    return false;
+}
+
 /** Shadow fields of a bare reference: `localShadow`, and the enclosing
  * function a closure binds it in. */
 function pythonShadowFields(refNode, name) {
@@ -2413,10 +2653,14 @@ function isPythonConstructorValueShadowedAt(refNode, name) {
     return classDeclarations > 1;
 }
 
+const moduleAliasesByTree = new WeakMap();
 function pythonModuleAliases(tree) {
+    const cached = moduleAliasesByTree.get(tree);
+    if (cached) return cached;
     const aliases = new Set();
-    traverseTreeCached(tree.rootNode, node => {
-        if (node.type !== 'import_statement') return true;
+    // A name query needs import statements, not a wrapper for every node
+    // in the file. Keep this source-only answer with its immutable tree.
+    for (const node of tree.rootNode.descendantsOfType('import_statement')) {
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (child.type === 'dotted_name') {
@@ -2427,8 +2671,8 @@ function pythonModuleAliases(tree) {
                 if (alias?.type === 'identifier') aliases.add(alias.text);
             }
         }
-        return true;
-    });
+    }
+    moduleAliasesByTree.set(tree, aliases);
     return aliases;
 }
 
@@ -3423,7 +3667,9 @@ function findCallsInTree(code, tree, parser, sink = null) {
                                     receiverTypeEvidence: { ...typeOrigin('constructor', objNode), type: ctor.type } };
                             }
                         }
-                        if (valueType) {
+                        const valuePath = !valueType && objNode?.type === 'attribute'
+                            ? attributeReceiverPath(objNode) : null;
+                        if (valueType || valuePath) {
                             // The receiver context a call on it carries.
                             const recv = objNode.type === 'identifier' ? objNode.text : null;
                             calls.push({
@@ -3432,19 +3678,27 @@ function findCallsInTree(code, tree, parser, sink = null) {
                                 line: attrName.startPosition.row + 1,
                                 isMethod: true,
                                 ...(recv && { receiver: recv }),
-                                receiverType: valueType,
+                                ...(valueType && { receiverType: valueType }),
                                 ...valueFields,
+                                ...(valuePath && {
+                                    receiverRoot: valuePath.root,
+                                    receiverField: valuePath.fields[valuePath.fields.length - 1],
+                                    receiverFields: valuePath.fields,
+                                    ...(localVarTypes.has(valuePath.root) && {
+                                        receiverRootType: localVarTypes.get(valuePath.root),
+                                    }),
+                                }),
                                 ...(recv && localVarTypeQualifiers.get(recv) && {
                                     receiverTypeQualifier: localVarTypeQualifiers.get(recv),
                                 }),
                                 ...(recv && localVarStdlibContracts.has(recv) && {
                                     receiverTypeStdlibModule: localVarStdlibContracts.get(recv),
                                 }),
-                                ...((!recv || constructedReceiverVars.has(recv)) && { receiverConstructed: true }),
+                                ...(((!recv && !valuePath) || constructedReceiverVars.has(recv)) && { receiverConstructed: true }),
                                 ...(recv && withBindingVars.has(recv) && { receiverWithBinding: true }),
                                 ...(recv && isShadowedByLocal(objNode, recv) && { receiverLocalBinding: true }),
                                 isFunctionReference: true,
-                                memberRead: true,
+                                ...(!valuePath && { memberRead: true }),
                                 enclosingFunction: getCurrentEnclosingFunction(),
                             });
                         }
@@ -3639,10 +3893,28 @@ function findCallsInTree(code, tree, parser, sink = null) {
                         enclosingFunction,
                         uncertain,
                         ...pythonShadowFields(funcNode, funcNode.text),
+                        ...ownClassFields(node),
                         ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
                         ...(requestConfig && { requestConfig })
                     });
                 }
+            } else if (funcNode.type === 'call') {
+                // `type(self)(..)` constructs the method's class (fix #434).
+                const ownClass = pythonOwnClassConstruction(node);
+                if (ownClass) {
+                    calls.push({
+                        callSite: typeOrigin('call', ownClass.receiverNode),
+                        column: ownClass.receiverNode.startPosition.column,
+                        name: ownClass.name,
+                        line: node.startPosition.row + 1,
+                        isMethod: false,
+                        argCount,
+                        ...(argSpread && { argSpread: true }),
+                        enclosingFunction,
+                        uncertain,
+                        ownClass,
+                    });
+                }
             } else if (funcNode.type === 'attribute') {
                 // Method/attribute call: obj.foo() or self.attr.foo()
                 const attrNode = funcNode.childForFieldName('attribute');
@@ -3670,7 +3942,8 @@ function findCallsInTree(code, tree, parser, sink = null) {
                     // Detect super().method() pattern
                     if (objNode?.type === 'call') {
                         const superFunc = objNode.childForFieldName('function');
-                        if (superFunc?.type === 'identifier' && superFunc.text === 'super') {
+                        if (superFunc?.type === 'identifier' && superFunc.text === 'super' &&
+                            objNode.childForFieldName('arguments')?.namedChildCount === 0) {
                             receiver = 'super';
                         }
                     }
@@ -3905,6 +4178,22 @@ function findCallsInTree(code, tree, parser, sink = null) {
                         ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
                         ...(requestConfig && { requestConfig })
                     });
+                    // `self.__class__(..)` constructs the method's class (fix #434).
+                    const ownClass = attrNode.text === '__class__' ? pythonOwnClassConstruction(node) : null;
+                    if (ownClass) {
+                        calls.push({
+                            callSite: typeOrigin('call', ownClass.receiverNode),
+                            column: ownClass.receiverNode.startPosition.column,
+                            name: ownClass.name,
+                            line: node.startPosition.row + 1,
+                            isMethod: false,
+                            argCount,
+                            ...(argSpread && { argSpread: true }),
+                            enclosingFunction,
+                            uncertain,
+                            ownClass,
+                        });
+                    }
                 }
             }
 
@@ -4602,6 +4891,16 @@ function findUsagesInTree(code, name, parser, tree, options = {}) {
             }
         }
 
+        // A module path segment (`from a.b import c`, `import a.b [as x]`)
+        // names a module, never a function, class or variable; the name of
+        // `from m import name as alias` is m's attribute, decided by m (fix
+        // #424). Neither is a reference resolved in this file's scopes.
+        const importRole = pythonImportTokenRole(node);
+        if (importRole) {
+            usages.push({ line, column, usageType, ...(importRole === 'module-path'
+                ? { modulePath: true } : { importSource: true }) });
+            return true;
+        }
         // 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'
@@ -4613,6 +4912,29 @@ function findUsagesInTree(code, name, parser, tree, options = {}) {
     return usages;
 }
 
+/**
+ * The role of an identifier inside an import statement (fix #424):
+ * 'module-path' for a segment of the imported module's dotted path,
+ * 'import-source' for the imported name of `from m import name as alias`,
+ * null otherwise (bound names and aliases).
+ */
+function pythonImportTokenRole(node) {
+    const dotted = node.parent;
+    if (dotted?.type !== 'dotted_name') return null;
+    const holder = dotted.parent;
+    if (!holder) return null;
+    if (holder.type === 'relative_import' || holder.type === 'import_statement') return 'module-path';
+    if (holder.type === 'import_from_statement') {
+        return sameNode(holder.childForFieldName('module_name'), dotted) ? 'module-path' : null;
+    }
+    if (holder.type === 'aliased_import' && sameNode(holder.childForFieldName('name'), dotted)) {
+        const statement = holder.parent?.type;
+        if (statement === 'import_statement') return 'module-path';
+        if (statement === 'import_from_statement') return 'import-source';
+    }
+    return null;
+}
+
 /**
  * Find instance attribute types from __init__ constructor assignments.
  * Parses self.X = ClassName(...) patterns in __init__ methods.
@@ -5085,10 +5407,13 @@ function findClassFieldFacts(tree, line, name) {
     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;
+    let nestedClassEnd = -1;
+    for (const node of body.descendantsOfType(['class_definition', 'attribute', 'call'])) {
+        if (node.startIndex < nestedClassEnd) continue;
+        if (node.type === 'class_definition') {
+            nestedClassEnd = node.endIndex;
+            continue;
+        }
         if (node.type === 'attribute') {
             const object = node.childForFieldName('object');
             const attribute = node.childForFieldName('attribute');
@@ -5102,7 +5427,6 @@ function findClassFieldFacts(tree, line, name) {
             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 };
 }
@@ -5498,7 +5822,33 @@ function findScopeAlternativeBindings(tree, defLine, name) {
     return out;
 }
 
+/**
+ * The annotated type of a plain receiver of an attribute reference (fix
+ * #424): `env.config` inside `def f(env: Environment)` reads a member of
+ * Environment when the parameter is the only binding of `env` in the scope
+ * the reference resolves to. `column` is the attribute token's column.
+ * Undefined when the receiver is rebound, unannotated or not a parameter.
+ */
+function annotatedReceiverType(tree, line, column, receiver) {
+    if (!tree || !receiver || receiver === 'self' || receiver === 'cls') return undefined;
+    const token = tree.rootNode.descendantForPosition({ row: line - 1, column });
+    const attribute = token?.parent;
+    if (attribute?.type !== 'attribute' || !sameNode(attribute.childForFieldName('attribute'), token)) return undefined;
+    const object = attribute.childForFieldName('object');
+    if (object?.type !== 'identifier' || object.text !== receiver) return undefined;
+    const { referenceScopeNode, pythonBindingSites } = require('./lexical-scope');
+    const scope = referenceScopeNode(object, receiver);
+    if (scope?.type !== 'function_definition') return undefined;
+    const sites = pythonBindingSites(scope, receiver);
+    if (sites.length !== 1) return undefined;
+    const parameter = sites[0].parent;
+    if (!parameter || !['typed_parameter', 'typed_default_parameter'].includes(parameter.type) ||
+        parameter.parent?.type !== 'parameters') return undefined;
+    return typeNameFromAnnotation(parameter.childForFieldName('type')) || undefined;
+}
+
 module.exports = {
+    annotatedReceiverType,
     findScopeAlternativeBindings,
     findPythonModuleEvidence,
     findFunctions,