gitnexus 1.4.5 → 1.4.6

package/dist/core/ingestion/type-extractors/go.js

@@ -296,7 +296,7 @@ const findGoParamElementType = (iterableName, startNode, pos = 'last') => {
  * For `_, user := range users`, the loop variable is the second identifier in
  * the `left` expression_list (index is discarded, value is the element).
  */
-const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }) => {
     if (node.type !== 'for_statement')
         return;
     // Find the range_clause child — this distinguishes range loops from other for forms.
@@ -313,6 +313,7 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     // The iterable is the `right` field of the range_clause.
     const rightNode = rangeClause.childForFieldName('right');
     let iterableName;
+    let callExprElementType;
     if (rightNode?.type === 'identifier') {
         iterableName = rightNode.text;
     }
@@ -321,11 +322,35 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
         if (field)
             iterableName = field.text;
     }
-    if (!iterableName)
+    else if (rightNode?.type === 'call_expression') {
+        // Range over a call result: `for _, v := range getItems()` or `for _, v := range repo.All()`
+        const funcNode = rightNode.childForFieldName('function');
+        let callee;
+        if (funcNode?.type === 'identifier') {
+            callee = funcNode.text;
+        }
+        else if (funcNode?.type === 'selector_expression') {
+            const field = funcNode.childForFieldName('field');
+            if (field)
+                callee = field.text;
+        }
+        if (callee) {
+            const rawReturn = returnTypeLookup.lookupRawReturnType(callee);
+            if (rawReturn)
+                callExprElementType = extractElementTypeFromString(rawReturn);
+        }
+    }
+    if (!iterableName && !callExprElementType)
         return;
-    const containerTypeName = scopeEnv.get(iterableName);
-    const typeArgPos = methodToTypeArgPosition(undefined, containerTypeName);
-    const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractGoElementTypeFromTypeNode, findGoParamElementType, typeArgPos);
+    let elementType;
+    if (callExprElementType) {
+        elementType = callExprElementType;
+    }
+    else {
+        const containerTypeName = scopeEnv.get(iterableName);
+        const typeArgPos = methodToTypeArgPosition(undefined, containerTypeName);
+        elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractGoElementTypeFromTypeNode, findGoParamElementType, typeArgPos);
+    }
     if (!elementType)
         return;
     // The loop variable(s) are in the `left` field.
@@ -343,8 +368,11 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
             loopVarNode = leftNode.namedChild(1);
         }
         else {
-            // Single-var in expression_list — yields INDEX for slices/maps, ELEMENT for channels
-            if (isChannelType(iterableName, scopeEnv, declarationTypeNodes, scope)) {
+            // Single-var in expression_list — yields INDEX for slices/maps, ELEMENT for channels.
+            // For call-expression iterables (iterableName undefined), conservative: treat as non-channel.
+            // Channels are rarely returned from function calls, and even if they were, skipping here
+            // just means we miss a binding rather than create an incorrect one.
+            if (iterableName && isChannelType(iterableName, scopeEnv, declarationTypeNodes, scope)) {
                 loopVarNode = leftNode.namedChild(0);
             }
             else {
@@ -354,7 +382,10 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     }
     else {
         // Plain identifier (single-var form without expression_list)
-        if (isChannelType(iterableName, scopeEnv, declarationTypeNodes, scope)) {
+        // For call-expression iterables (iterableName undefined), conservative: treat as non-channel.
+        // Channels are rarely returned from function calls, and even if they were, skipping here
+        // just means we miss a binding rather than create an incorrect one.
+        if (iterableName && isChannelType(iterableName, scopeEnv, declarationTypeNodes, scope)) {
             loopVarNode = leftNode;
         }
         else {
@@ -387,7 +418,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
         if (scopeEnv.has(lhs))
             return undefined;
         if (rhsNode.type === 'identifier')
-            return { lhs, rhs: rhsNode.text };
+            return { kind: 'copy', lhs, rhs: rhsNode.text };
         return undefined;
     }
     if (node.type === 'var_spec' || node.type === 'var_declaration') {
@@ -420,7 +451,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
             }
             const rhsNode = exprList?.firstNamedChild;
             if (rhsNode?.type === 'identifier')
-                return { lhs, rhs: rhsNode.text };
+                return { kind: 'copy', lhs, rhs: rhsNode.text };
         }
     }
     return undefined;

package/dist/core/ingestion/type-extractors/jvm.js

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName, findChildByType, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
+import { extractSimpleTypeName, extractVarName, findChildByType, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
 // ── Java ──────────────────────────────────────────────────────────────────
 const JAVA_DECLARATION_NODE_TYPES = new Set([
     'local_variable_declaration',
@@ -139,7 +139,7 @@ const findJavaParamElementType = (iterableName, startNode, pos = 'last') => {
 };
 /** Java: for (User user : users) — extract loop variable binding.
  *  Tier 1c: for `for (var user : users)`, resolves element type from iterable. */
-const extractJavaForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractJavaForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }) => {
     const typeNode = node.childForFieldName('type');
     const nameNode = node.childForFieldName('name');
     if (!typeNode || !nameNode)
@@ -159,6 +159,7 @@ const extractJavaForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope)
         return;
     let iterableName;
     let methodName;
+    let callExprElementType;
     if (iterableNode.type === 'identifier') {
         iterableName = iterableNode.text;
     }
@@ -180,14 +181,26 @@ const extractJavaForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope)
             if (innerField)
                 iterableName = innerField.text;
         }
+        else if (!obj && name) {
+            // Direct function call: for (var u : getUsers()) — no receiver object
+            const rawReturn = returnTypeLookup.lookupRawReturnType(name.text);
+            if (rawReturn)
+                callExprElementType = extractElementTypeFromString(rawReturn);
+        }
         if (name)
             methodName = name.text;
     }
