gitnexus 1.4.5 → 1.4.7

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

@@ -132,7 +132,7 @@ export function resolveIterableElementType(iterableName, node, scopeEnv, declara
 /** Known single-arg nullable wrapper types that unwrap to their inner type
  *  for receiver resolution. Optional<User> → "User", Option<User> → "User".
  *  Only nullable wrappers — NOT containers (List, Vec) or async wrappers (Promise, Future).
- *  See call-processor.ts WRAPPER_GENERICS for the full set used in return-type inference. */
+ *  See WRAPPER_GENERICS below for the full set used in return-type inference. */
 const NULLABLE_WRAPPER_TYPES = new Set([
     'Optional', // Java
     'Option', // Rust, Scala
@@ -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
@@ -569,3 +574,237 @@ export function extractElementTypeFromString(typeStr, pos = 'last') {
     }
     return undefined;
 }
+// ── Return type text helpers ─────────────────────────────────────────────
+// extractReturnTypeName works on raw return-type text already stored in
+// SymbolDefinition (e.g. "User", "Promise<User>", "User | null", "*User").
+// Extracts the base user-defined type name.
+/** Primitive / built-in types that should NOT produce a receiver binding. */
+const PRIMITIVE_TYPES = new Set([
+    'string', 'number', 'boolean', 'void', 'int', 'float', 'double', 'long',
+    'short', 'byte', 'char', 'bool', 'str', 'i8', 'i16', 'i32', 'i64',
+    'u8', 'u16', 'u32', 'u64', 'f32', 'f64', 'usize', 'isize',
+    'undefined', 'null', 'None', 'nil',
+]);
+/**
+ * Extract a simple type name from raw return-type text.
+ * Handles common patterns:
+ *   "User"                → "User"
+ *   "Promise<User>"       → "User"   (unwrap wrapper generics)
+ *   "Option<User>"        → "User"
+ *   "Result<User, Error>" → "User"   (first type arg)
+ *   "User | null"         → "User"   (strip nullable union)
+ *   "User?"               → "User"   (strip nullable suffix)
+ *   "*User"               → "User"   (Go pointer)
+ *   "&User"               → "User"   (Rust reference)
+ * Returns undefined for complex types or primitives.
+ */
+const WRAPPER_GENERICS = new Set([
+    'Promise', 'Observable', 'Future', 'CompletableFuture', 'Task', 'ValueTask', // async wrappers
+    'Option', 'Some', 'Optional', 'Maybe', // nullable wrappers
+    'Result', 'Either', // result wrappers
+    // Rust smart pointers (Deref to inner type)
+    'Rc', 'Arc', 'Weak', // pointer types
+    'MutexGuard', 'RwLockReadGuard', 'RwLockWriteGuard', // guard types
+    'Ref', 'RefMut', // RefCell guards
+    'Cow', // copy-on-write
+    // Containers (List, Array, Vec, Set, etc.) are intentionally excluded —
+    // methods are called on the container, not the element type.
+    // Non-wrapper generics return the base type (e.g., List) via the else branch.
+]);
+/**
+ * Extracts the first type argument from a comma-separated generic argument string,
+ * respecting nested angle brackets. For example:
+ *   "Result<User, Error>"  → "Result<User, Error>"  (no top-level comma)
+ *   "User, Error"          → "User"
+ *   "Map<K, V>, string"    → "Map<K, V>"
+ */
+function extractFirstGenericArg(args) {
+    let depth = 0;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '<')
+            depth++;
+        else if (args[i] === '>')
+            depth--;
+        else if (args[i] === ',' && depth === 0)
+            return args.slice(0, i).trim();
+    }
+    return args.trim();
+}
+/**
+ * Extract the first non-lifetime type argument from a generic argument string.
+ * Skips Rust lifetime parameters (e.g., `'a`, `'_`) to find the actual type.
+ *   "'_, User"       → "User"
+ *   "'a, User"       → "User"
+ *   "User, Error"    → "User"  (no lifetime — delegates to extractFirstGenericArg)
+ */
+function extractFirstTypeArg(args) {
+    let remaining = args;
+    while (remaining) {
+        const first = extractFirstGenericArg(remaining);
+        if (!first.startsWith("'"))
+            return first;
+        // Skip past this lifetime arg + the comma separator
+        const commaIdx = remaining.indexOf(',', first.length);
+        if (commaIdx < 0)
+            return first; // only lifetimes — fall through
+        remaining = remaining.slice(commaIdx + 1).trim();
+    }
+    return args.trim();
+}
+const MAX_RETURN_TYPE_INPUT_LENGTH = 2048;
+const MAX_RETURN_TYPE_LENGTH = 512;
+export const extractReturnTypeName = (raw, depth = 0) => {
+    if (depth > 10)
+        return undefined;
+    if (raw.length > MAX_RETURN_TYPE_INPUT_LENGTH)
+        return undefined;
+    let text = raw.trim();
+    if (!text)
+        return undefined;
+    // Strip pointer/reference prefixes: *User, &User, &mut User
+    text = text.replace(/^[&*]+\s*(mut\s+)?/, '');
+    // Strip nullable suffix: User?
+    text = text.replace(/\?$/, '');
+    // Handle union types: "User | null" → "User"
+    if (text.includes('|')) {
+        const parts = text.split('|').map(p => p.trim()).filter(p => p !== 'null' && p !== 'undefined' && p !== 'void' && p !== 'None' && p !== 'nil');
+        if (parts.length === 1)
+            text = parts[0];
+        else
+            return undefined; // genuine union — too complex
+    }
+    // Handle generics: Promise<User> → unwrap if wrapper, else take base
+    const genericMatch = text.match(/^(\w+)\s*<(.+)>$/);
+    if (genericMatch) {
+        const [, base, args] = genericMatch;
+        if (WRAPPER_GENERICS.has(base)) {
+            // Take the first non-lifetime type argument, using bracket-balanced splitting
+            // so that nested generics like Result<User, Error> are not split at the inner
+            // comma. Lifetime parameters (Rust 'a, '_) are skipped.
+            const firstArg = extractFirstTypeArg(args);
+            return extractReturnTypeName(firstArg, depth + 1);
+        }
+        // Non-wrapper generic: return the base type (e.g., Map<K,V> → Map)
+        return PRIMITIVE_TYPES.has(base.toLowerCase()) ? undefined : base;
+    }
+    // Bare wrapper type without generic argument (e.g. Task, Promise, Option)
+    // should not produce a binding — these are meaningless without a type parameter
+    if (WRAPPER_GENERICS.has(text))
+        return undefined;
+    // Handle qualified names: models.User → User, Models::User → User, \App\Models\User → User
+    if (text.includes('::') || text.includes('.') || text.includes('\\')) {
+        text = text.split(/::|[.\\]/).pop();
+    }
+    // Final check: skip primitives
+    if (PRIMITIVE_TYPES.has(text) || PRIMITIVE_TYPES.has(text.toLowerCase()))
+        return undefined;
+    // Must start with uppercase (class/type convention) or be a valid identifier
+    if (!/^[A-Z_]\w*$/.test(text))
+        return undefined;
+    // If the final extracted type name is too long, reject it
+    if (text.length > MAX_RETURN_TYPE_LENGTH)
+        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

@@ -23,17 +23,61 @@ export type ConstructorBindingScanner = (node: SyntaxNode) => {
  *  Used for languages where return types are expressed in comments (e.g. YARD @return [Type])
  *  rather than in AST fields. Returns undefined if no return type can be determined. */
 export type ReturnTypeExtractor = (node: SyntaxNode) => string | undefined;
-/** Extracts loop variable type binding from a for-each statement.
- *  All parameters are required (aligned with PatternBindingExtractor convention)
- *  to prevent new extractors from silently ignoring declarationTypeNodes/scope. */
-export type ForLoopExtractor = (node: SyntaxNode, scopeEnv: Map<string, string>, declarationTypeNodes: ReadonlyMap<string, SyntaxNode>, scope: string) => void;
-/** Extracts a plain-identifier assignment for Tier 2 propagation.
- *  For `const b = a`, returns { lhs: 'b', rhs: 'a' } when the LHS has no resolved type.
- *  Returns undefined if the node is not a plain identifier assignment. */
-export type PendingAssignmentExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMap<string, string>) => {
+/** Narrow lookup interface for resolving a callee name → return type name.
+ *  Backed by SymbolTable.lookupFuzzyCallable; passed via ForLoopExtractorContext.
+ *  Conservative: returns undefined when the callee is ambiguous (0 or 2+ matches). */
+export interface ReturnTypeLookup {
+    /** Processed type name after stripping wrappers (e.g., 'User' from 'Promise<User>').
+     *  Use for call-result variable bindings (`const b = foo()`). */
+    lookupReturnType(callee: string): string | undefined;
+    /** Raw return type as declared in the symbol (e.g., '[]User', 'List<User>').
+     *  Use for iterable-element extraction (`for v := range foo()`). */
+    lookupRawReturnType(callee: string): string | undefined;
+}
+/** Context object passed to ForLoopExtractor.
+ *  Groups the four parameters that were previously positional. */
+export interface ForLoopExtractorContext {
+    /** Mutable type-env for the current scope — extractor writes bindings here */
+    scopeEnv: Map<string, string>;
+    /** Maps `scope\0varName` to the declaration's type annotation AST node */
+    declarationTypeNodes: ReadonlyMap<string, SyntaxNode>;
+    /** Current scope key, e.g. `"process@42"` */
+    scope: string;
+    /** Resolves a callee name to its declared return type (undefined = unknown/ambiguous) */
+    returnTypeLookup: ReturnTypeLookup;
+}
+/** 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)
+ *  - `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;
     rhs: string;
-} | undefined;
+} | {
+    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`), 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.
  *  Returns { varName, typeName } for patterns that introduce NEW variables.
  *  Examples: `if let Some(user) = opt` (Rust), `x instanceof User user` (Java).
@@ -82,9 +126,10 @@ export interface LanguageTypeConfig {
     extractReturnType?: ReturnTypeExtractor;
     /** Extract loop variable → type binding from a for-each AST node. */
     extractForLoopBinding?: ForLoopExtractor;
-    /** Extract plain-identifier assignment (e.g. `const b = a`) for Tier 2 chain propagation.
-     *  Called on declaration/assignment nodes; returns {lhs, rhs} when the RHS is a bare identifier
-     *  and the LHS has no resolved type yet. Language-specific because AST shapes differ widely. */
+    /** Extract pending assignment for Tier 2 propagation.
+     *  Called on declaration/assignment nodes; returns a PendingAssignment when the RHS
+     *  is a bare identifier (copy) or call expression (callResult) and the LHS has no
+     *  resolved type yet. Language-specific because AST shapes differ widely. */
     extractPendingAssignment?: PendingAssignmentExtractor;
     /** Extract a typed variable binding from a pattern-matching construct.
      *  Called on every AST node; returns { varName, typeName } when the node introduces a new

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

@@ -345,7 +345,7 @@ const findTsIterableElementType = (iterableName, startNode, pos = 'last') => {
  *   3. AST walk — walks up to the enclosing function's parameters to read User[] annotations directly
  * Only handles `for...of`; `for...in` produces string keys, not element types.
  */
-const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }) => {
     if (node.type !== 'for_in_statement')
         return;
     // Confirm this is `for...of`, not `for...in`, by scanning unnamed children for the keyword text.
@@ -359,10 +359,11 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     }
     if (!isForOf)
         return;
