ucn 5.0.6 → 5.2.0

package/languages/javascript.js

@@ -435,6 +435,34 @@ function extractReturnedConcreteType(node) {
         ? types[0] : null;
 }
 
+/**
+ * Whether every explicit value-producing return yields the current receiver.
+ * A fallthrough/empty return cannot feed a subsequent chained call, so it does
+ * not compete with `this`; any other returned value makes the result unknown.
+ */
+function returnsReceiverSelf(node) {
+    const body = node.childForFieldName('body');
+    if (!body) return false;
+    let sawSelf = false;
+    const stack = [body];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current !== body && FUNCTION_SCOPE_NODES.has(current.type)) continue;
+        if (current.type === 'class_declaration' || current.type === 'class') continue;
+        if (current.type === 'return_statement') {
+            const value = current.namedChild(0);
+            if (!value) continue;
+            if (value.type !== 'this') return false;
+            sawSelf = true;
+            continue;
+        }
+        for (let i = current.namedChildCount - 1; i >= 0; i--) {
+            stack.push(current.namedChild(i));
+        }
+    }
+    return sawSelf;
+}
+
 /**
  * Process a node for function extraction (single-pass helper)
  * Returns true if node was matched, false otherwise
@@ -618,6 +646,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                             isGenerator: isGen,
                             isAsync,
                             modifiers,
+                            ...lexicalOwnerRange(node),
                             ...typeAnno,
                             ...(generics && { generics }),
                             ...(docstring && { docstring })
@@ -699,8 +728,14 @@ function _processFunction(node, functions, processedRanges, lines) {
         if (processedRanges.has(rangeKey)) return false;
 
         const leftNode = node.childForFieldName('left');
-        const isPrototypeAssignment = leftNode && leftNode.type === 'member_expression' &&
-            leftNode.text.includes('.prototype.');
+        const assignedObject = leftNode?.type === 'member_expression'
+            ? leftNode.childForFieldName('object') : null;
+        const prototypeBase = assignedObject?.type === 'member_expression' &&
+            assignedObject.childForFieldName('property')?.text === 'prototype'
+            ? assignedObject.childForFieldName('object') : null;
+        const prototypeOwner = prototypeBase?.type === 'identifier'
+            ? prototypeBase.text : null;
+        const isPrototypeAssignment = !!prototypeOwner;
 
         // For non-prototype assignments, check if nested
         if (!isPrototypeAssignment) {
@@ -748,7 +783,8 @@ function _processFunction(node, functions, processedRanges, lines) {
                     processedRanges.add(rangeKey);
                     const paramsNode = rightNode.childForFieldName('parameters');
                     const { startLine, endLine, indent } = nodeToLocation(node, lines);
-                    const returnType = extractReturnType(rightNode);
+                    const returnType = extractReturnType(rightNode) ||
+                        (prototypeOwner && returnsReceiverSelf(rightNode) ? 'this' : null);
                     const generics = extractGenerics(rightNode);
                     const docstring = extractJSDocstring(lines, startLine);
                     const isGen = isGenerator(rightNode);
@@ -774,9 +810,14 @@ function _processFunction(node, functions, processedRanges, lines) {
                         // assignments carry their class so typed-receiver
                         // method resolution reaches them.
                         ...(leftNode.type === 'member_expression' && { memberAssigned: true }),
+                        // One-hop member assignments record the object they
+                        // patch (fix #286a: `console.log = () => {}` — the
+                        // builtin-global exclusion must see cross-file that
+                        // the project rebinds this global's member).
                         ...(leftNode.type === 'member_expression' &&
-                            /^([A-Za-z_$][\w$]*)\.prototype\.[A-Za-z_$][\w$]*$/.test(leftNode.text) &&
-                            { className: leftNode.text.split('.')[0], isMethod: true }),
+                            leftNode.childForFieldName('object')?.type === 'identifier' &&
+                            { assignedReceiver: leftNode.childForFieldName('object').text }),
+                        ...(prototypeOwner && { className: prototypeOwner, isMethod: true }),
                         ...typeAnno,
                         ...(generics && { generics }),
                         ...(docstring && { docstring })
@@ -1258,7 +1299,8 @@ function extractClassMembers(classNode, codeOrLines) {
                 }
 
                 const isAsync = text.match(/^\s*(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:override\s+)?async\s/) !== null;
-                const returnType = extractReturnType(child);
+                const returnType = extractReturnType(child) ||
+                    (returnsReceiverSelf(child) ? 'this' : null);
                 const docstring = extractJSDocstring(code, startLine);
                 const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
                 const typeAnno = buildTypeAnnotations(paramsStructured, returnType, code, startLine, true);
@@ -1372,6 +1414,8 @@ function extractClassMembers(classNode, codeOrLines) {
                 const name = nameNode.text;
                 const valueNode = child.childForFieldName('value');
                 const isArrow = valueNode && valueNode.type === 'arrow_function';
+                const isStatic = Array.from({ length: child.childCount }, (_, ci) => child.child(ci))
+                    .some(part => part.type === 'static');
 
                 // Collect decorators — children of the field node (TS) or preceding siblings (JS)
                 const fieldDecorators = [];
@@ -1410,6 +1454,7 @@ function extractClassMembers(classNode, codeOrLines) {
                         startLine,
                         endLine,
                         memberType: name.startsWith('#') ? 'private' : 'field',
+                        ...(isStatic && { modifiers: ['static'] }),
                         isArrow: true,
                         isMethod: true,  // Arrow fields are callable like methods
                         ...typeAnno,
@@ -1427,6 +1472,7 @@ function extractClassMembers(classNode, codeOrLines) {
                         startLine,
                         endLine,
                         memberType: name.startsWith('#') ? 'private field' : 'field',
+                        ...(isStatic && { modifiers: ['static'] }),
                         ...(fieldType && { fieldType }),
                         ...(fieldDecorators.length > 0 && { decorators: fieldDecorators })
                         // Not a method - regular field
@@ -1484,6 +1530,48 @@ function _processState(node, objects, lines) {
     return false;
 }
 
+/**
+ * Record immutable module-scope aliases of a statically named class member.
+ *
+ * `const make = Widget.create` preserves the member's compiler-visible
+ * callable signature.  The normalized IR can therefore expose both the local
+ * callable value and any `export { make as widget }` surface without guessing
+ * from a later call spelling.  Mutable/local/object aliases deliberately stay
+ * out: they need data-flow evidence, not a declaration-shape shortcut.
+ */
+function _processCallableAlias(node, aliases) {
+    if (node.type !== 'lexical_declaration' || !isModuleScope(node)) return false;
+    const declarationKind = node.child(0)?.text;
+    if (declarationKind !== 'const') return false;
+
+    let matched = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const declarator = node.namedChild(i);
+        if (declarator.type !== 'variable_declarator') continue;
+        const nameNode = declarator.childForFieldName('name');
+        let valueNode = declarator.childForFieldName('value');
+        if (nameNode?.type !== 'identifier' || !valueNode) continue;
+        while (valueNode && ['parenthesized_expression', 'as_expression',
+            'satisfies_expression', 'type_assertion'].includes(valueNode.type)) {
+            valueNode = valueNode.namedChild(0);
+        }
+        if (valueNode?.type !== 'member_expression') continue;
+        const owner = valueNode.childForFieldName('object');
+        const member = valueNode.childForFieldName('property');
+        if (owner?.type !== 'identifier' ||
+            !['identifier', 'property_identifier'].includes(member?.type)) continue;
+        aliases.push({
+            name: nameNode.text,
+            owner: owner.text,
+            member: member.text,
+            startLine: declarator.startPosition.row + 1,
+            endLine: declarator.endPosition.row + 1,
+        });
+        matched = true;
+    }
+    return matched;
+}
+
 /**
  * Find state objects (CONFIG, constants, etc.)
  */