-    if (!iterableName)
+    if (!iterableName && !callExprElementType)
         return;
-    const containerTypeName = scopeEnv.get(iterableName);
-    const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
-    const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractJavaElementTypeFromTypeNode, findJavaParamElementType, typeArgPos);
+    let elementType;
+    if (callExprElementType) {
+        elementType = callExprElementType;
+    }
+    else {
+        const containerTypeName = scopeEnv.get(iterableName);
+        const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
+        elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractJavaElementTypeFromTypeNode, findJavaParamElementType, typeArgPos);
+    }
     if (elementType)
         scopeEnv.set(varName, elementType);
 };
@@ -205,7 +218,7 @@ const extractJavaPendingAssignment = (node, scopeEnv) => {
         if (scopeEnv.has(lhs))
             continue;
         if (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier')
-            return { lhs, rhs: valueNode.text };
+            return { kind: 'copy', lhs, rhs: valueNode.text };
     }
     return undefined;
 };
@@ -459,7 +472,8 @@ const findKotlinParamElementType = (iterableName, startNode, pos = 'last') => {
 };
 /** Kotlin: for (user: User in users) — extract loop variable binding.
  *  Tier 1c: for `for (user in users)` without annotation, resolves from iterable. */
-const extractKotlinForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractKotlinForLoopBinding = (node, ctx) => {
+    const { scopeEnv, declarationTypeNodes, scope, returnTypeLookup } = ctx;
     const varDecl = findChildByType(node, 'variable_declaration');
     if (!varDecl)
         return;
@@ -483,6 +497,7 @@ const extractKotlinForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope
     let iterableName;
     let methodName;
     let fallbackIterableName;
+    let callExprElementType;
     let foundVarDecl = false;
     for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
@@ -528,21 +543,33 @@ const extractKotlinForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope
                         methodName = prop.text;
                 }
             }
+            else if (callee?.type === 'simple_identifier') {
+                // Direct function call: for (u in getUsers())
+                const rawReturn = returnTypeLookup.lookupRawReturnType(callee.text);
+                if (rawReturn)
+                    callExprElementType = extractElementTypeFromString(rawReturn);
+            }
             break;
         }
     }
-    if (!iterableName)
+    if (!iterableName && !callExprElementType)
         return;
