ucn 5.1.1 → 5.2.0

package/languages/javascript.js

@@ -1854,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().
  */
@@ -2463,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)
@@ -2477,6 +2516,7 @@ function findCallsInCode(code, parser) {
                     callEnd: node.endIndex,
                     isMethod: false,
                     ...(assignedTo && { assignedTo }),
+                    ...assignedIterFields,
                     enclosingFunction,
                     uncertain,
                     ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
@@ -2658,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
@@ -2694,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 }),
@@ -2742,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
                                     });
@@ -2777,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') {