gitnexus 1.4.5 → 1.4.7

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;
@@ -280,13 +373,40 @@ const extractPendingAssignment = (node, scopeEnv) => {
     const right = node.childForFieldName('right');
     if (!left || !right)
         return undefined;
-    if (left.type !== 'variable_name' || right.type !== 'variable_name')
+    if (left.type !== 'variable_name')
         return undefined;
     const lhs = left.text;
-    const rhs = right.text;
-    if (!lhs || !rhs || scopeEnv.has(lhs))
+    if (!lhs || scopeEnv.has(lhs))
         return undefined;
-    return { lhs, rhs };
+    if (right.type === 'variable_name') {
+        const rhs = right.text;
+        if (rhs)
+            return { kind: 'copy', lhs, rhs };
+    }
+    // member_access_expression RHS → fieldAccess ($a->field)
+    if (right.type === 'member_access_expression') {
+        const obj = right.childForFieldName('object');
+        const name = right.childForFieldName('name');
+        if (obj?.type === 'variable_name' && name) {
+            return { kind: 'fieldAccess', lhs, receiver: obj.text, field: name.text };
+        }
+    }
+    // function_call_expression RHS → callResult (bare function calls only)
+    if (right.type === 'function_call_expression') {
+        const funcNode = right.childForFieldName('function');
+        if (funcNode?.type === 'name') {
+            return { kind: 'callResult', lhs, callee: funcNode.text };
+        }
+    }
+    // member_call_expression RHS → methodCallResult ($a->method())
+    if (right.type === 'member_call_expression') {
+        const obj = right.childForFieldName('object');
+        const name = right.childForFieldName('name');
+        if (obj?.type === 'variable_name' && name) {
+            return { kind: 'methodCallResult', lhs, receiver: obj.text, method: name.text };
+        }
+    }
+    return undefined;
 };
 const FOR_LOOP_NODE_TYPES = new Set([
     'foreach_statement',
@@ -339,7 +459,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 +493,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 +504,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 +540,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

@@ -61,6 +61,10 @@ const extractParameter = (node, env) => {
     else {
         nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
         typeNode = node.childForFieldName('type');
+        // Python typed_parameter: name is a positional child (identifier), not a named field
+        if (!nameNode && node.type === 'typed_parameter') {
+            nameNode = node.firstNamedChild?.type === 'identifier' ? node.firstNamedChild : null;
+        }
     }
     if (!nameNode || !typeNode)
         return;
@@ -229,6 +233,38 @@ const findPyParamElementType = (iterableName, startNode, pos = 'last') => {
     }
     return undefined;
 };
+/**
+ * Extracts iterableName and methodName from a call expression like `data.items()`.
+ * Returns undefined if the call doesn't match the expected pattern.
+ */
+const extractMethodCall = (callNode) => {
+    const fn = callNode.childForFieldName('function');
+    if (fn?.type !== 'attribute')
+        return undefined;
+    const obj = fn.firstNamedChild;
+    if (obj?.type !== 'identifier')
+        return undefined;
+    const method = fn.lastNamedChild;
+    const methodName = (method?.type === 'identifier' && method !== obj) ? method.text : undefined;
+    return { iterableName: obj.text, methodName };
+};
+/**
+ * Collects all identifier nodes from a pattern, descending into nested tuple_patterns.
+ * For `i, (k, v)` returns [i, k, v]. For `key, value` returns [key, value].
+ */
+const collectPatternIdentifiers = (pattern) => {
+    const vars = [];
+    for (let i = 0; i < pattern.namedChildCount; i++) {
+        const child = pattern.namedChild(i);
+        if (child?.type === 'identifier') {
+            vars.push(child);
+        }
+        else if (child?.type === 'tuple_pattern') {
+            vars.push(...collectPatternIdentifiers(child));
+        }
+    }
+    return vars;
+};
 /**
  * Python: for user in users: where users has a known container type annotation.
  *
@@ -238,14 +274,19 @@ const findPyParamElementType = (iterableName, startNode, pos = 'last') => {
  *   1. declarationTypeNodes — raw type annotation AST node (covers stored container types)
  *   2. scopeEnv string — extractElementTypeFromString on the stored type
  *   3. AST walk — walks up to the enclosing function's parameters to read List[User] directly
+ *
+ * Also handles `enumerate(iterable)` — unwraps the outer call and skips the integer
+ * index variable so the value variable still resolves to the element type.
  */
-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()).
     const rightNode = node.childForFieldName('right');
     let iterableName;
     let methodName;
+    let callExprElementType;
+    let isEnumerate = false;
+    // Extract iterable info from the `right` field — may be identifier, attribute, or call.
     if (rightNode?.type === 'identifier') {
         iterableName = rightNode.text;
     }
@@ -255,34 +296,56 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
             iterableName = prop.text;
     }
     else if (rightNode?.type === 'call') {
-        // data.items() → call > function: attribute > identifier('data') + identifier('items')
         const fn = rightNode.childForFieldName('function');
-        if (fn?.type === 'attribute') {
-            const obj = fn.firstNamedChild;
-            if (obj?.type === 'identifier')
-                iterableName = obj.text;
-            // Extract method name: items, keys, values
-            const method = fn.lastNamedChild;
-            if (method?.type === 'identifier' && method !== obj)
-                methodName = method.text;
+        if (fn?.type === 'identifier' && fn.text === 'enumerate') {
+            // enumerate(iterable) or enumerate(d.items()) — unwrap to inner iterable.
+            isEnumerate = true;
+            const innerArg = rightNode.childForFieldName('arguments')?.firstNamedChild;
+            if (innerArg?.type === 'identifier') {
+                iterableName = innerArg.text;
+            }
+            else if (innerArg?.type === 'call') {
+                const extracted = extractMethodCall(innerArg);
+                if (extracted)
+                    ({ iterableName, methodName } = extracted);
+            }
+        }
+        else if (fn?.type === 'attribute') {
+            // data.items() → call > function: attribute > identifier('data') + identifier('items')
+            const extracted = extractMethodCall(rightNode);
+            if (extracted)
+                ({ iterableName, methodName } = extracted);
+        }
+        else if (fn?.type === 'identifier') {
+            // Direct function call: for user in get_users() (Phase 7.3 — return-type path)
+            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.
     const leftNode = node.childForFieldName('left');
     if (!leftNode)
         return;
-    // Handle tuple unpacking: for key, value in data.items()
-    if (leftNode.type === 'pattern_list') {
-        const lastChild = leftNode.lastNamedChild;
-        if (lastChild?.type === 'identifier') {
-            scopeEnv.set(lastChild.text, elementType);
+    if (leftNode.type === 'pattern_list' || leftNode.type === 'tuple_pattern') {
+        // Tuple unpacking: `key, value` or `i, (k, v)` or `(k, v)` — bind the last identifier to element type.
+        // With enumerate, skip binding if there's only one var (just the index, no value to bind).
+        const vars = collectPatternIdentifiers(leftNode);
+        if (vars.length > 0 && (!isEnumerate || vars.length > 1)) {
+            scopeEnv.set(vars[vars.length - 1].text, elementType);
         }
         return;
     }
@@ -312,7 +375,30 @@ 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 };
+    // attribute RHS → fieldAccess (a.field)
+    if (right.type === 'attribute') {
+        const obj = right.firstNamedChild;
+        const field = right.lastNamedChild;
+        if (obj?.type === 'identifier' && field?.type === 'identifier' && obj !== field) {
+            return { kind: 'fieldAccess', lhs, receiver: obj.text, field: field.text };
+        }
+    }
+    // call RHS
+    if (right.type === 'call') {
+        const funcNode = right.childForFieldName('function');
+        if (funcNode?.type === 'identifier') {
+            return { kind: 'callResult', lhs, callee: funcNode.text };
+        }
+        // method call with receiver: call → function: attribute
+        if (funcNode?.type === 'attribute') {
+            const obj = funcNode.firstNamedChild;
+            const method = funcNode.lastNamedChild;
+            if (obj?.type === 'identifier' && method?.type === 'identifier' && obj !== method) {
+                return { kind: 'methodCallResult', lhs, receiver: obj.text, method: method.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).
@@ -372,9 +372,24 @@ const extractPendingAssignment = (node, scopeEnv) => {
     if (scopeEnv.has(varName))
         return undefined;
     const rhsNode = node.childForFieldName('right');
-    if (!rhsNode || rhsNode.type !== 'identifier')
+    if (!rhsNode)
         return undefined;
-    return { lhs: varName, rhs: rhsNode.text };
+    if (rhsNode.type === 'identifier')
+        return { kind: 'copy', lhs: varName, rhs: rhsNode.text };
+    // call/method_call RHS — Ruby uses method calls for both field access and method calls
+    if (rhsNode.type === 'call' || rhsNode.type === 'method_call') {
+        const methodNode = rhsNode.childForFieldName('method');
+        const receiverNode = rhsNode.childForFieldName('receiver');
+        if (!receiverNode && methodNode?.type === 'identifier') {
+            // No receiver → callResult (bare function call)
+            return { kind: 'callResult', lhs: varName, callee: methodNode.text };
+        }
+        if (receiverNode?.type === 'identifier' && methodNode?.type === 'identifier') {
+            // With receiver → methodCallResult (a.method)
+            return { kind: 'methodCallResult', lhs: varName, receiver: receiverNode.text, method: methodNode.text };
+        }
+    }
+    return undefined;
 };
 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',
@@ -95,7 +95,7 @@ const extractDeclaration = (node, env) => {
         env.set(varName, typeName);
 };
 /** Rust: let x = User::new(), let x = User::default(), or let x = User { ... } */
-const extractInitializer = (node, env, _classNames) => {
+const extractInitializer = (node, env, classNames) => {
     // Skip if there's an explicit type annotation — Tier 0 already handled it
     if (node.childForFieldName('type') !== null)
         return;
@@ -119,6 +119,13 @@ const extractInitializer = (node, env, _classNames) => {
             env.set(varName, typeName);
         return;
     }
+    // Unit struct instantiation: let svc = UserService; (bare identifier, no braces or call)
+    if (value.type === 'identifier' && classNames.has(value.text)) {
+        const varName = extractVarName(pattern);
+        if (varName)
+            env.set(varName, value.text);
+        return;
+    }
     if (value.type !== 'call_expression')
         return;
     const func = value.childForFieldName('function');
@@ -209,8 +216,35 @@ const extractPendingAssignment = (node, scopeEnv) => {
     const lhs = extractVarName(pattern);
     if (!lhs || scopeEnv.has(lhs))
         return undefined;
-    if (value.type === 'identifier')
-        return { lhs, rhs: value.text };
+    // Unwrap Rust .await: `let user = get_user().await` → call_expression
+    const unwrapped = unwrapAwait(value) ?? value;
+    if (unwrapped.type === 'identifier')
+        return { kind: 'copy', lhs, rhs: unwrapped.text };
+    // field_expression RHS → fieldAccess (a.field)
+    if (unwrapped.type === 'field_expression') {
+        const obj = unwrapped.firstNamedChild;
+        const field = unwrapped.lastNamedChild;
+        if (obj?.type === 'identifier' && field?.type === 'field_identifier') {
+            return { kind: 'fieldAccess', lhs, receiver: obj.text, field: field.text };
+        }
+    }
+    // call_expression RHS → callResult (simple calls only)
+    if (unwrapped.type === 'call_expression') {
+        const funcNode = unwrapped.childForFieldName('function');
+        if (funcNode?.type === 'identifier') {
+            return { kind: 'callResult', lhs, callee: funcNode.text };
+        }
+    }
+    // method_call_expression RHS → methodCallResult (receiver.method())
+    if (unwrapped.type === 'method_call_expression') {
+        const obj = unwrapped.firstNamedChild;
+        if (obj?.type === 'identifier') {
+            const methodNode = unwrapped.childForFieldName('name') ?? unwrapped.namedChild(1);
+            if (methodNode?.type === 'field_identifier') {
+                return { kind: 'methodCallResult', lhs, receiver: obj.text, method: methodNode.text };
+            }
+        }
+    }
     return undefined;
 };
 /**
@@ -375,7 +409,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 +419,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 +434,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,17 @@ 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;
+/**
+ * Extract the declared type of a property/field from its AST definition node.
+ * Handles cross-language patterns:
+ * - TypeScript: `name: Type` → type_annotation child
+ * - Java: `Type name` → type child on field_declaration
+ * - C#: `Type Name { get; set; }` → type child on property_declaration
+ * - Go: `Name Type` → type child on field_declaration
+ * - Kotlin: `var name: Type` → variable_declaration child with type field
+ *
+ * Returns the normalized type name, or undefined if no type can be extracted.
+ */
+export declare const extractPropertyDeclaredType: (definitionNode: SyntaxNode | null) => string | undefined;
 export {};