-    let containerTypeName = scopeEnv.get(iterableName);
-    // Fallback: if object has no type in scope, try the property as the iterable name.
-    // Handles patterns like this.users where the property itself is the iterable variable.
-    if (!containerTypeName && fallbackIterableName) {
-        iterableName = fallbackIterableName;
-        methodName = undefined;
-        containerTypeName = scopeEnv.get(iterableName);
+    let elementType;
+    if (callExprElementType) {
+        elementType = callExprElementType;
+    }
+    else {
+        let containerTypeName = scopeEnv.get(iterableName);
+        // Fallback: if object has no type in scope, try the property as the iterable name.
+        // Handles patterns like this.users where the property itself is the iterable variable.
+        if (!containerTypeName && fallbackIterableName) {
+            iterableName = fallbackIterableName;
+            methodName = undefined;
+            containerTypeName = scopeEnv.get(iterableName);
+        }
+        const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
+        elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractKotlinElementTypeFromTypeNode, findKotlinParamElementType, typeArgPos);
     }
-    const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
-    const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractKotlinElementTypeFromTypeNode, findKotlinParamElementType, typeArgPos);
     if (elementType)
         scopeEnv.set(varName, elementType);
 };
@@ -573,7 +600,7 @@ const extractKotlinPendingAssignment = (node, scopeEnv) => {
                 continue;
             }
             if (foundEq && child.type === 'simple_identifier') {
-                return { lhs, rhs: child.text };
+                return { kind: 'copy', lhs, rhs: child.text };
             }
         }
         return undefined;
@@ -601,7 +628,7 @@ const extractKotlinPendingAssignment = (node, scopeEnv) => {
                 continue;
             }
             if (foundEq && child.type === 'simple_identifier') {
-                return { lhs, rhs: child.text };
+                return { kind: 'copy', lhs, rhs: child.text };
             }
         }
         return undefined;

package/dist/core/ingestion/type-extractors/php.js

@@ -81,6 +81,72 @@ const SKIP_NODE_TYPES = new Set(['attribute_list', 'attribute']);
 const PHPDOC_PARAM_RE = /@param\s+(\S+)\s+\$(\w+)/g;
 /** Alternate PHPDoc order: `@param $name Type` (name first) */
 const PHPDOC_PARAM_ALT_RE = /@param\s+\$(\w+)\s+(\S+)/g;
+/** Regex to extract PHPDoc @var annotations: `@var Type` */
+const PHPDOC_VAR_RE = /@var\s+(\S+)/;
+/**
+ * Extract the element type for a class property from its PHPDoc @var annotation or
+ * PHP 7.4+ native type. Walks backward from the property_declaration node to find
+ * an immediately preceding comment containing @var.
+ *
+ * Returns the normalized element type (e.g. User[] → User, Collection<User> → User).
+ * Returns undefined when no usable type annotation is found.
+ */
+const extractClassPropertyElementType = (propDecl) => {
+    // Strategy 1: PHPDoc @var annotation on a preceding comment sibling
+    let sibling = propDecl.previousSibling;
+    while (sibling) {
+        if (sibling.type === 'comment') {
+            const match = PHPDOC_VAR_RE.exec(sibling.text);
+            if (match)
+                return normalizePhpType(match[1]);
+        }
+        else if (sibling.isNamed && !SKIP_NODE_TYPES.has(sibling.type)) {
+            break;
+        }
+        sibling = sibling.previousSibling;
+    }
+    // Strategy 2: PHP 7.4+ native type field — skip generic 'array' since element type is unknown
+    const typeNode = propDecl.childForFieldName('type');
+    if (!typeNode)
+        return undefined;
+    const typeName = extractSimpleTypeName(typeNode);
+    if (!typeName || typeName === 'array')
+        return undefined;
+    return typeName;
+};
+/**
+ * Scan a class body for a property_declaration matching the given property name,
+ * and extract its element type. The class body is the `declaration_list` child of
+ * a `class_declaration` node.
+ *
+ * Used as Strategy C in extractForLoopBinding for `$this->property` iterables
+ * where Strategy A (resolveIterableElementType) and Strategy B (scopeEnv lookup)
+ * both fail to find the type.
+ */
+const findClassPropertyElementType = (propName, classNode) => {
+    const declList = classNode.childForFieldName('body')
+        ?? (classNode.namedChild(classNode.namedChildCount - 1)?.type === 'declaration_list'
+            ? classNode.namedChild(classNode.namedChildCount - 1)
+            : null); // fallback: last named child, only if it's a declaration_list
+    if (!declList)
+        return undefined;
+    for (let i = 0; i < declList.namedChildCount; i++) {
+        const child = declList.namedChild(i);
+        if (child?.type !== 'property_declaration')
+            continue;
+        // Check if any property_element has a variable_name matching '$propName'
+        for (let j = 0; j < child.namedChildCount; j++) {
+            const elem = child.namedChild(j);
+            if (elem?.type !== 'property_element')
+                continue;
+            const varNameNode = elem.firstNamedChild; // variable_name node
+            if (varNameNode?.text === '$' + propName) {
+                return extractClassPropertyElementType(child);
+            }
+        }
+    }
+    return undefined;
+};
 /**
  * Collect PHPDoc @param type bindings from comment nodes preceding a method/function.
  * Returns a map of paramName → typeName (without $ prefix).
@@ -253,9 +319,36 @@ const scanConstructorBinding = (node) => {
 };
 /** Regex to extract PHPDoc @return annotations: `@return User` */
 const PHPDOC_RETURN_RE = /@return\s+(\S+)/;