@@ -1508,13 +1596,14 @@ function findStateObjects(code, parser) {
 function parse(code, parser) {
     const tree = parseTree(parser, code);
     const lines = code.split('\n');
-    const functions = [], classes = [], stateObjects = [];
+    const functions = [], classes = [], stateObjects = [], callableAliases = [];
     const processedFn = new Set(), processedCls = new Set();
 
     traverseTreeCached(tree.rootNode, (node) => {
         _processFunction(node, functions, processedFn, lines);
         _processClass(node, classes, processedCls, lines);
         _processState(node, stateObjects, lines);
+        _processCallableAlias(node, callableAliases);
         return true; // always continue, never skip subtrees
     });
 
@@ -1554,6 +1643,7 @@ function parse(code, parser) {
         declarationTokens.sort((a, b) => a.startIndex - b.startIndex);
 
         const recoveredFunctions = [], recoveredClasses = [], recoveredState = [];
+        const recoveredCallableAliases = [];
         for (let i = 0; i < declarationTokens.length; i++) {
             const token = declarationTokens[i];
             const next = declarationTokens[i + 1];
@@ -1562,12 +1652,13 @@ function parse(code, parser) {
             if (!fragment.trim()) continue;
             const fragmentTree = parseTree(parser, fragment);
             const fragmentLines = fragment.split('\n');
-            const ff = [], fc = [], fs = [];
+            const ff = [], fc = [], fs = [], fa = [];
             const pf = new Set(), pc = new Set();
             traverseTreeCached(fragmentTree.rootNode, (node) => {
                 _processFunction(node, ff, pf, fragmentLines);
                 _processClass(node, fc, pc, fragmentLines);
                 _processState(node, fs, fragmentLines);
+                _processCallableAlias(node, fa);
                 return true;
             });
             const lineOffset = token.startPosition.row;
@@ -1585,6 +1676,7 @@ function parse(code, parser) {
             for (const item of ff) { shiftLines(item); recoveredFunctions.push(item); }
             for (const item of fc) { shiftLines(item); recoveredClasses.push(item); }
             for (const item of fs) { shiftLines(item); recoveredState.push(item); }
+            for (const item of fa) { shiftLines(item); recoveredCallableAliases.push(item); }
         }
 
         const mergeUnique = (target, additions, kind) => {
@@ -1597,11 +1689,21 @@ function parse(code, parser) {
         mergeUnique(functions, recoveredFunctions, 'function');
         mergeUnique(classes, recoveredClasses, 'class');
         mergeUnique(stateObjects, recoveredState, 'state');
+        const aliasKeys = new Set(callableAliases.map(alias =>
+            `${alias.name}\0${alias.owner}\0${alias.member}\0${alias.startLine}`));
+        for (const alias of recoveredCallableAliases) {
+            const key = `${alias.name}\0${alias.owner}\0${alias.member}\0${alias.startLine}`;
+            if (!aliasKeys.has(key)) {
+                aliasKeys.add(key);
+                callableAliases.push(alias);
+            }
+        }
     }
 
     functions.sort((a, b) => a.startLine - b.startLine);
     classes.sort((a, b) => a.startLine - b.startLine);
     stateObjects.sort((a, b) => a.startLine - b.startLine);
+    callableAliases.sort((a, b) => a.startLine - b.startLine);
 
     return {
         language: 'javascript',
@@ -1609,6 +1711,7 @@ function parse(code, parser) {
         functions,
         classes,
         stateObjects,
+        callableAliases,
         ...(tree.rootNode.hasError && { parseRecovery: true }),
         imports: [],  // Handled by core/imports.js
         exports: []   // Handled by core/imports.js
@@ -1653,6 +1756,40 @@ const JS_LITERAL_ASSIGN_TYPES = {
 // Predefined TS types that pin a receiver; any/unknown/object say nothing.
 const TS_PREDEFINED_RECEIVER_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'symbol']);
 
+/**
+ * Companion to tsTypeName: the namespace qualifier that owns the annotated
+ * name (fix #286e — `app: ns.Flask` must carry 'ns' so two same-name classes
+ * resolve by declaration origin, not directory proximity).
+ */
+function tsTypeQualifier(node) {
+    if (!node) return undefined;
+    switch (node.type) {
+        case 'nested_type_identifier': {
+            const last = node.namedChild(node.namedChildCount - 1);
+            const start = node.startIndex;
+            return last && last.startIndex > start
+                ? node.text.slice(0, last.startIndex - start).replace(/\.$/, '') || undefined
+                : undefined;
+        }
+        case 'generic_type':
+            return tsTypeQualifier(node.namedChild(0));
+        case 'union_type': {
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (c.type === 'nested_type_identifier' || c.type === 'generic_type') {
+                    const q = tsTypeQualifier(c);
+                    if (q) return q;
+                }
+            }
+            return undefined;
+        }
+        case 'parenthesized_type':
+            return tsTypeQualifier(node.namedChild(0));
+        default:
+            return undefined;
+    }
+}
+
 /**
  * Extract a single concrete type name from a TS type node. Conservative by
  * design: a wrong type would exclude true callers downstream
@@ -1717,6 +1854,34 @@ function jsAssignmentTargetOf(callNode) {
     return undefined;
 }
 
+/**
+ * For-of iteration target of a call used as the iterable:
+ * `for (const x of getItems())`. The loop variable holds an ELEMENT of the
+ * producer's result, never the return value — provenance only (fix #294).
+ */
+function jsIterTargetOf(callNode) {
+    let n = callNode;
+    let p = n.parent;
+    if (p && p.type === 'await_expression') { n = p; p = n.parent; }
+    if (!p || p.type !== 'for_in_statement') return undefined;
+    if (p.childForFieldName('operator')?.text !== 'of') return undefined;
+    const right = p.childForFieldName('right');
+    if (!right || right.id !== n.id) return undefined;
+    const left = p.childForFieldName('left');
+    if (!left) return undefined;
+    const names = [];
+    if (left.type === 'identifier') {
+        names.push(left.text);
+    } else if (left.type === 'array_pattern') {
+        for (let i = 0; i < left.namedChildCount; i++) {
+            const c = left.namedChild(i);
+            if (c.type === 'identifier') names.push(c.text);
+        }
+    }
+    if (names.length === 0) return undefined;
+    return { first: names[0], rest: names.slice(1) };
+}
+
 /**
  * Type name from a new-expression constructor node: new Foo() or new pkg.Foo().
  */
@@ -2180,6 +2345,12 @@ function findCallsInCode(code, parser) {
                     if (typeName) {
                         localVarTypes.set(nameNode.text, typeName);
                         declaredTypeVars.add(nameNode.text);
+                        const annotationQualifier = tsTypeQualifier(typeId);
+                        if (annotationQualifier) {
+                            localVarTypeQualifiers.set(nameNode.text, annotationQualifier);
+                        } else {
+                            localVarTypeQualifiers.delete(nameNode.text);
+                        }
                     }
                 } else if (initNode && JS_LITERAL_ASSIGN_TYPES[initNode.type]) {
                     // Literal declaration types the variable (fix #262):
@@ -2200,6 +2371,12 @@ function findCallsInCode(code, parser) {
                 if (typeName) {
                     localVarTypes.set(pat.text, typeName);
                     declaredTypeVars.add(pat.text);
+                    const annotationQualifier = tsTypeQualifier(inner);
+                    if (annotationQualifier) {
+                        localVarTypeQualifiers.set(pat.text, annotationQualifier);
+                    } else {
+                        localVarTypeQualifiers.delete(pat.text);
+                    }
                 }
             }
         }
@@ -2314,7 +2491,18 @@ function findCallsInCode(code, parser) {
                 const resolvedName = typeof alias === 'string' ? alias : undefined;
                 const resolvedNames = Array.isArray(alias) ? alias : undefined;
                 const firstArg = getFirstStringArg(node);
-                const assignedTo = jsAssignmentTargetOf(node);
+                let assignedTo = jsAssignmentTargetOf(node);
+                let assignedIterFields = {};
+                if (!assignedTo) {
+                    const iterTarget = jsIterTargetOf(node);
+                    if (iterTarget) {
+                        assignedTo = iterTarget.first;
+                        assignedIterFields = {
+                            assignedIter: true,
+                            ...(iterTarget.rest.length > 0 && { assignedTupleRest: iterTarget.rest }),
+                        };
+                    }
+                }
                 // MEDIUM-5: capture explicit method for fetch(url, { method }).
                 const optionsMethod = funcNode.text === 'fetch'
                     ? getOptionsMethod(node, 1)
@@ -2328,6 +2516,7 @@ function findCallsInCode(code, parser) {
                     callEnd: node.endIndex,
                     isMethod: false,
                     ...(assignedTo && { assignedTo }),
+                    ...assignedIterFields,
                     enclosingFunction,
                     uncertain,
                     ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
@@ -2509,7 +2698,19 @@ function findCallsInCode(code, parser) {
                                 !localVarTypes.has(receiver));
                         const firstArg = getFirstStringArg(node);
                         const argCount = getArgCount(node);
-                        const assignedTo = jsAssignmentTargetOf(node);
+                        let assignedTo = jsAssignmentTargetOf(node);
+                        let assignedIterFields = {};
+                        if (!assignedTo) {
+                            const iterTarget = jsIterTargetOf(node);
+                            if (iterTarget) {
+                                assignedTo = iterTarget.first;
+                                assignedIterFields = {
+                                    assignedIter: true,
+                                    ...(iterTarget.rest.length > 0 &&
+                                        { assignedTupleRest: iterTarget.rest }),
+                                };
+                            }
+                        }
                         calls.push({
                             name: propName,
                             // Multi-line chains (builder.x()\n.y()) must report
@@ -2545,6 +2746,7 @@ function findCallsInCode(code, parser) {
                             ...(receiverCallStart != null && { receiverCallStart }),
                             ...(receiverCallEnd != null && { receiverCallEnd }),
                             ...(assignedTo && { assignedTo }),
+                            ...assignedIterFields,
                             enclosingFunction,
                             uncertain,
                             ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
@@ -2593,11 +2795,17 @@ function findCallsInCode(code, parser) {
                                 const propNode = arg.childForFieldName('property');
                                 const objNode = arg.childForFieldName('object');
                                 if (propNode && !SKIP_IDENTS.has(propNode.text)) {
+                                    const hofRecv = objNode?.type === 'identifier' ? objNode.text : undefined;
+                                    // Same typing evidence as the general-arg
+                                    // member-value shape (fix #295) — tier must
+                                    // not depend on argument position (#234).
+                                    const hofRecvType = hofRecv ? localVarTypes.get(hofRecv) : undefined;
                                     calls.push({
                                         name: propNode.text,
                                         line: arg.startPosition.row + 1,
                                         isMethod: true,
-                                        receiver: objNode?.type === 'identifier' ? objNode.text : undefined,
+                                        receiver: hofRecv,
+                                        ...(hofRecvType && { receiverType: hofRecvType }),
                                         isFunctionReference: true,
                                         enclosingFunction
                                     });
@@ -2628,6 +2836,29 @@ function findCallsInCode(code, parser) {
                                 enclosingFunction
                             });
                         }
+                        // Method-value references (fix #295): `expectRaises(t.check, null)`
+                        // passes the method value t.check — one-hop identifier
+                        // receivers, typed from the same localVarTypes evidence
+                        // method calls use. No isPotentialCallback: the record
+                        // rides the MAIN path's full receiver physics (the HOF
+                        // member-value convention above).
+                        if (arg.type === 'member_expression') {
+                            const mvProp = arg.childForFieldName('property');
+                            const mvObj = arg.childForFieldName('object');
+                            if (mvProp && mvObj?.type === 'identifier' &&
+                                !SKIP_IDENTS.has(mvProp.text) && !SKIP_IDENTS.has(mvObj.text)) {
+                                const mvType = localVarTypes.get(mvObj.text);
+                                calls.push({
+                                    name: mvProp.text,
+                                    line: arg.startPosition.row + 1,
+                                    isMethod: true,
+                                    receiver: mvObj.text,
+                                    ...(mvType && { receiverType: mvType }),
+                                    isFunctionReference: true,
+                                    enclosingFunction
+                                });
+                            }
+                        }
                         // Scan object literal args for function refs in property values
                         // e.g., doRequest({onSuccess: handleSuccess, onError: handleError})
                         if (arg.type === 'object') {
@@ -3163,6 +3394,22 @@ function findImportsInCode(code, parser) {
     return imports;
 }
 
+/**
+ * Return the local symbol created or referenced by a statically-owned
+ * CommonJS property assignment. Dynamic expressions deliberately return
+ * undefined: `exports.x = factory()` and `exports.x = other.y` may be
+ * re-exports or arbitrary values, so they are not exclusion-grade identity.
+ */
+function cjsAssignedLocalName(valueNode, exposedName) {
+    if (!valueNode) return undefined;
+    if (valueNode.type === 'identifier') return valueNode.text;
+    if (['function_expression', 'generator_function', 'arrow_function', 'class']
+        .includes(valueNode.type)) {
+        return valueNode.childForFieldName('name')?.text || exposedName;
+    }
+    return undefined;
+}
+
 /**
  * Find all exports in JavaScript/TypeScript code using tree-sitter AST
  * @param {string} code - Source code to analyze
@@ -3355,12 +3602,15 @@ function findExportsInCode(code, parser) {
                                 } else if (prop.type === 'pair') {
                                     const key = prop.childForFieldName('key');
                                     const value = prop.childForFieldName('value');
-                                    if (key) exports.push({
-                                        name: key.text,
-                                        ...(value?.type === 'identifier' && { localName: value.text }),
-                                        type: 'module.exports',
-                                        line,
-                                    });
+                                    if (key) {
+                                        const localName = cjsAssignedLocalName(value, key.text);
+                                        exports.push({
+                                            name: key.text,
+                                            ...(localName && { localName }),
+                                            type: 'module.exports',
+                                            line,
+                                        });
+                                    }
                                 } else if (prop.type === 'method_definition') {
                                     // Shorthand methods are exports too
                                     // (fix #252 — `module.exports =
@@ -3402,9 +3652,21 @@ function findExportsInCode(code, parser) {
                             }
                         } else if (rightNode && rightNode.type === 'identifier') {
                             // module.exports = something
-                            exports.push({ name: rightNode.text, localName: rightNode.text, type: 'module.exports', line });
+                            exports.push({ name: rightNode.text, localName: rightNode.text,
+                                type: 'module.exports', defaultLike: true, line });
                         } else {
-                            exports.push({ name: 'default', type: 'module.exports', line });
+                            // A named function/class expression still exports
+                            // one callable default. Preserve its LOCAL symbol
+                            // identity so `require('./mod')()` resolves back
+                            // to the declaration; anonymous expressions use
+                            // the parser's synthetic `default` symbol.
+                            const localName = rightNode &&
+                                ['function_expression', 'generator_function', 'class'].includes(rightNode.type)
+                                ? rightNode.childForFieldName('name')?.text
+                                : undefined;
+                            exports.push({ name: 'default',
+                                ...(localName && { localName }),
+                                type: 'module.exports', defaultLike: true, line });
                         }
                         return true;
                     }
@@ -3413,9 +3675,10 @@ function findExportsInCode(code, parser) {
                     if (objNode.text === 'exports') {
                         const line = node.startPosition.row + 1;
                         const rightNode = node.childForFieldName('right');
+                        const localName = cjsAssignedLocalName(rightNode, propNode.text);
                         exports.push({
                             name: propNode.text,
-                            ...(rightNode?.type === 'identifier' && { localName: rightNode.text }),
+                            ...(localName && { localName }),
                             type: 'exports',
                             line,
                         });
@@ -3425,7 +3688,11 @@ function findExportsInCode(code, parser) {
                     // module.exports.name = ...
                     if (objNode.type === 'member_expression' && objNode.text === 'module.exports') {
                         const line = node.startPosition.row + 1;
-                        exports.push({ name: propNode.text, type: 'module.exports', line });
+                        const rightNode = node.childForFieldName('right');
+                        const localName = cjsAssignedLocalName(rightNode, propNode.text);
+                        exports.push({ name: propNode.text,
+                            ...(localName && { localName }),
+                            type: 'module.exports', line });
                         return true;
                     }
                 }