-    // The iterable is the `right` field — may be identifier or call_expression.
+    // The iterable is the `right` field — may be identifier, member_expression, or call_expression.
     const rightNode = node.childForFieldName('right');
     let iterableName;
     let methodName;
+    let callExprElementType;
     if (rightNode?.type === 'identifier') {
         iterableName = rightNode.text;
     }
@@ -374,6 +375,7 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     else if (rightNode?.type === 'call_expression') {
         // entries.values() → call_expression > function: member_expression > object + property
         // this.repos.values() → nested member_expression: extract property from inner member
+        // getUsers() → call_expression > function: identifier (Phase 7.3 — return-type path)
         const fn = rightNode.childForFieldName('function');
         if (fn?.type === 'member_expression') {
             const obj = fn.childForFieldName('object');
@@ -390,13 +392,25 @@ const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
             if (prop?.type === 'property_identifier')
                 methodName = prop.text;
         }
+        else if (fn?.type === 'identifier') {
+            // Direct function call: for (const user of getUsers())
+            const rawReturn = returnTypeLookup.lookupRawReturnType(fn.text);
+            if (rawReturn)
+                callExprElementType = extractElementTypeFromString(rawReturn);
+        }
     }
-    if (!iterableName)
+    if (!iterableName && !callExprElementType)
         return;