+/**
+ * Normalize a PHPDoc return type for storage in the SymbolTable.
+ * Unlike normalizePhpType (which strips User[] → User for scopeEnv), this preserves
+ * array notation so lookupRawReturnType can extract element types for for-loop resolution.
+ *   \App\Models\User[] → User[]
+ *   ?User → User
+ *   Collection<User> → Collection<User>  (preserved for extractElementTypeFromString)
+ */
+const normalizePhpReturnType = (raw) => {
+    // Strip nullable prefix: ?User[] → User[]
+    let type = raw.startsWith('?') ? raw.slice(1) : raw;
+    // Strip union with null/false/void: User[]|null → User[]
+    const parts = type.split('|').filter(p => p !== 'null' && p !== 'false' && p !== 'void' && p !== 'mixed');
+    if (parts.length !== 1)
+        return undefined;
+    type = parts[0];
+    // Strip namespace: \App\Models\User[] → User[]
+    const segments = type.split('\\');
+    type = segments[segments.length - 1];
+    // Skip uninformative types
+    if (type === 'mixed' || type === 'void' || type === 'self' || type === 'static' || type === 'object' || type === 'array')
+        return undefined;
+    if (/^\w+(\[\])?$/.test(type) || /^\w+\s*</.test(type))
+        return type;
+    return undefined;
+};
 /**
  * Extract return type from PHPDoc `@return Type` annotation preceding a method.
  * Walks backwards through preceding siblings looking for comment nodes.
+ * Preserves array notation (e.g., User[]) for for-loop element type extraction.
  */
 const extractReturnType = (node) => {
     let sibling = node.previousSibling;
@@ -263,7 +356,7 @@ const extractReturnType = (node) => {
         if (sibling.type === 'comment') {
             const match = PHPDOC_RETURN_RE.exec(sibling.text);
             if (match)
-                return normalizePhpType(match[1]);
+                return normalizePhpReturnType(match[1]);
         }
         else if (sibling.isNamed && !SKIP_NODE_TYPES.has(sibling.type))
             break;
@@ -286,7 +379,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
     const rhs = right.text;
     if (!lhs || !rhs || scopeEnv.has(lhs))
         return undefined;
-    return { lhs, rhs };
+    return { kind: 'copy', lhs, rhs };
 };
 const FOR_LOOP_NODE_TYPES = new Set([
     'foreach_statement',
@@ -339,7 +432,7 @@ const findPhpParamElementType = (iterableName, startNode) => {
  * constructor-binding cases that retain container types), then fall back to direct
  * scopeEnv lookup (for PHPDoc-normalized types).
  */
-const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }) => {
     if (node.type !== 'foreach_statement')
         return;
     // Collect non-body named children: first is the iterable, second is value or pair
@@ -373,6 +466,7 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
         return;
     // Get iterable variable name (PHP vars include $ prefix)
     let iterableName;
+    let callExprElementType;
     if (iterableNode.type === 'variable_name') {
         iterableName = iterableNode.text;
     }
@@ -383,8 +477,31 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
         if (name)
             iterableName = '$' + name.text;
     }
-    if (!iterableName)
+    else if (iterableNode?.type === 'function_call_expression') {
+        // foreach (getUsers() as $user) — resolve via return type lookup
+        const calleeName = extractCalleeName(iterableNode);
+        if (calleeName) {
+            const rawReturn = returnTypeLookup.lookupRawReturnType(calleeName);
+            if (rawReturn)
+                callExprElementType = extractElementTypeFromString(rawReturn);
+        }
+    }
+    else if (iterableNode?.type === 'member_call_expression') {
+        // foreach ($this->getUsers() as $user) — resolve via return type lookup
+        const methodName = iterableNode.childForFieldName('name');
+        if (methodName) {
+            const rawReturn = returnTypeLookup.lookupRawReturnType(methodName.text);
+            if (rawReturn)
+                callExprElementType = extractElementTypeFromString(rawReturn);
+        }
+    }
+    if (!iterableName && !callExprElementType)
+        return;
+    // If we resolved the element type from a call expression, bind and return early
+    if (callExprElementType) {
+        scopeEnv.set(varName, callExprElementType);
         return;
+    }
     // Strategy A: try resolveIterableElementType (handles constructor-binding container types)
     const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractPhpElementTypeFromTypeNode, findPhpParamElementType, undefined);
     if (elementType) {
@@ -396,6 +513,27 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     const iterableType = scopeEnv.get(iterableName);
     if (iterableType) {
         scopeEnv.set(varName, iterableType);
+        return;
+    }
+    // Strategy C: $this->property — scan the enclosing class body for the property
+    // declaration and extract its element type from @var PHPDoc or native type.
+    // This handles the common PHP pattern where the property type is declared on the
+    // class body (/** @var User[] */ private $users) but the foreach is in a method
+    // whose scopeEnv does not contain the property type.
+    if (iterableNode?.type === 'member_access_expression') {
+        const obj = iterableNode.childForFieldName('object');
+        if (obj?.text === '$this') {
+            const nameNode = iterableNode.childForFieldName('name');
+            const propName = nameNode?.text;
+            if (propName) {
+                const classNode = findEnclosingClass(iterableNode);
+                if (classNode) {
+                    const elementType = findClassPropertyElementType(propName, classNode);
+                    if (elementType)
+                        scopeEnv.set(varName, elementType);
+                }
+            }
+        }
     }
 };
 export const typeConfig = {

package/dist/core/ingestion/type-extractors/python.js

@@ -239,13 +239,14 @@ const findPyParamElementType = (iterableName, startNode, pos = 'last') => {
  *   2. scopeEnv string — extractElementTypeFromString on the stored type
  *   3. AST walk — walks up to the enclosing function's parameters to read List[User] directly
  */
-const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }) => {
     if (node.type !== 'for_statement')
         return;
-    // The iterable is the `right` field — may be identifier or call (data.items()/keys()/values()).
+    // The iterable is the `right` field — may be identifier, attribute, or call.
     const rightNode = node.childForFieldName('right');
     let iterableName;
     let methodName;
+    let callExprElementType;
     if (rightNode?.type === 'identifier') {
         iterableName = rightNode.text;
     }
@@ -256,6 +257,7 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     }
     else if (rightNode?.type === 'call') {
         // data.items() → call > function: attribute > identifier('data') + identifier('items')
+        // get_users() → call > function: identifier (Phase 7.3 — return-type path)
         const fn = rightNode.childForFieldName('function');
         if (fn?.type === 'attribute') {
             const obj = fn.firstNamedChild;
@@ -266,12 +268,24 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
             if (method?.type === 'identifier' && method !== obj)
                 methodName = method.text;
         }
+        else if (fn?.type === 'identifier') {
+            // Direct function call: for user in get_users()
+            const rawReturn = returnTypeLookup.lookupRawReturnType(fn.text);
+            if (rawReturn)
+                callExprElementType = extractElementTypeFromString(rawReturn);
+        }
     }
