gitnexus 1.4.5 → 1.4.7

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

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
+import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
 /** Known container property accessors that operate on the container itself (e.g., dict.Keys, dict.Values) */
 const KNOWN_CONTAINER_PROPS = new Set(['Keys', 'Values']);
 const DECLARATION_NODE_TYPES = new Set([
@@ -214,7 +214,7 @@ const findCSharpParamElementType = (iterableName, startNode, pos = 'last') => {
 };
 /** C#: foreach (User user in users) — extract loop variable binding.
  *  Tier 1c: for `foreach (var user in users)`, resolves element type from iterable. */
-const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }) => {
     const typeNode = node.childForFieldName('type');
     const nameNode = node.childForFieldName('left');
     if (!typeNode || !nameNode)
@@ -233,6 +233,7 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     const rightNode = node.childForFieldName('right');
     let iterableName;
     let methodName;
+    let callExprElementType;
     if (rightNode?.type === 'identifier') {
         iterableName = rightNode.text;
     }
@@ -261,6 +262,7 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     }
     else if (rightNode?.type === 'invocation_expression') {
         // C# method call: data.Select(...) → invocation_expression > member_access_expression
+        // Direct function call: GetUsers() → invocation_expression > identifier
         const fn = rightNode.firstNamedChild;
         if (fn?.type === 'member_access_expression') {
             const obj = fn.childForFieldName('expression');
@@ -270,12 +272,24 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
             if (prop?.type === 'identifier')
                 methodName = prop.text;
         }
+        else if (fn?.type === 'identifier') {
+            // Direct function call: foreach (var u in GetUsers())
+            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, extractCSharpElementTypeFromTypeNode, findCSharpParamElementType, 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, extractCSharpElementTypeFromTypeNode, findCSharpParamElementType, typeArgPos);
+    }
     if (elementType)
         scopeEnv.set(varName, elementType);
 };
