ucn 5.5.1 → 5.5.3

package/languages/javascript.js

@@ -131,6 +131,9 @@ const FUNCTION_NODE_TYPES = new Set([
     'method_definition', 'generator_function', 'generator_function_declaration',
 ]);
 
+const JS_VALUE_WRAPPERS = new Set(['parenthesized_expression', 'as_expression', 'non_null_expression',
+    'satisfies_expression', 'type_assertion']);
+
 function unwrapValueExpression(node) {
     while (node && (node.type === 'parenthesized_expression' || node.type === 'as_expression' ||
         node.type === 'non_null_expression' || node.type === 'satisfies_expression' ||
@@ -142,26 +145,26 @@ function unwrapValueExpression(node) {
 }
 
 /** Names a binding pattern declares (identifiers, shorthand, rest, defaults' targets). */
-function collectPatternNames(pattern, out) {
+function collectPatternNames(pattern, out, withNodes = false) {
     if (!pattern) return;
     if (pattern.type === 'required_parameter' || pattern.type === 'optional_parameter') {
-        collectPatternNames(pattern.childForFieldName('pattern') || pattern.childForFieldName('name'), out);
+        collectPatternNames(pattern.childForFieldName('pattern') || pattern.childForFieldName('name'), out, withNodes);
         return;
     }
     if (pattern.type === 'identifier' || pattern.type === 'shorthand_property_identifier_pattern') {
-        out.push(pattern.text);
+        out.push(withNodes ? pattern : pattern.text);
         return;
     }
     if (pattern.type === 'pair_pattern' || pattern.type === 'pair') {
-        collectPatternNames(pattern.childForFieldName('value'), out);
+        collectPatternNames(pattern.childForFieldName('value'), out, withNodes);
         return;
     }
     if (pattern.type === 'assignment_pattern') {
-        collectPatternNames(pattern.childForFieldName('left') || pattern.childForFieldName('pattern'), out);
+        collectPatternNames(pattern.childForFieldName('left') || pattern.childForFieldName('pattern'), out, withNodes);
         return;
     }
     if (pattern.type === 'type_annotation') return;
-    for (let i = 0; i < pattern.namedChildCount; i++) collectPatternNames(pattern.namedChild(i), out);
+    for (let i = 0; i < pattern.namedChildCount; i++) collectPatternNames(pattern.namedChild(i), out, withNodes);
 }
 
 // Module-level alias: findCallsInCode declares its own one-argument
@@ -449,6 +452,47 @@ function objectPropertyName(nameNode) {
     return null;
 }
 
+// A non-computed method's key has the value of its identifier or string
+// literal. Class constructor identity uses that value, including escapes.
+function classMethodName(node) {
+    const raw = objectPropertyName(node);
+    if (raw == null || !raw.includes('\\')) return raw;
+    const string = node.type === 'string';
+    const escapes = { b: '\b', f: '\f', n: '\n', r: '\r', t: '\t', v: '\v', '0': '\0' };
+    let value = '';
+    for (let at = 0; at < raw.length; at++) {
+        if (raw[at] !== '\\') { value += raw[at]; continue; }
+        const escape = raw[++at];
+        if (escape === undefined) return null;
+        if (escape === 'u' || string && escape === 'x') {
+            const brace = escape === 'u' && raw[at + 1] === '{';
+            const start = at + (brace ? 2 : 1);
+            const end = brace ? raw.indexOf('}', start) : start + (escape === 'u' ? 4 : 2);
+            if (end <= start || end > raw.length) return null;
+            let code = 0;
+            for (let digit = start; digit < end; digit++) {
+                const point = raw.charCodeAt(digit);
+                const hex = point >= 48 && point <= 57 ? point - 48
+                    : point >= 65 && point <= 70 ? point - 55
+                        : point >= 97 && point <= 102 ? point - 87 : -1;
+                if (hex < 0) return null;
+                code = code * 16 + hex;
+                if (code > 0x10ffff) return null;
+            }
+            value += String.fromCodePoint(code);
+            at = brace ? end : end - 1;
+        } else if (!string) return null;
+        else if (escape === '\r' || escape === '\n' || escape === '\u2028' || escape === '\u2029') {
+            if (escape === '\r' && raw[at + 1] === '\n') at++;
+        } else {
+            if (escape >= '0' && escape <= '9' &&
+                (escape !== '0' || raw[at + 1] >= '0' && raw[at + 1] <= '9')) return null;
+            value += Object.hasOwn(escapes, escape) ? escapes[escape] : escape;
+        }
+    }
+    return value;
+}
+
 /**
  * Index function-valued object properties. Module-scope objects are dynamic
  * dispatch surfaces (`HANDLERS[command](...)`); without symbols for their
@@ -486,7 +530,7 @@ function appendObjectFunctionMembers(objectNode, functions, lines, extraFields =
         }
 
         const paramsNode = fnNode.childForFieldName('parameters');
-        const { startLine, endLine, indent } = nodeToLocation(prop, lines);
+        const { startLine, endLine, indent, sourceSpan } = nodeToLocation(prop, lines);
         const returnType = extractReturnType(fnNode);
         const generics = extractGenerics(fnNode);
         const docstring = extractJSDocstring(lines, startLine);
@@ -499,6 +543,7 @@ function appendObjectFunctionMembers(objectNode, functions, lines, extraFields =
             paramsStructured,
             startLine,
             endLine,
+            sourceSpan,
             indent,
             isArrow: fnNode.type === 'arrow_function',
             isGenerator: isGenerator(fnNode),
@@ -852,7 +897,7 @@ function _processFunction(node, functions, processedRanges, lines) {
         const paramsNode = node.childForFieldName('parameters');
 
         if (nameNode) {
-            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
             const returnType = extractReturnType(node);
             const returnedConcreteType = extractReturnedConcreteType(node);
             const generics = extractGenerics(node);
@@ -874,6 +919,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                 paramsStructured,
                 startLine,
                 endLine,
+                sourceSpan,
                 indent,
                 isArrow: false,
                 isGenerator: isGen,
@@ -905,7 +951,7 @@ function _processFunction(node, functions, processedRanges, lines) {
         if (!isBoundValue && nameNode && !processedRanges.has(rangeKey)) {
             processedRanges.add(rangeKey);
             const paramsNode = node.childForFieldName('parameters');
-            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
             const returnType = extractReturnType(node);
             const generics = extractGenerics(node);
             const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
@@ -917,6 +963,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                 paramsStructured,
                 startLine,
                 endLine,
+                sourceSpan,
                 indent,
                 isArrow: false,
                 isGenerator: isGenerator(node),
@@ -945,7 +992,7 @@ function _processFunction(node, functions, processedRanges, lines) {
         const paramsNode = node.childForFieldName('parameters');
 
         if (nameNode) {
-            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
             const returnType = extractReturnType(node);
             const generics = extractGenerics(node);
             const docstring = extractJSDocstring(lines, startLine);
@@ -958,6 +1005,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                 paramsStructured,
                 startLine,
                 endLine,
+                sourceSpan,
                 indent,
                 isArrow: false,
                 isGenerator: false,
@@ -974,12 +1022,16 @@ function _processFunction(node, functions, processedRanges, lines) {
     // Variable declarations with arrow functions or function expressions
     if (node.type === 'lexical_declaration' || node.type === 'variable_declaration') {
         if (processedRanges.has(rangeKey)) return false;
+        const declarators = node.namedChildren.filter(child => child.type === 'variable_declarator');
 
         for (let i = 0; i < node.namedChildCount; i++) {
             const declarator = node.namedChild(i);
             if (declarator.type === 'variable_declarator') {
                 const nameNode = declarator.childForFieldName('name');
-                const valueNode = declarator.childForFieldName('value');
+                // A function wrapped in parentheses, a cast or a satisfies
+                // clause (`((next) => ..) as Middleware`, fix #434) is the
+                // value the declaration binds.
+                const valueNode = unwrapValueExpression(declarator.childForFieldName('value'));
 
                 if (nameNode && valueNode) {
                     const isArrow = valueNode.type === 'arrow_function';
@@ -990,7 +1042,10 @@ function _processFunction(node, functions, processedRanges, lines) {
                         processedRanges.add(rangeKey);
                         const paramsNode = valueNode.childForFieldName('parameters') ||
                             valueNode.childForFieldName('parameter');
-                        const { startLine, endLine, indent } = nodeToLocation(node, lines);
+                        // A comma-separated declaration binds distinct functions.
+                        // Its other declarators are outside this callable's extent.
+                        const { startLine, endLine, indent } = nodeToLocation(
+                            declarators.length === 1 ? node : declarator, lines);
                         const returnType = extractReturnType(valueNode);
                         const generics = extractGenerics(valueNode);
                         const docstring = extractJSDocstring(lines, startLine);
@@ -1014,7 +1069,8 @@ function _processFunction(node, functions, processedRanges, lines) {
                             params: extractParams(paramsNode),
                             paramsStructured,
                             startLine,
-                            endLine,
+                            nameLine: nameNode.startPosition.row + 1,
+                            endLine, sourceSpan: nodeToLocation(valueNode, lines).sourceSpan,
                             indent,
                             isArrow,
                             isGenerator: isGen,
@@ -1051,7 +1107,8 @@ function _processFunction(node, functions, processedRanges, lines) {
                                     if (innerFn && (innerFn.type === 'arrow_function' || innerFn.type === 'function_expression')) {
                                         processedRanges.add(rangeKey);
                                         const paramsNode = innerFn.childForFieldName('parameters');
-                                        const { startLine, endLine, indent } = nodeToLocation(node, lines);
+                                        const { startLine, endLine, indent } = nodeToLocation(
+                                            declarators.length === 1 ? node : declarator, lines);
                                         const returnType = extractReturnType(innerFn);
                                         const generics = extractGenerics(innerFn);
                                         const docstring = extractJSDocstring(lines, startLine);
@@ -1066,11 +1123,14 @@ function _processFunction(node, functions, processedRanges, lines) {
                                             params: extractParams(paramsNode),
                                             paramsStructured,
                                             startLine,
+                                            nameLine: nameNode.startPosition.row + 1,
                                             endLine,
+                                            sourceSpan: nodeToLocation(innerFn, lines).sourceSpan,
                                             indent,
                                             isArrow: innerFn.type === 'arrow_function',
                                             isGenerator: false,
                                             modifiers,
+                                            ...lexicalOwnerRange(node),
                                             ...typeAnno,
                                             ...(generics && { generics }),
                                             ...(docstring && { docstring })
@@ -1184,6 +1244,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                         paramsStructured,
                         startLine,
                         endLine,
+                        sourceSpan: nodeToLocation(rightNode, lines).sourceSpan,
                         indent,
                         isArrow,
                         isGenerator: isGen,
@@ -1269,6 +1330,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                         paramsStructured,
                         startLine,
                         endLine,
+                        sourceSpan: nodeToLocation(child, lines).sourceSpan,
                         indent,
                         isArrow: child.type === 'arrow_function',
                         isGenerator: isGen,
@@ -1311,12 +1373,38 @@ function findFunctions(code, parser) {
  * Process a node for class/interface/type/enum extraction (single-pass helper)
  * Returns true if node was matched, false otherwise
  */
+/**
+ * The location of a class declaration from its first decorator (fix #423):
+ * `@Component({..}) export class C` places the decorators on the export
+ * statement, before `export`; the declaration starts there, as an
+ * undecorated-export or non-exported decorated class starts at its first
+ * token.
+ */
+function _decoratedDeclarationLocation(node, lines) {
+    const located = nodeToLocation(node, lines);
+    const wrapper = node.parent?.type === 'export_statement' ? node.parent : null;
+    let first = null;
+    for (let i = 0; wrapper && i < wrapper.namedChildCount; i++) {
+        const child = wrapper.namedChild(i);
+        if (child.type !== 'decorator') continue;
+        if (child.startIndex < node.startIndex) first = first || child;
+    }
+    if (!first) return located;
+    const startLine = first.startPosition.row + 1;
+    const indent = ((lines[first.startPosition.row] || '').match(/^(\s*)/) || ['', ''])[1].length;
+    return {
+        startLine, endLine: located.endLine, indent,
+        sourceSpan: { ...located.sourceSpan, start: first.startIndex, startLine,
+            startColumn: first.startPosition.column },
+    };
+}
+
 function _processClass(node, classes, processedRanges, lines) {
     // Class declarations (including abstract classes)
     if (node.type === 'class_declaration' || node.type === 'class' || node.type === 'abstract_class_declaration') {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = _decoratedDeclarationLocation(node, lines);
             const members = extractClassMembers(node, lines);
             const docstring = extractJSDocstring(lines, startLine);
             const generics = extractGenerics(node);
@@ -1326,10 +1414,14 @@ function _processClass(node, classes, processedRanges, lines) {
             const decoratorsWithArgs = extractDecoratorsWithArgs(node);
 
             const isAbstract = node.type === 'abstract_class_declaration';
+            const nameLine = nameNode.startPosition.row + 1;
             classes.push({
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
+                // A decorated class names itself below its first decorator.
+                ...(nameLine !== startLine && { nameLine }),
                 type: 'class',
                 members,
                 ...(isAbstract && { modifiers: ['abstract'] }),
@@ -1351,7 +1443,7 @@ function _processClass(node, classes, processedRanges, lines) {
     if (node.type === 'interface_declaration') {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const docstring = extractJSDocstring(lines, startLine);
             const generics = extractGenerics(node);
             const extendsInfo = extractInterfaceExtends(node);
@@ -1361,6 +1453,7 @@ function _processClass(node, classes, processedRanges, lines) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 type: 'interface',
                 members,
                 ...(docstring && { docstring }),
@@ -1375,7 +1468,7 @@ function _processClass(node, classes, processedRanges, lines) {
     if (node.type === 'type_alias_declaration') {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const docstring = extractJSDocstring(lines, startLine);
             const valueNode = node.childForFieldName('value');
             // `type ZodTypeAny = ZodType<any, any, any>;` — the alias IS the
@@ -1395,6 +1488,7 @@ function _processClass(node, classes, processedRanges, lines) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 type: 'type',
                 members,
                 ...(aliasOf && { aliasOf }),
@@ -1408,7 +1502,7 @@ function _processClass(node, classes, processedRanges, lines) {
     if (node.type === 'enum_declaration') {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const docstring = extractJSDocstring(lines, startLine);
             const members = extractEnumMembers(node, lines);
 
@@ -1416,6 +1510,7 @@ function _processClass(node, classes, processedRanges, lines) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 type: 'enum',
                 members,
                 ...(docstring && { docstring })
@@ -1435,13 +1530,14 @@ function _processClass(node, classes, processedRanges, lines) {
         // StoreMutators augmentations). The compiler merges it into the
         // TARGET module — never claimable, never importable by this "name".
         if (nameNode && nameNode.type !== 'string') {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const docstring = extractJSDocstring(lines, startLine);
 
             classes.push({
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 type: 'namespace',
                 members: [],
                 ...(docstring && { docstring })
@@ -1578,7 +1674,7 @@ function extractTypeMembers(bodyNode, code) {
             const nameNode = child.childForFieldName('name');
             const paramsNode = child.childForFieldName('parameters');
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
                 const returnType = extractReturnType(child);
                 const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
                 const typeAnno = buildTypeAnnotations(paramsStructured, returnType, code, startLine, true);
@@ -1588,6 +1684,7 @@ function extractTypeMembers(bodyNode, code) {
                     paramsStructured,
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType: 'method',
                     isMethod: true,
                     ...typeAnno
@@ -1596,7 +1693,7 @@ function extractTypeMembers(bodyNode, code) {
         } else if (child.type === 'property_signature') {
             const nameNode = child.childForFieldName('name');
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
                 // Declared property type (fix #219): raw annotation text —
                 // findCallers hops field receivers to it (this._map.has()),
                 // and function-typed properties ((arg) => T) count as
@@ -1607,6 +1704,7 @@ function extractTypeMembers(bodyNode, code) {
                     name: nameNode.text,
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType: 'field',
                     ...(fieldType && { fieldType })
                 });
@@ -1629,12 +1727,12 @@ function extractEnumMembers(enumNode, code) {
         if (child.type === 'enum_assignment') {
             const nameNode = child.childForFieldName('name');
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
-                members.push({ name: nameNode.text, startLine, endLine, memberType: 'field' });
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
+                members.push({ name: nameNode.text, startLine, endLine, sourceSpan, memberType: 'field' });
             }
         } else if (child.type === 'property_identifier') {
-            const { startLine, endLine } = nodeToLocation(child, code);
-            members.push({ name: child.text, startLine, endLine, memberType: 'field' });
+            const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
+            members.push({ name: child.text, startLine, endLine, sourceSpan, memberType: 'field' });
         }
     }
     return members;
@@ -1657,9 +1755,10 @@ function extractClassMembers(classNode, codeOrLines) {
             const nameNode = child.childForFieldName('name');
             const paramsNode = child.childForFieldName('parameters');
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
-                let name = nameNode.text;
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
+                let name = classMethodName(nameNode) === 'constructor' ? 'constructor' : nameNode.text;
                 const text = child.text;
+                const isStatic = child.children.some(part => part.type === 'static');
 
                 // Collect decorators from preceding siblings in the class body
                 const decorators = [];
@@ -1685,7 +1784,7 @@ function extractClassMembers(classNode, codeOrLines) {
                     if (staticMatch) name = staticMatch[1];
                 }
 
-                if (name === 'constructor') {
+                if (name === 'constructor' && !isStatic && nameNode.type !== 'computed_property_name') {
                     memberType = 'constructor';
                 } else if (text.match(/^\s*(?:public\s+|private\s+|protected\s+)?(?:override\s+)?static\s+(?:override\s+)?get\s/)) {
                     memberType = hasOverride ? 'static override get' : 'static get';
@@ -1726,6 +1825,7 @@ function extractClassMembers(classNode, codeOrLines) {
                     paramsStructured,
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType,
                     ...(accessMatch && { modifiers: [accessMatch[1]] }),
                     isAsync,
@@ -1783,7 +1883,7 @@ function extractClassMembers(classNode, codeOrLines) {
             const nameNode = child.childForFieldName('name');
             const paramsNode = child.childForFieldName('parameters');
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
                 const returnType = extractReturnType(child);
                 const docstring = extractJSDocstring(code, startLine);
                 const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
@@ -1805,6 +1905,7 @@ function extractClassMembers(classNode, codeOrLines) {
                     paramsStructured,
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType: 'abstract',
                     isMethod: true,
                     ...typeAnno,
@@ -1818,7 +1919,7 @@ function extractClassMembers(classNode, codeOrLines) {
         if (child.type === 'field_definition' || child.type === 'public_field_definition') {
             const nameNode = child.childForFieldName('name') || child.childForFieldName('property');
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
                 const name = nameNode.text;
                 // fix #390: a TS decorator is part of the field node; the
                 // name's line is where definition edits go.
@@ -1865,6 +1966,7 @@ function extractClassMembers(classNode, codeOrLines) {
                         paramsStructured,
                         startLine,
                         endLine,
+                        sourceSpan,
                         ...fieldNameLine,
                         memberType: name.startsWith('#') ? 'private' : 'field',
                         ...(isStatic && { modifiers: ['static'] }),
@@ -1892,6 +1994,7 @@ function extractClassMembers(classNode, codeOrLines) {
                         name,
                         startLine,
                         endLine,
+                        sourceSpan,
                         ...fieldNameLine,
                         memberType: name.startsWith('#') ? 'private field' : 'field',
                         ...(isStatic && { modifiers: ['static'] }),
@@ -1905,9 +2008,48 @@ function extractClassMembers(classNode, codeOrLines) {
         }
     }
 
+    members.push(...jsInstanceProperties(bodyNode, members.map(member => member.name)));
     return members;
 }
 
+const JS_OWN_THIS_SCOPES = new Set(['function_expression', 'function_declaration', 'function',
+    'generator_function', 'generator_function_declaration', 'class', 'class_declaration',
+    'abstract_class_declaration', 'method_definition']);
+
+/**
+ * Instance properties a class's methods create by assigning them on `this`
+ * (fix #431, as Python instance attributes, fix #430): one per name, the
+ * first assignment in source order, for names the class body does not
+ * declare. A static method's `this` is the class; a nested function or
+ * class has its own `this`; an arrow function shares it.
+ */
+function jsInstanceProperties(bodyNode, declared) {
+    const out = [];
+    const seen = new Set(declared);
+    for (let i = 0; i < bodyNode.namedChildCount; i++) {
+        const member = bodyNode.namedChild(i);
+        if (member.type !== 'method_definition' || member.children.some(part => part.type === 'static')) continue;
+        const body = member.childForFieldName('body');
+        if (!body) continue;
+        traverseTree(body, node => {
+            if (JS_OWN_THIS_SCOPES.has(node.type)) return false;
+            if (node.type !== 'assignment_expression' && node.type !== 'augmented_assignment_expression') return true;
+            const left = node.childForFieldName('left');
+            const property = left?.type === 'member_expression' && left.childForFieldName('object')?.type === 'this'
+                ? left.childForFieldName('property') : null;
+            // Reading an inherited member on the RHS still writes an own
+            // instance property, as in `this.m = this.m.bind(this)`.
+            if (property?.type === 'property_identifier' && !seen.has(property.text)) {
+                seen.add(property.text);
+                out.push({ name: property.text, startLine: property.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1, memberType: 'field', instanceAttribute: true });
+            }
+            return true;
+        });
+    }
+    return out;
+}
+
 // Module-level state detection helpers
 const _STATE_PATTERN = /^(CONFIG|[A-Z][a-zA-Z]*(?:State|Store|Context|Options|Settings)|[A-Z][A-Z_]+|Entities|Input)$/;
 const _ACTION_PATTERN = /^(action\w*|[a-z]+Action|[a-z]+State)$/;
@@ -1925,25 +2067,63 @@ function _isFactoryCall(node) {
  * Process a node for state object extraction (single-pass helper)
  * Returns true if node was matched, false otherwise
  */
+function moduleStateScope(declaration) {
+    const namespaces = [];
+    for (let scope = declaration.parent; scope; scope = scope.parent) {
+        if (scope.type === 'program') return { namespace: namespaces.reverse().join('.') };
+        if (scope.type === 'export_statement' || scope.type === 'ambient_declaration') continue;
+        if (scope.type === 'internal_module' || scope.type === 'module') {
+            const name = scope.childForFieldName('name');
+            if (!name || name.type === 'string') return null;
+            namespaces.push(name.text);
+            continue;
+        }
+        if (scope.type === 'statement_block' &&
+            ['internal_module', 'module'].includes(scope.parent?.type)) continue;
+        if (FUNCTION_NODE_TYPES.has(scope.type) ||
+            ['class_body', 'class_static_block'].includes(scope.type)) return null;
+        if (declaration.type !== 'variable_declaration') return null;
+    }
+    return null;
+}
+
 function _processState(node, objects, lines) {
     if (node.type === 'lexical_declaration' || node.type === 'variable_declaration') {
+        const moduleScope = moduleStateScope(node);
         for (let i = 0; i < node.namedChildCount; i++) {
             const declarator = node.namedChild(i);
             if (declarator.type === 'variable_declarator') {
                 const nameNode = declarator.childForFieldName('name');
                 const valueNode = declarator.childForFieldName('value');
 
+                const value = unwrapValueExpression(valueNode);
+                if (moduleScope && nameNode && !isImportInitializerNode(valueNode) &&
+                    !['arrow_function', 'function', 'function_expression', 'generator_function',
+                        'class', 'class_declaration'].includes(value?.type)) {
+                    const names = [];
+                    collectPatternNames(nameNode, names, true);
+                    for (const binding of names) {
+                        objects.push({ name: binding.text,
+                            startLine: binding.startPosition.row + 1,
+                            endLine: declarator.endPosition.row + 1,
+                            sourceSpan: nodeToLocation(declarator, lines).sourceSpan,
+                            ...(moduleScope.namespace && { namespace: moduleScope.namespace }),
+                        });
+                    }
+                    continue;
+                }
+
                 if (nameNode && valueNode) {
                     const name = nameNode.text;
                     const isObject = valueNode.type === 'object';
                     const isArray = valueNode.type === 'array';
 
                     if ((isObject || isArray) && _STATE_PATTERN.test(name)) {
-                        const { startLine, endLine } = nodeToLocation(node, lines);
-                        objects.push({ name, startLine, endLine });
+                        const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
+                        objects.push({ name, startLine, endLine, sourceSpan });
                     } else if (_isFactoryCall(valueNode) && (_ACTION_PATTERN.test(name) || _STATE_PATTERN.test(name))) {
-                        const { startLine, endLine } = nodeToLocation(node, lines);
-                        objects.push({ name, startLine, endLine });
+                        const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
+                        objects.push({ name, startLine, endLine, sourceSpan });
                     }
                 }
             }
@@ -2051,33 +2231,63 @@ function jsModuleValueAliases(root) {
             }
         }
     }
-    if (mutable.length > 0) {
-        // A `let`/`var` alias is the class only while nothing assigns the
-        // name again (fix #392): any write to that identifier anywhere in the
-        // module, or a second declaration, leaves it unbound.
-        const written = new Set();
-        const writeTargets = (node) => {
-            if (!node) return;
-            if (node.type === 'identifier') { written.add(node.text); return; }
-            if (/pattern$/.test(node.type) || node.type === 'pair_pattern' ||
-                node.type === 'shorthand_property_identifier_pattern') {
-                if (node.type === 'shorthand_property_identifier_pattern') written.add(node.text);
-                for (const child of node.namedChildren) writeTargets(child);
-            }
-        };
-        for (const node of root.descendantsOfType(['assignment_expression',
-            'augmented_assignment_expression', 'update_expression', 'for_in_statement'])) {
-            if (node.type === 'update_expression') writeTargets(node.namedChild(0));
-            else if (node.type === 'for_in_statement') {
-                if (!node.childForFieldName('kind')) writeTargets(node.childForFieldName('left'));
-            } else writeTargets(node.childForFieldName('left'));
+    // A `let`/`var` alias is the class only while nothing assigns the
+    // name again (fix #392): any write to that identifier anywhere in the
+    // module, or a second declaration, leaves it unbound.
+    const written = new Set();
+    const writeTargets = (node) => {
+        if (!node) return;
+        if (node.type === 'identifier') { written.add(node.text); return; }
+        if (/pattern$/.test(node.type) || node.type === 'pair_pattern' ||
+            node.type === 'shorthand_property_identifier_pattern') {
+            if (node.type === 'shorthand_property_identifier_pattern') written.add(node.text);
+            for (const child of node.namedChildren) writeTargets(child);
         }
-        for (const alias of mutable) {
-            if (!written.has(alias.name) && declared.get(alias.name) === 1) aliases.push(alias);
+    };
+    for (const node of root.descendantsOfType(['assignment_expression',
+        'augmented_assignment_expression', 'update_expression', 'for_in_statement'])) {
+        if (node.type === 'update_expression') writeTargets(node.namedChild(0));
+        else if (node.type === 'for_in_statement') {
+            if (!node.childForFieldName('kind')) writeTargets(node.childForFieldName('left'));
+        } else writeTargets(node.childForFieldName('left'));
+    }
+    for (const alias of mutable) {
+        if (!written.has(alias.name) && declared.get(alias.name) === 1) aliases.push(alias);
+    }
+    aliases.sort((a, b) => a.line - b.line);
+    return { aliases, assignedNames: [...written].sort() };
+}
+
+/**
+ * Declarations inside `declare global { .. }` and `declare module 'name' {
+ * .. }` merge with declarations outside the project (fix #423: `interface
+ * Window`, a router's `Register`): the checker reads them through the merged
+ * declaration, so no use names them in project code. Marks every symbol
+ * (and member) whose span lies in such a block `ambientAugmentation`.
+ */
+function markAmbientAugmentations(root, groups) {
+    const ranges = [];
+    for (let i = 0; i < root.namedChildCount; i++) {
+        let node = root.namedChild(i);
+        if (node.type === 'export_statement') node = node.namedChild(0);
+        if (node?.type !== 'ambient_declaration') continue;
+        const inner = node.namedChild(0);
+        const augments = inner?.type === 'statement_block' ||
+            (inner?.type === 'module' && inner.childForFieldName('name')?.type === 'string');
+        if (augments) ranges.push([node.startIndex, node.endIndex]);
+    }
+    if (ranges.length === 0) return;
+    const inside = item => {
+        const start = item?.sourceSpan?.start;
+        return Number.isInteger(start) && ranges.some(([from, to]) => start >= from && start < to);
+    };
+    for (const group of groups) {
+        for (const item of group) {
+            if (!inside(item)) continue;
+            item.ambientAugmentation = true;
+            for (const member of item.members || []) member.ambientAugmentation = true;
         }
-        aliases.sort((a, b) => a.line - b.line);
     }
-    return aliases;
 }
 
 function parse(code, parser) {
@@ -2191,7 +2401,8 @@ function parse(code, parser) {
     classes.sort((a, b) => a.startLine - b.startLine);
     stateObjects.sort((a, b) => a.startLine - b.startLine);
     callableAliases.sort((a, b) => a.startLine - b.startLine);
-    const moduleValueAliases = jsModuleValueAliases(tree.rootNode);
+    markAmbientAugmentations(tree.rootNode, [functions, classes, stateObjects]);
+    const { aliases: moduleValueAliases, assignedNames: moduleAssignedNames } = jsModuleValueAliases(tree.rootNode);
 
     return {
         language: 'javascript',
@@ -2201,6 +2412,7 @@ function parse(code, parser) {
         stateObjects,
         callableAliases,
         ...(moduleValueAliases.length > 0 && { moduleValueAliases }),
+        ...(moduleAssignedNames.length > 0 && { moduleAssignedNames }),
         ...(tree.rootNode.hasError && { parseRecovery: true, parseErrorRegions: parseErrorRegions(tree.rootNode) }),
         imports: [],  // Handled by core/imports.js
         exports: []   // Handled by core/imports.js
@@ -2447,6 +2659,40 @@ function jsLiteralRequireModule(node) {
     return first?.type === 'string' ? first.text.slice(1, -1) : undefined;
 }
 
+// Functions with their own `this`; an arrow function reads its enclosing one.
+const JS_THIS_FUNCTIONS = new Set(['function_declaration', 'function_expression', 'function',
+    'generator_function', 'generator_function_declaration']);
+
+/**
+ * A construction through a method's own receiver (fix #434): `new this(..)`
+ * in a static method and `new this.constructor(..)` in an instance method
+ * build the method's class or a subclass of it. Returns the class (by its
+ * name line), the method, the receiver binding and the callee spelling.
+ */
+function jsOwnClassConstruction(newNode, ctorNode) {
+    let binding;
+    if (ctorNode.type === 'this') binding = 'class';
+    else if (ctorNode.type === 'member_expression' && ctorNode.childForFieldName('object')?.type === 'this' &&
+        ctorNode.childForFieldName('property')?.text === 'constructor') binding = 'instance';
+    else return null;
+    let method = null;
+    for (let parent = newNode.parent; parent && !method; parent = parent.parent) {
+        if (JS_THIS_FUNCTIONS.has(parent.type) || parent.type === 'class_body' || parent.type === 'program' ||
+            parent.type === 'class_static_block') return null;
+        if (parent.type === 'method_definition') method = parent;
+    }
+    const classNode = method?.parent?.type === 'class_body' ? method.parent.parent : null;
+    const className = classNode && ['class_declaration', 'abstract_class_declaration'].includes(classNode.type)
+        ? classNode.childForFieldName('name') : null;
+    const methodName = method?.childForFieldName('name');
+    if (!className || !methodName) return null;
+    const isStatic = method.children.some(child => child.type === 'static');
+    if ((binding === 'class') !== isStatic) return null;
+    return { name: className.text, line: className.startPosition.row + 1, method: methodName.text,
+        methodLine: methodName.startPosition.row + 1, receiver: 'this', binding,
+        spelling: binding === 'class' ? 'this' : 'constructor' };
+}
+
 function findCallsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const calls = [];
@@ -2997,8 +3243,10 @@ function findCallsInCode(code, parser) {
             return nameNode?.text || '<anonymous>';
         }
         if (node.type === 'arrow_function') {
-            // Arrow functions don't have names, but check parent for variable assignment
-            const parent = node.parent;
+            // Arrow functions don't have names, but check parent for variable
+            // assignment, through parentheses and casts (fix #434).
+            let parent = node.parent;
+            while (parent && JS_VALUE_WRAPPERS.has(parent.type)) parent = parent.parent;
             if (parent?.type === 'variable_declarator') {
                 const nameNode = parent.childForFieldName('name');
                 return nameNode?.text || '<anonymous>';
@@ -3676,6 +3924,38 @@ function findCallsInCode(code, parser) {
             enclosingFunction: getCurrentEnclosingFunction(),
         });
     };
+    // A method overwritten on a typed receiver (fix #423, commander tests:
+    // `cmd.copyInheritedSettings = mock` with `cmd = new Command()`): the
+    // written member names the method exactly like a stored read, and a
+    // rename that leaves it assigns another property. Only values that can
+    // hold a callable record a reference; a data write (`x.count = 0`)
+    // records nothing, and `this` members are read by their own pass.
+    const CALLABLE_VALUE_TYPES = new Set(['identifier', 'member_expression', 'arrow_function',
+        'function_expression', 'function', 'call_expression', 'conditional_expression']);
+    const memberWriteReference = (leftNode, rightNode) => {
+        if (leftNode?.type !== 'member_expression') return;
+        const prop = leftNode.childForFieldName('property');
+        const obj = leftNode.childForFieldName('object');
+        if (prop?.type !== 'property_identifier' || obj?.type !== 'identifier' || SKIP_IDENTS.has(prop.text)) return;
+        let value = rightNode;
+        while (value && (value.type === 'parenthesized_expression' || value.type === 'as_expression' ||
+            value.type === 'satisfies_expression' || value.type === 'non_null_expression')) {
+            value = value.namedChild(0);
+        }
+        if (!value || !CALLABLE_VALUE_TYPES.has(value.type)) return;
+        const facts = memberReceiverFacts(obj, prop.text);
+        if (!facts.receiverType) return;
+        calls.push({
+            name: prop.text,
+            line: prop.startPosition.row + 1,
+            column: prop.startPosition.column,
+            isMethod: true,
+            ...facts,
+            isFunctionReference: true,
+            memberValue: true,
+            enclosingFunction: getCurrentEnclosingFunction(),
+        });
+    };
     const destructuredFields = (refNode) => {
         const destructured = destructuredBindingOf(refNode, refNode.text);
         return destructured ? { destructured } : null;
@@ -3867,6 +4147,7 @@ function findCallsInCode(code, parser) {
             const left = node.childForFieldName('left');
             const right = node.childForFieldName('right');
             memberValueReference(right);
+            memberWriteReference(left, right);
             if (left?.type === 'identifier') {
                 if (right?.type === 'new_expression') {
                     nonCallableNames.add(left.text);
@@ -4020,6 +4301,7 @@ function findCallsInCode(code, parser) {
                 // the parent class's constructor definition.
                 calls.push({
                     name: 'constructor',
+                    constructorSyntax: 'delegation',
                     line: node.startPosition.row + 1,
                     callStart: node.startIndex,
                     callEnd: node.endIndex,
@@ -4288,12 +4570,34 @@ function findCallsInCode(code, parser) {
             const ctorNode = node.childForFieldName('constructor');
             if (ctorNode) {
                 const enclosingFunction = getCurrentEnclosingFunction();
+                const args = (node.childForFieldName('arguments')?.namedChildren || [])
+                    .filter(arg => !arg.type.endsWith('comment'));
+                const argumentsShape = {
+                    argCount: args.length,
+                    ...(args.some(arg => arg.type === 'spread_element') && { argSpread: true }),
+                };
 
                 // fix #366: `new Router({ prefix: '/api' })` (koa-router)
                 // carries a constructor mount prefix.
                 const ctorPrefix = hasObjectKeyArg(node, 'prefix');
-                if (ctorNode.type === 'identifier') {
+                const ownClass = jsOwnClassConstruction(node, ctorNode);
+                if (ctorNode.type === 'this' && ownClass) {
+                    // `new this(..)` in a static method builds the method's
+                    // class or a subclass of it (fix #434).
+                    calls.push({
+                        callSite: typeOrigin('call', ctorNode),
+                        ...argumentsShape,
+                        name: ownClass.name,
+                        line: node.startPosition.row + 1,
+                        isMethod: false,
+                        isConstructor: true,
+                        ownClass,
+                        enclosingFunction
+                    });
+                } else if (ctorNode.type === 'identifier') {
                     calls.push({
+                        callSite: typeOrigin('call', ctorNode),
+                        ...argumentsShape,
                         name: ctorNode.text,
                         line: node.startPosition.row + 1,
                         isMethod: false,
@@ -4307,10 +4611,14 @@ function findCallsInCode(code, parser) {
                     const propNode = ctorNode.childForFieldName('property');
                     if (propNode) {
                         calls.push({
+                            callSite: typeOrigin('call', propNode),
+                            ...argumentsShape,
                             name: propNode.text,
                             line: node.startPosition.row + 1,
                             isMethod: true,
                             isConstructor: true,
+                            ...memberReceiverFacts(ctorNode.childForFieldName('object'), propNode.text),
+                            ...(ownClass && { ownClass }),
                             ...(ctorPrefix && { prefixOption: true }),
                             enclosingFunction
                         });
@@ -4982,8 +5290,39 @@ function findImportsInCode(code, parser) {
                     const deferredFields = deferral ? { deferred: true, deferredReason: deferral } : {};
                     if (firstArg && firstArg.type === 'string') {
                         const modulePath = firstArg.text.slice(1, -1);
-                        imports.push({ module: modulePath, names: [], type: 'dynamic', line, dynamic: false,
-                            ...deferredFields });
+                        // `const { a, b: c } = await import('m')` binds the
+                        // module's named exports like a static import does
+                        // (fix #423, swr `const { preload } = await
+                        // import('swr')` in a test).
+                        const names = [], renames = [];
+                        // `{ default: x }` reads the module's default value,
+                        // as `import x from 'm'` (and `require('m')`) does.
+                        let defaultLocal = null;
+                        let holder = node.parent;
+                        while (holder && (holder.type === 'parenthesized_expression' ||
+                            holder.type === 'await_expression')) holder = holder.parent;
+                        const pattern = holder?.type === 'variable_declarator' ? holder.childForFieldName('name') : null;
+                        if (pattern?.type === 'object_pattern' && holder.childForFieldName('value') &&
+                            node.startIndex >= holder.childForFieldName('value').startIndex) {
+                            for (let i = 0; i < pattern.namedChildCount; i++) {
+                                const prop = pattern.namedChild(i);
+                                if (prop.type === 'shorthand_property_identifier_pattern') names.push(prop.text);
+                                else if (prop.type === 'pair_pattern') {
+                                    const key = prop.childForFieldName('key');
+                                    const val = prop.childForFieldName('value');
+                                    if (key?.type !== 'property_identifier' || val?.type !== 'identifier') continue;
+                                    if (key.text === 'default') { defaultLocal = val.text; continue; }
+                                    names.push(key.text);
+                                    if (val.text !== key.text) renames.push({ original: key.text, local: val.text });
+                                }
+                            }
+                        }
+                        imports.push({ module: modulePath, names, type: 'dynamic', line, dynamic: false,
+                            ...deferredFields, ...(renames.length > 0 && { renames }) });
+                        if (defaultLocal) {
+                            imports.push({ module: modulePath, names: [defaultLocal], type: 'dynamic', line,
+                                dynamic: false, defaultLike: true, ...deferredFields });
+                        }
                     } else if (firstArg) {
                         imports.push({ module: firstArg.text, names: [], type: 'dynamic', line, dynamic: true,
                             ...deferredFields });
@@ -5376,6 +5715,16 @@ function findUsagesInCode(code, name, parser, tree, options = {}) {
                     importAliasLocal = true;
                 }
             }
+            // `const { default: name } = await import('m')` / `require('m')`:
+            // the local of the module's default value is an import (fix #423).
+            else if (parent.type === 'pair_pattern' && sameNode(parent.childForFieldName('value'), node) &&
+                     parent.childForFieldName('key')?.text === 'default' &&
+                     parent.parent?.type === 'object_pattern' &&
+                     parent.parent.parent?.type === 'variable_declarator' &&
+                     sameNode(parent.parent.parent.childForFieldName('name'), parent.parent) &&
+                     isImportInitializerNode(parent.parent.parent.childForFieldName('value'))) {
+                usageType = 'import';
+            }
             // Call: identifier is function in call_expression
             else if (parent.type === 'call_expression' &&
                      sameNode(parent.childForFieldName('function'), node)) {
@@ -5449,10 +5798,13 @@ function findUsagesInCode(code, name, parser, tree, options = {}) {
                 // Check if the object_pattern is part of a variable_declarator with require()
                 const declarator = parent.parent;
                 if (declarator && declarator.type === 'variable_declarator') {
-                    const value = declarator.childForFieldName('value');
+                    let value = declarator.childForFieldName('value');
+                    // `const { name } = await import('m')` (fix #423).
+                    while (value && (value.type === 'await_expression' ||
+                        value.type === 'parenthesized_expression')) value = value.namedChild(0);
                     if (value && value.type === 'call_expression') {
                         const func = value.childForFieldName('function');
-                        if (func && func.text === 'require') {
+                        if (func && (func.text === 'require' || func.type === 'import')) {
                             usageType = 'import';
                         }
                     }