-    if (!iterableName)
+    if (!iterableName && !callExprElementType)
         return;
-    const containerTypeName = scopeEnv.get(iterableName);
-    const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
-    const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractPyElementTypeFromAnnotation, findPyParamElementType, typeArgPos);
+    let elementType;
+    if (callExprElementType) {
+        elementType = callExprElementType;
+    }
+    else {
+        const containerTypeName = scopeEnv.get(iterableName);
+        const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
+        elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractPyElementTypeFromAnnotation, findPyParamElementType, typeArgPos);
+    }
     if (!elementType)
         return;
     // The loop variable is the `left` field — identifier or pattern_list.
@@ -312,7 +326,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
     if (!lhs || scopeEnv.has(lhs))
         return undefined;
     if (right.type === 'identifier')
-        return { lhs, rhs: right.text };
+        return { kind: 'copy', lhs, rhs: right.text };
     return undefined;
 };
 /**

package/dist/core/ingestion/type-extractors/ruby.js

@@ -324,7 +324,7 @@ const findRubyParamElementType = (iterableName, startNode) => {
  * Ruby has no static types on loop variables, so this mainly works when the
  * iterable has a YARD-annotated container type (e.g., `@param users [Array<User>]`).
  */
-const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope }) => {
     if (node.type !== 'for')
         return;
     // The loop variable is the `pattern` field (identifier).
@@ -374,7 +374,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
     const rhsNode = node.childForFieldName('right');
     if (!rhsNode || rhsNode.type !== 'identifier')
         return undefined;
-    return { lhs: varName, rhs: rhsNode.text };
+    return { kind: 'copy', lhs: varName, rhs: rhsNode.text };
 };
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,