@@ -351,7 +365,47 @@ const extractPendingAssignment = (node, scopeEnv) => {
         }
         const valueNode = evc?.firstNamedChild ?? child.namedChild(child.namedChildCount - 1);
         if (valueNode && valueNode !== nameNode && (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier')) {
-            return { lhs, rhs: valueNode.text };
+            return { kind: 'copy', lhs, rhs: valueNode.text };
+        }
+        // member_access_expression RHS → fieldAccess (a.Field)
+        if (valueNode?.type === 'member_access_expression') {
+            const expr = valueNode.childForFieldName('expression');
+            const name = valueNode.childForFieldName('name');
+            if (expr?.type === 'identifier' && name?.type === 'identifier') {
+                return { kind: 'fieldAccess', lhs, receiver: expr.text, field: name.text };
+            }
+        }
+        // invocation_expression RHS
+        if (valueNode?.type === 'invocation_expression') {
+            const funcNode = valueNode.firstNamedChild;
+            if (funcNode?.type === 'identifier_name' || funcNode?.type === 'identifier') {
+                return { kind: 'callResult', lhs, callee: funcNode.text };
+            }
+            // method call with receiver → methodCallResult: a.GetC()
+            if (funcNode?.type === 'member_access_expression') {
+                const expr = funcNode.childForFieldName('expression');
+                const name = funcNode.childForFieldName('name');
+                if (expr?.type === 'identifier' && name?.type === 'identifier') {
+                    return { kind: 'methodCallResult', lhs, receiver: expr.text, method: name.text };
+                }
+            }
+        }
+        // await_expression → unwrap and check inner
+        if (valueNode?.type === 'await_expression') {
+            const inner = valueNode.firstNamedChild;
+            if (inner?.type === 'invocation_expression') {
+                const funcNode = inner.firstNamedChild;
+                if (funcNode?.type === 'identifier_name' || funcNode?.type === 'identifier') {
+                    return { kind: 'callResult', lhs, callee: funcNode.text };
+                }
+                if (funcNode?.type === 'member_access_expression') {
+                    const expr = funcNode.childForFieldName('expression');
+                    const name = funcNode.childForFieldName('name');
+                    if (expr?.type === 'identifier' && name?.type === 'identifier') {
+                        return { kind: 'methodCallResult', lhs, receiver: expr.text, method: name.text };
+                    }
+                }
+            }
         }
     }
     return undefined;

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,30 @@ 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 };
+        // selector_expression RHS → fieldAccess (a.field)
+        if (rhsNode.type === 'selector_expression') {
+            const operand = rhsNode.childForFieldName('operand');
+            const field = rhsNode.childForFieldName('field');
+            if (operand?.type === 'identifier' && field) {
+                return { kind: 'fieldAccess', lhs, receiver: operand.text, field: field.text };
+            }
+        }
+        // call_expression RHS
+        if (rhsNode.type === 'call_expression') {
+            const funcNode = rhsNode.childForFieldName('function');
+            if (funcNode?.type === 'identifier') {
+                return { kind: 'callResult', lhs, callee: funcNode.text };
+            }
+            // method call with receiver: call_expression → function: selector_expression
+            if (funcNode?.type === 'selector_expression') {
+                const operand = funcNode.childForFieldName('operand');
+                const field = funcNode.childForFieldName('field');
+                if (operand?.type === 'identifier' && field) {
+                    return { kind: 'methodCallResult', lhs, receiver: operand.text, method: field.text };
+                }
+            }
+        }
         return undefined;
     }
     if (node.type === 'var_spec' || node.type === 'var_declaration') {
@@ -420,7 +474,29 @@ const extractPendingAssignment = (node, scopeEnv) => {
             }
             const rhsNode = exprList?.firstNamedChild;
             if (rhsNode?.type === 'identifier')
-                return { lhs, rhs: rhsNode.text };
+                return { kind: 'copy', lhs, rhs: rhsNode.text };
+            // selector_expression RHS → fieldAccess
+            if (rhsNode?.type === 'selector_expression') {
+                const operand = rhsNode.childForFieldName('operand');
+                const field = rhsNode.childForFieldName('field');
+                if (operand?.type === 'identifier' && field) {
+                    return { kind: 'fieldAccess', lhs, receiver: operand.text, field: field.text };
+                }
+            }
+            // call_expression RHS
+            if (rhsNode?.type === 'call_expression') {
+                const funcNode = rhsNode.childForFieldName('function');
+                if (funcNode?.type === 'identifier') {
+                    return { kind: 'callResult', lhs, callee: funcNode.text };
+                }
+                if (funcNode?.type === 'selector_expression') {
+                    const operand = funcNode.childForFieldName('operand');
+                    const field = funcNode.childForFieldName('field');
+                    if (operand?.type === 'identifier' && field) {
+                        return { kind: 'methodCallResult', lhs, receiver: operand.text, method: field.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,33 @@ 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 };
+        // field_access RHS → fieldAccess (a.field)
+        if (valueNode.type === 'field_access') {
+            const obj = valueNode.childForFieldName('object');
+            const field = valueNode.childForFieldName('field');
+            if (obj?.type === 'identifier' && field) {
+                return { kind: 'fieldAccess', lhs, receiver: obj.text, field: field.text };
+            }
+        }
+        // method_invocation RHS
+        if (valueNode.type === 'method_invocation') {
+            const objField = valueNode.childForFieldName('object');
+            if (!objField) {
+                // No receiver → callResult
+                const nameField = valueNode.childForFieldName('name');
+                if (nameField?.type === 'identifier') {
+                    return { kind: 'callResult', lhs, callee: nameField.text };
+                }
+            }
+            else if (objField.type === 'identifier') {
+                // With receiver → methodCallResult
+                const nameField = valueNode.childForFieldName('name');
+                if (nameField?.type === 'identifier') {
+                    return { kind: 'methodCallResult', lhs, receiver: objField.text, method: nameField.text };
+                }
+            }
+        }
     }
     return undefined;
 };
@@ -459,7 +498,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 +523,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 +569,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);
 };
