gitnexus 1.4.6 → 1.4.7

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

@@ -219,6 +219,32 @@ const extractJavaPendingAssignment = (node, scopeEnv) => {
             continue;
         if (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier')
             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;
 };
@@ -589,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);
@@ -602,6 +628,31 @@ const extractKotlinPendingAssignment = (node, scopeEnv) => {
             if (foundEq && child.type === 'simple_identifier') {
                 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;
     }
@@ -613,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;
@@ -630,6 +680,28 @@ const extractKotlinPendingAssignment = (node, scopeEnv) => {
             if (foundEq && child.type === 'simple_identifier') {
                 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;
     }

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

@@ -373,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 { kind: 'copy', 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',

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,15 +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, returnTypeLookup }) => {
     if (node.type !== 'for_statement')
         return;
-    // The iterable is the `right` field — may be identifier, attribute, or call.
     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;
     }
@@ -256,20 +296,28 @@ const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, re
             iterableName = prop.text;
     }
     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;
-            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()
+            // 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);
@@ -292,11 +340,12 @@ const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, re
     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;
     }
@@ -327,6 +376,29 @@ const extractPendingAssignment = (node, scopeEnv) => {
         return undefined;
     if (right.type === 'identifier')
         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

@@ -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 { kind: 'copy', 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

@@ -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 { kind: 'copy', 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;
 };
 /**

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

@@ -130,4 +130,16 @@ export declare const findChildByType: (node: SyntaxNode, type: string) => Syntax
  */
 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 {};

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

@@ -226,9 +226,14 @@ export const extractSimpleTypeName = (typeNode, depth = 0) => {
     }
     // Pointer/reference types (C++, Rust): User*, &User, &mut User
     if (typeNode.type === 'pointer_type' || typeNode.type === 'reference_type') {
-        const inner = typeNode.firstNamedChild;
-        if (inner)
-            return extractSimpleTypeName(inner, depth + 1);
+        // Skip mutable_specifier for Rust &mut references — firstNamedChild would be
+        // `mutable_specifier` not the actual type. Walk named children to find the type.
+        for (let i = 0; i < typeNode.namedChildCount; i++) {
+            const child = typeNode.namedChild(i);
+            if (child && child.type !== 'mutable_specifier') {
+                return extractSimpleTypeName(child, depth + 1);
+            }
+        }
     }
     // Primitive/predefined types: string, int, float, bool, number, unknown, any
     // PHP: primitive_type; TS/JS: predefined_type
@@ -701,3 +706,105 @@ export const extractReturnTypeName = (raw, depth = 0) => {
         return undefined;
     return text;
 };
+// ── Property declared-type extraction ────────────────────────────────────
+// Shared between parse-worker (worker path) and parsing-processor (sequential path).
+/**
+ * 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 const extractPropertyDeclaredType = (definitionNode) => {
+    if (!definitionNode)
+        return undefined;
+    // Strategy 1: Look for a `type` or `type_annotation` named field
+    const typeNode = definitionNode.childForFieldName?.('type');
+    if (typeNode) {
+        const typeName = extractSimpleTypeName(typeNode);
+        if (typeName)
+            return typeName;
+        // Fallback: use the raw text (for complex types like User[] or List<User>)
+        const text = typeNode.text?.trim();
+        if (text && text.length < 100)
+            return text;
+    }
+    // Strategy 2: Walk children looking for type_annotation (TypeScript pattern)
+    for (let i = 0; i < definitionNode.childCount; i++) {
+        const child = definitionNode.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'type_annotation') {
+            // Type annotation has the actual type as a child
+            for (let j = 0; j < child.childCount; j++) {
+                const typeChild = child.child(j);
+                if (typeChild && typeChild.type !== ':') {
+                    const typeName = extractSimpleTypeName(typeChild);
+                    if (typeName)
+                        return typeName;
+                    const text = typeChild.text?.trim();
+                    if (text && text.length < 100)
+                        return text;
+                }
+            }
+        }
+    }
+    // Strategy 3: For Java field_declaration, the type is a sibling of variable_declarator
+    // AST: (field_declaration type: (type_identifier) declarator: (variable_declarator ...))
+    const parentDecl = definitionNode.parent;
+    if (parentDecl) {
+        const parentType = parentDecl.childForFieldName?.('type');
+        if (parentType) {
+            const typeName = extractSimpleTypeName(parentType);
+            if (typeName)
+                return typeName;
+        }
+    }
+    // Strategy 4: Kotlin property_declaration — type is nested inside variable_declaration child
+    // AST: (property_declaration (variable_declaration (simple_identifier) ":" (user_type (type_identifier))))
+    // Kotlin's variable_declaration has NO named 'type' field — children are all positional.
+    for (let i = 0; i < definitionNode.childCount; i++) {
+        const child = definitionNode.child(i);
+        if (child?.type === 'variable_declaration') {
+            // Try named field first (works for other languages sharing this strategy)
+            const varType = child.childForFieldName?.('type');
+            if (varType) {
+                const typeName = extractSimpleTypeName(varType);
+                if (typeName)
+                    return typeName;
+                const text = varType.text?.trim();
+                if (text && text.length < 100)
+                    return text;
+            }
+            // Fallback: walk unnamed children for user_type / type_identifier (Kotlin)
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const varChild = child.namedChild(j);
+                if (varChild && (varChild.type === 'user_type' || varChild.type === 'type_identifier'
+                    || varChild.type === 'nullable_type' || varChild.type === 'generic_type')) {
+                    const typeName = extractSimpleTypeName(varChild);
+                    if (typeName)
+                        return typeName;
+                }
+            }
+        }
+    }
+    // Strategy 5: PHP @var PHPDoc — look for preceding comment with @var Type
+    // Handles pre-PHP-7.4 code: /** @var Address */ public $address;
+    const prevSibling = definitionNode.previousNamedSibling ?? definitionNode.parent?.previousNamedSibling;
+    if (prevSibling?.type === 'comment') {
+        const commentText = prevSibling.text;
+        const varMatch = commentText?.match(/@var\s+([A-Z][\w\\]*)/);
+        if (varMatch) {
+            // Strip namespace prefix: \App\Models\User → User
+            const raw = varMatch[1];
+            const base = raw.includes('\\') ? raw.split('\\').pop() : raw;
+            if (base && /^[A-Z]\w*$/.test(base))
+                return base;
+        }
+    }
+    return undefined;
+};

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

@@ -49,8 +49,10 @@ export interface ForLoopExtractorContext {
 /** Extracts loop variable type binding from a for-each statement. */
 export type ForLoopExtractor = (node: SyntaxNode, ctx: ForLoopExtractorContext) => void;
 /** Discriminated union for pending Tier-2 propagation items.
- *  - `copy`       — `const b = a` (identifier alias, propagate a's type to b)
- *  - `callResult` — `const b = foo()` (bind b to foo's declared return type) */
+ *  - `copy`             — `const b = a` (identifier alias, propagate a's type to b)
+ *  - `callResult`       — `const b = foo()` (bind b to foo's declared return type)
+ *  - `fieldAccess`      — `const b = a.field` (bind b to field's declaredType on a's type)
+ *  - `methodCallResult` — `const b = a.method()` (bind b to method's returnType on a's type) */
 export type PendingAssignment = {
     kind: 'copy';
     lhs: string;
@@ -59,10 +61,21 @@ export type PendingAssignment = {
     kind: 'callResult';
     lhs: string;
     callee: string;
+} | {
+    kind: 'fieldAccess';
+    lhs: string;
+    receiver: string;
+    field: string;
+} | {
+    kind: 'methodCallResult';
+    lhs: string;
+    receiver: string;
+    method: string;
 };
 /** Extracts a pending assignment for Tier 2 propagation.
- *  Returns a PendingAssignment when the RHS is a bare identifier (`copy`) or a
- *  call expression (`callResult`) and the LHS has no resolved type yet.
+ *  Returns a PendingAssignment when the RHS is a bare identifier (`copy`), a
+ *  call expression (`callResult`), a field access (`fieldAccess`), or a
+ *  method call with receiver (`methodCallResult`) and the LHS has no resolved type yet.
  *  Returns undefined if the node is not a matching assignment. */
 export type PendingAssignmentExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMap<string, string>) => PendingAssignment | undefined;
 /** Extracts a typed variable binding from a pattern-matching construct.

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

@@ -459,6 +459,36 @@ const extractPendingAssignment = (node, scopeEnv) => {
             continue;
         if (valueNode.type === 'identifier')
             return { kind: 'copy', lhs, rhs: valueNode.text };
+        // member_expression RHS → fieldAccess (a.field, this.field)
+        if (valueNode.type === 'member_expression') {
+            const obj = valueNode.childForFieldName('object');
+            const prop = valueNode.childForFieldName('property');
+            if (obj && prop?.type === 'property_identifier' &&
+                (obj.type === 'identifier' || obj.type === 'this')) {
+                return { kind: 'fieldAccess', lhs, receiver: obj.text, field: prop.text };
+            }
+            continue;
+        }
+        // Unwrap await: `const user = await fetchUser()` or `await a.getC()`
+        const callNode = unwrapAwait(valueNode);
+        if (!callNode || callNode.type !== 'call_expression')
+            continue;
+        const funcNode = callNode.childForFieldName('function');
+        if (!funcNode)
+            continue;
+        // Simple call → callResult: getUser()
+        if (funcNode.type === 'identifier') {
+            return { kind: 'callResult', lhs, callee: funcNode.text };
+        }
+        // Method call with receiver → methodCallResult: a.getC()
+        if (funcNode.type === 'member_expression') {
+            const obj = funcNode.childForFieldName('object');
+            const prop = funcNode.childForFieldName('property');
+            if (obj && prop?.type === 'property_identifier' &&
+                (obj.type === 'identifier' || obj.type === 'this')) {
+                return { kind: 'methodCallResult', lhs, receiver: obj.text, method: prop.text };
+            }
+        }
     }
     return undefined;
 };

package/dist/core/ingestion/utils.d.ts

@@ -110,4 +110,29 @@ export declare function extractCallChain(receiverCallNode: SyntaxNode): {
     chain: string[];
     baseReceiverName: string | undefined;
 } | undefined;
+/** One step in a mixed receiver chain. */
+export type MixedChainStep = {
+    kind: 'field' | 'call';
+    name: string;
+};
+/**
+ * Walk a receiver AST node that may interleave field accesses and method calls,
+ * building a unified chain of steps up to MAX_CHAIN_DEPTH.
+ *
+ * For `svc.getUser().address.save()`, called with the receiver of `save`
+ * (`svc.getUser().address`, a field access node):
+ *   returns { chain: [{ kind:'call', name:'getUser' }, { kind:'field', name:'address' }],
+ *             baseReceiverName: 'svc' }
+ *
+ * For `user.getAddress().city.getName()`, called with receiver of `getName`
+ * (`user.getAddress().city`):
+ *   returns { chain: [{ kind:'call', name:'getAddress' }, { kind:'field', name:'city' }],
+ *             baseReceiverName: 'user' }
+ *
+ * Pure field chains and pure call chains are special cases (all steps same kind).
+ */
+export declare function extractMixedChain(receiverNode: SyntaxNode): {
+    chain: MixedChainStep[];
+    baseReceiverName: string | undefined;
+} | undefined;
 export {};