package/dist/core/ingestion/type-extractors/rust.js

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, unwrapAwait, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
+import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, unwrapAwait, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'let_declaration',
     'let_condition',
@@ -210,7 +210,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
     if (!lhs || scopeEnv.has(lhs))
         return undefined;
     if (value.type === 'identifier')
-        return { lhs, rhs: value.text };
+        return { kind: 'copy', lhs, rhs: value.text };
     return undefined;
 };
 /**
@@ -375,7 +375,7 @@ const findRustParamElementType = (iterableName, startNode, pos = 'last') => {
 };
 /** Rust: for user in &users where users has a known container type.
  *  Unwraps reference_expression (&users, &mut users) to get the iterable name. */
-const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }) => {
     if (node.type !== 'for_expression')
         return;
     const patternNode = node.childForFieldName('pattern');
@@ -385,6 +385,7 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     // Extract iterable name + method — may be &users, users, or users.iter()/keys()/values()
     let iterableName;
     let methodName;
+    let callExprElementType;
     if (valueNode.type === 'reference_expression') {
         const inner = valueNode.lastNamedChild;
         if (inner?.type === 'identifier')
@@ -399,23 +400,35 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
             iterableName = prop.text;
     }
     else if (valueNode.type === 'call_expression') {
-        // users.iter() → call_expression > function: field_expression > identifier + field_identifier
-        const fieldExpr = valueNode.childForFieldName('function');
-        if (fieldExpr?.type === 'field_expression') {
-            const obj = fieldExpr.firstNamedChild;
+        const funcExpr = valueNode.childForFieldName('function');
+        if (funcExpr?.type === 'field_expression') {
+            // users.iter() → field_expression > identifier + field_identifier
+            const obj = funcExpr.firstNamedChild;
             if (obj?.type === 'identifier')
                 iterableName = obj.text;
             // Extract method name: iter, keys, values, into_iter, etc.
-            const field = fieldExpr.lastNamedChild;
+            const field = funcExpr.lastNamedChild;
             if (field?.type === 'field_identifier')
                 methodName = field.text;
         }
+        else if (funcExpr?.type === 'identifier') {
+            // Direct function call: for user in get_users()
+            const rawReturn = returnTypeLookup.lookupRawReturnType(funcExpr.text);
+            if (rawReturn)
+                callExprElementType = extractElementTypeFromString(rawReturn);
+        }
     }
-    if (!iterableName)
+    if (!iterableName && !callExprElementType)
         return;
-    const containerTypeName = scopeEnv.get(iterableName);
-    const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
-    const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractRustElementTypeFromTypeNode, findRustParamElementType, typeArgPos);
+    let elementType;
+    if (callExprElementType) {
+        elementType = callExprElementType;
+    }
+    else {
+        const containerTypeName = scopeEnv.get(iterableName);
+        const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
+        elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractRustElementTypeFromTypeNode, findRustParamElementType, typeArgPos);
+    }
     if (!elementType)
         return;
     const loopVarName = extractVarName(patternNode);

package/dist/core/ingestion/type-extractors/shared.d.ts

@@ -129,4 +129,5 @@ export declare const findChildByType: (node: SyntaxNode, type: string) => Syntax
  * Returns undefined when the extracted type is not a simple word.
  */
 export declare function extractElementTypeFromString(typeStr: string, pos?: TypeArgPosition): string | undefined;
+export declare const extractReturnTypeName: (raw: string, depth?: number) => string | undefined;
 export {};