-    // Look up the container's base type name for descriptor-aware resolution
-    const containerTypeName = scopeEnv.get(iterableName);
-    const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
-    const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractTsElementTypeFromAnnotation, findTsIterableElementType, typeArgPos);
+    let elementType;
+    if (callExprElementType) {
+        elementType = callExprElementType;
+    }
+    else {
+        // Look up the container's base type name for descriptor-aware resolution
+        const containerTypeName = scopeEnv.get(iterableName);
+        const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
+        elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractTsElementTypeFromAnnotation, findTsIterableElementType, typeArgPos);
+    }
     if (!elementType)
         return;
     // The loop variable is the `left` field.
@@ -444,7 +458,37 @@ const extractPendingAssignment = (node, scopeEnv) => {
         if (scopeEnv.has(lhs))
             continue;
         if (valueNode.type === 'identifier')
-            return { lhs, rhs: valueNode.text };
+            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 {};

package/dist/core/ingestion/utils.js

@@ -254,7 +254,7 @@ export const CLASS_CONTAINER_TYPES = new Set([
     'class_declaration', 'abstract_class_declaration',
     'interface_declaration', 'struct_declaration', 'record_declaration',
     'class_specifier', 'struct_specifier',
-    'impl_item', 'trait_item',
+    'impl_item', 'trait_item', 'struct_item', 'enum_item',
     'class_definition',
     'trait_declaration',
     'protocol_declaration',
@@ -275,6 +275,8 @@ export const CONTAINER_TYPE_TO_LABEL = {
     class_definition: 'Class',
     impl_item: 'Impl',
     trait_item: 'Trait',
+    struct_item: 'Struct',
+    enum_item: 'Enum',
     trait_declaration: 'Trait',
     record_declaration: 'Record',
     protocol_declaration: 'Interface',
@@ -306,6 +308,21 @@ export const findEnclosingClassId = (node, filePath) => {
                 }
             }
         }
+        // Go: type_declaration wrapping a struct_type (type User struct { ... })
+        // field_declaration → field_declaration_list → struct_type → type_spec → type_declaration
+        if (current.type === 'type_declaration') {
+            const typeSpec = current.children?.find((c) => c.type === 'type_spec');
+            if (typeSpec) {
+                const typeBody = typeSpec.childForFieldName?.('type');
+                if (typeBody?.type === 'struct_type' || typeBody?.type === 'interface_type') {
+                    const nameNode = typeSpec.childForFieldName?.('name');
+                    if (nameNode) {
+                        const label = typeBody.type === 'struct_type' ? 'Struct' : 'Interface';
+                        return generateId(label, `${filePath}:${nameNode.text}`);
+                    }
+                }
+            }
+        }
         if (CLASS_CONTAINER_TYPES.has(current.type)) {
             // Rust impl_item: for `impl Trait for Struct {}`, pick the type after `for`
             if (current.type === 'impl_item') {
@@ -1129,3 +1146,145 @@ export function extractCallChain(receiverCallNode) {
     }
     return chain.length > 0 ? { chain, baseReceiverName: undefined } : undefined;
 }
+/** Node types representing member/field access across languages. */
+const FIELD_ACCESS_NODE_TYPES = new Set([
+    'member_expression', // TS/JS
+    'member_access_expression', // C#
+    'selector_expression', // Go
+    'field_expression', // Rust/C++
+    'field_access', // Java
+    'attribute', // Python
+    'navigation_expression', // Kotlin/Swift
+    'member_binding_expression', // C# null-conditional (user?.Address)
+]);
+/**
+ * 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 function extractMixedChain(receiverNode) {
+    const chain = [];
+    let current = receiverNode;
+    while (chain.length < MAX_CHAIN_DEPTH) {
+        if (CALL_EXPRESSION_TYPES.has(current.type)) {
+            // ── Call expression: extract method name + inner receiver ────────────
+            const funcNode = current.childForFieldName?.('function')
+                ?? current.childForFieldName?.('name')
+                ?? current.childForFieldName?.('method');
+            let methodName;
+            let innerReceiver = null;
+            if (funcNode) {
+                methodName = funcNode.lastNamedChild?.text ?? funcNode.text;
+            }
+            // Kotlin/Swift: call_expression → navigation_expression
+            if (!funcNode && current.type === 'call_expression') {
+                const callee = current.firstNamedChild;
+                if (callee?.type === 'navigation_expression') {
+                    const suffix = callee.lastNamedChild;
+                    if (suffix?.type === 'navigation_suffix') {
+                        methodName = suffix.lastNamedChild?.text;
+                        for (let i = 0; i < callee.namedChildCount; i++) {
+                            const child = callee.namedChild(i);
+                            if (child && child.type !== 'navigation_suffix') {
+                                innerReceiver = child;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!methodName)
+                break;
+            chain.unshift({ kind: 'call', name: methodName });
+            if (!innerReceiver && funcNode) {
+                innerReceiver = funcNode.childForFieldName?.('object')
+                    ?? funcNode.childForFieldName?.('value')
+                    ?? funcNode.childForFieldName?.('operand')
+                    ?? funcNode.childForFieldName?.('argument') // C/C++ field_expression
+                    ?? funcNode.childForFieldName?.('expression')
+                    ?? null;
+            }
+            if (!innerReceiver && current.type === 'method_invocation') {
+                innerReceiver = current.childForFieldName?.('object') ?? null;
+            }
+            if (!innerReceiver && (current.type === 'member_call_expression' || current.type === 'nullsafe_member_call_expression')) {
+                innerReceiver = current.childForFieldName?.('object') ?? null;
+            }
+            if (!innerReceiver && current.type === 'call') {
+                innerReceiver = current.childForFieldName?.('receiver') ?? null;
+            }
+            if (!innerReceiver)
+                break;
+            if (CALL_EXPRESSION_TYPES.has(innerReceiver.type) || FIELD_ACCESS_NODE_TYPES.has(innerReceiver.type)) {
+                current = innerReceiver;
+            }
+            else {
+                return { chain, baseReceiverName: innerReceiver.text || undefined };
+            }
+        }
+        else if (FIELD_ACCESS_NODE_TYPES.has(current.type)) {
+            // ── Field/member access: extract property name + inner object ─────────
+            let propertyName;
+            let innerObject = null;
+            if (current.type === 'navigation_expression') {
+                for (const child of current.children ?? []) {
+                    if (child.type === 'navigation_suffix') {
+                        for (const sc of child.children ?? []) {
+                            if (sc.isNamed && sc.type !== '.') {
+                                propertyName = sc.text;
+                                break;
+                            }
+                        }
+                    }
+                    else if (child.isNamed && !innerObject) {
+                        innerObject = child;
+                    }
+                }
+            }
+            else if (current.type === 'attribute') {
+                innerObject = current.childForFieldName?.('object') ?? null;
+                propertyName = current.childForFieldName?.('attribute')?.text;
+            }
+            else {
+                innerObject = current.childForFieldName?.('object')
+                    ?? current.childForFieldName?.('value')
+                    ?? current.childForFieldName?.('operand')
+                    ?? current.childForFieldName?.('argument') // C/C++ field_expression
+                    ?? current.childForFieldName?.('expression')
+                    ?? null;
+                propertyName = (current.childForFieldName?.('property')
+                    ?? current.childForFieldName?.('field')
+                    ?? current.childForFieldName?.('name'))?.text;
+            }
+            if (!propertyName)
+                break;
+            chain.unshift({ kind: 'field', name: propertyName });
+            if (!innerObject)
+                break;
+            if (CALL_EXPRESSION_TYPES.has(innerObject.type) || FIELD_ACCESS_NODE_TYPES.has(innerObject.type)) {
+                current = innerObject;
+            }
+            else {
+                return { chain, baseReceiverName: innerObject.text || undefined };
+            }
+        }
+        else {
+            // Simple identifier — this is the base receiver
+            return chain.length > 0
+                ? { chain, baseReceiverName: current.text || undefined }
+                : undefined;
+        }
+    }
+    return chain.length > 0 ? { chain, baseReceiverName: undefined } : undefined;
+}