@@ -562,7 +615,7 @@ const extractKotlinPendingAssignment = (node, scopeEnv) => {
         const lhs = nameNode.text;
         if (scopeEnv.has(lhs))
             return undefined;
-        // Find the RHS: a simple_identifier sibling after the "=" token
+        // Find the RHS after the "=" token
         let foundEq = false;
         for (let i = 0; i < node.childCount; i++) {
             const child = node.child(i);
@@ -573,7 +626,32 @@ const extractKotlinPendingAssignment = (node, scopeEnv) => {
                 continue;
             }
             if (foundEq && child.type === 'simple_identifier') {
-                return { lhs, rhs: child.text };
+                return { kind: 'copy', lhs, rhs: child.text };
+            }
+            // navigation_expression RHS → fieldAccess (a.field)
+            if (foundEq && child.type === 'navigation_expression') {
+                const recv = child.firstNamedChild;
+                const suffix = child.lastNamedChild;
+                const fieldNode = suffix?.type === 'navigation_suffix' ? suffix.lastNamedChild : suffix;
+                if (recv?.type === 'simple_identifier' && fieldNode?.type === 'simple_identifier') {
+                    return { kind: 'fieldAccess', lhs, receiver: recv.text, field: fieldNode.text };
+                }
+            }
+            // call_expression RHS
+            if (foundEq && child.type === 'call_expression') {
+                const calleeNode = child.firstNamedChild;
+                if (calleeNode?.type === 'simple_identifier') {
+                    return { kind: 'callResult', lhs, callee: calleeNode.text };
+                }
+                // navigation_expression callee → methodCallResult (a.method())
+                if (calleeNode?.type === 'navigation_expression') {
+                    const recv = calleeNode.firstNamedChild;
+                    const suffix = calleeNode.lastNamedChild;
+                    const methodNode = suffix?.type === 'navigation_suffix' ? suffix.lastNamedChild : suffix;
+                    if (recv?.type === 'simple_identifier' && methodNode?.type === 'simple_identifier') {
+                        return { kind: 'methodCallResult', lhs, receiver: recv.text, method: methodNode.text };
+                    }
+                }
             }
         }
         return undefined;
@@ -586,8 +664,7 @@ const extractKotlinPendingAssignment = (node, scopeEnv) => {
         const lhs = nameNode.text;
         if (scopeEnv.has(lhs))
             return undefined;
-        // Look for RHS simple_identifier after "=" in the parent (property_declaration)
-        // variable_declaration itself doesn't contain "=" — it's in the parent
+        // Look for RHS after "=" in the parent (property_declaration)
         const parent = node.parent;
         if (!parent)
             return undefined;
@@ -601,7 +678,29 @@ const extractKotlinPendingAssignment = (node, scopeEnv) => {
                 continue;
             }
             if (foundEq && child.type === 'simple_identifier') {
-                return { lhs, rhs: child.text };
+                return { kind: 'copy', lhs, rhs: child.text };
+            }
+            if (foundEq && child.type === 'navigation_expression') {
+                const recv = child.firstNamedChild;
+                const suffix = child.lastNamedChild;
+                const fieldNode = suffix?.type === 'navigation_suffix' ? suffix.lastNamedChild : suffix;
+                if (recv?.type === 'simple_identifier' && fieldNode?.type === 'simple_identifier') {
+                    return { kind: 'fieldAccess', lhs, receiver: recv.text, field: fieldNode.text };
+                }
+            }
+            if (foundEq && child.type === 'call_expression') {
+                const calleeNode = child.firstNamedChild;
+                if (calleeNode?.type === 'simple_identifier') {
+                    return { kind: 'callResult', lhs, callee: calleeNode.text };
+                }
+                if (calleeNode?.type === 'navigation_expression') {
+                    const recv = calleeNode.firstNamedChild;
+                    const suffix = calleeNode.lastNamedChild;
+                    const methodNode = suffix?.type === 'navigation_suffix' ? suffix.lastNamedChild : suffix;
+                    if (recv?.type === 'simple_identifier' && methodNode?.type === 'simple_identifier') {
+                        return { kind: 'methodCallResult', lhs, receiver: recv.text, method: methodNode.text };
+                    }
+                }
             }
         }
         return undefined;