gitnexus 1.4.6 → 1.4.7

package/dist/core/ingestion/tree-sitter-queries.js

@@ -60,6 +60,19 @@ export const TYPESCRIPT_QUERIES = `
 (new_expression
   constructor: (identifier) @call.name) @call
 
+; Class properties — public_field_definition covers most TS class fields
+(public_field_definition
+  name: (property_identifier) @name) @definition.property
+
+; Private class fields: #address: Address
+(public_field_definition
+  name: (private_property_identifier) @name) @definition.property
+
+; Constructor parameter properties: constructor(public address: Address)
+(required_parameter
+  (accessibility_modifier)
+  pattern: (identifier) @name) @definition.property
+
 ; Heritage queries - class extends
 (class_declaration
   name: (type_identifier) @heritage.class
@@ -73,6 +86,20 @@ export const TYPESCRIPT_QUERIES = `
   (class_heritage
     (implements_clause
       (type_identifier) @heritage.implements))) @heritage.impl
+
+; Write access: obj.field = value
+(assignment_expression
+  left: (member_expression
+    object: (_) @assignment.receiver
+    property: (property_identifier) @assignment.property)
+  right: (_)) @assignment
+
+; Write access: obj.field += value (compound assignment)
+(augmented_assignment_expression
+  left: (member_expression
+    object: (_) @assignment.receiver
+    property: (property_identifier) @assignment.property)
+  right: (_)) @assignment
 `;
 // JavaScript queries - works with tree-sitter-javascript
 export const JAVASCRIPT_QUERIES = `
@@ -125,12 +152,30 @@ export const JAVASCRIPT_QUERIES = `
 (new_expression
   constructor: (identifier) @call.name) @call
 
+; Class fields — field_definition captures JS class fields (class User { address = ... })
+(field_definition
+  property: (property_identifier) @name) @definition.property
+
 ; Heritage queries - class extends (JavaScript uses different AST than TypeScript)
 ; In tree-sitter-javascript, class_heritage directly contains the parent identifier
 (class_declaration
   name: (identifier) @heritage.class
   (class_heritage
     (identifier) @heritage.extends)) @heritage
+
+; Write access: obj.field = value
+(assignment_expression
+  left: (member_expression
+    object: (_) @assignment.receiver
+    property: (property_identifier) @assignment.property)
+  right: (_)) @assignment
+
+; Write access: obj.field += value (compound assignment)
+(augmented_assignment_expression
+  left: (member_expression
+    object: (_) @assignment.receiver
+    property: (property_identifier) @assignment.property)
+  right: (_)) @assignment
 `;
 // Python queries - works with tree-sitter-python
 export const PYTHON_QUERIES = `
@@ -156,11 +201,33 @@ export const PYTHON_QUERIES = `
   function: (attribute
     attribute: (identifier) @call.name)) @call
 
+; Class attribute type annotations — PEP 526: address: Address or address: Address = Address()
+; Both bare annotations (address: Address) and annotated assignments (name: str = "test")
+; are parsed as (assignment left: ... type: ...) in tree-sitter-python.
+(expression_statement
+  (assignment
+    left: (identifier) @name
+    type: (type)) @definition.property)
+
 ; Heritage queries - Python class inheritance
 (class_definition
   name: (identifier) @heritage.class
   superclasses: (argument_list
     (identifier) @heritage.extends)) @heritage
+
+; Write access: obj.field = value
+(assignment
+  left: (attribute
+    object: (_) @assignment.receiver
+    attribute: (identifier) @assignment.property)
+  right: (_)) @assignment
+
+; Write access: obj.field += value (compound assignment)
+(augmented_assignment
+  left: (attribute
+    object: (_) @assignment.receiver
+    attribute: (identifier) @assignment.property)
+  right: (_)) @assignment
 `;
 // Java queries - works with tree-sitter-java
 export const JAVA_QUERIES = `
@@ -174,6 +241,11 @@ export const JAVA_QUERIES = `
 (method_declaration name: (identifier) @name) @definition.method
 (constructor_declaration name: (identifier) @name) @definition.constructor
 
+; Fields — typed field declarations inside class bodies
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @name)) @definition.property
+
 ; Imports - capture any import declaration child as source
 (import_declaration (_) @import.source) @import
 
@@ -191,6 +263,13 @@ export const JAVA_QUERIES = `
 ; Heritage - implements interfaces
 (class_declaration name: (identifier) @heritage.class
   (super_interfaces (type_list (type_identifier) @heritage.implements))) @heritage.impl
+
+; Write access: obj.field = value
+(assignment_expression
+  left: (field_access
+    object: (_) @assignment.receiver
+    field: (identifier) @assignment.property)
+  right: (_)) @assignment
 `;
 // C queries - works with tree-sitter-c
 export const C_QUERIES = `
@@ -236,6 +315,11 @@ export const GO_QUERIES = `
 (import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import
 (import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import
 
+; Struct fields — named field declarations inside struct types
+(field_declaration_list
+  (field_declaration
+    name: (field_identifier) @name) @definition.property)
+
 ; Struct embedding (anonymous fields = inheritance)
 (type_declaration
   (type_spec
@@ -251,6 +335,14 @@ export const GO_QUERIES = `
 
 ; Struct literal construction: User{Name: "Alice"}
 (composite_literal type: (type_identifier) @call.name) @call
+
+; Write access: obj.field = value
+(assignment_statement
+  left: (expression_list
+    (selector_expression
+      operand: (_) @assignment.receiver
+      field: (field_identifier) @assignment.property))
+  right: (_)) @assignment
 `;
 // C++ queries - works with tree-sitter-cpp
 export const CPP_QUERIES = `
@@ -291,6 +383,21 @@ export const CPP_QUERIES = `
 (declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function
 (declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function
 
+; Class/struct data member fields (Address address; int count;)
+; Uses field_identifier to exclude method declarations (which use function_declarator)
+(field_declaration
+  declarator: (field_identifier) @name) @definition.property
+
+; Pointer member fields (Address* address;)
+(field_declaration
+  declarator: (pointer_declarator
+    declarator: (field_identifier) @name)) @definition.property
+
+; Reference member fields (Address& address;)
+(field_declaration
+  declarator: (reference_declarator
+    (field_identifier) @name)) @definition.property
+
 ; Inline class method declarations (inside class body, no body: void Foo();)
 (field_declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.method
 
@@ -321,6 +428,14 @@ export const CPP_QUERIES = `
   (base_class_clause (type_identifier) @heritage.extends)) @heritage
 (class_specifier name: (type_identifier) @heritage.class
   (base_class_clause (access_specifier) (type_identifier) @heritage.extends)) @heritage
+
+; Write access: obj.field = value
+(assignment_expression
+  left: (field_expression
+    argument: (_) @assignment.receiver
+    field: (field_identifier) @assignment.property)
+  right: (_)) @assignment
+
 `;
 // C# queries - works with tree-sitter-c-sharp
 export const CSHARP_QUERIES = `
@@ -374,6 +489,13 @@ export const CSHARP_QUERIES = `
   (base_list (identifier) @heritage.extends)) @heritage
 (class_declaration name: (identifier) @heritage.class
   (base_list (generic_name (identifier) @heritage.extends))) @heritage
+
+; Write access: obj.field = value
+(assignment_expression
+  left: (member_access_expression
+    expression: (_) @assignment.receiver
+    name: (identifier) @assignment.property)
+  right: (_)) @assignment
 `;
 // Rust queries - works with tree-sitter-rust
 export const RUST_QUERIES = `
@@ -404,11 +526,30 @@ export const RUST_QUERIES = `
 ; Struct literal construction: User { name: value }
 (struct_expression name: (type_identifier) @call.name) @call
 
+; Struct fields — named field declarations inside struct bodies
+(field_declaration_list
+  (field_declaration
+    name: (field_identifier) @name) @definition.property)
+
 ; Heritage (trait implementation) — all combinations of concrete/generic trait × concrete/generic type
 (impl_item trait: (type_identifier) @heritage.trait type: (type_identifier) @heritage.class) @heritage
 (impl_item trait: (generic_type type: (type_identifier) @heritage.trait) type: (type_identifier) @heritage.class) @heritage
 (impl_item trait: (type_identifier) @heritage.trait type: (generic_type type: (type_identifier) @heritage.class)) @heritage
 (impl_item trait: (generic_type type: (type_identifier) @heritage.trait) type: (generic_type type: (type_identifier) @heritage.class)) @heritage
+
+; Write access: obj.field = value
+(assignment_expression
+  left: (field_expression
+    value: (_) @assignment.receiver
+    field: (field_identifier) @assignment.property)
+  right: (_)) @assignment
+
+; Write access: obj.field += value (compound assignment)
+(compound_assignment_expr
+  left: (field_expression
+    value: (_) @assignment.receiver
+    field: (field_identifier) @assignment.property)
+  right: (_)) @assignment
 `;
 // PHP queries - works with tree-sitter-php (php_only grammar)
 export const PHP_QUERIES = `
@@ -446,6 +587,13 @@ export const PHP_QUERIES = `
     (variable_name
       (name) @name))) @definition.property
 
+; Constructor property promotion (PHP 8.0+: public Address $address in __construct)
+(method_declaration
+  parameters: (formal_parameters
+    (property_promotion_parameter
+      name: (variable_name
+        (name) @name)))) @definition.property
+
 ; ── Imports: use statements ──────────────────────────────────────────────────
 ; Simple: use App\\Models\\User;
 (namespace_use_declaration
@@ -490,6 +638,20 @@ export const PHP_QUERIES = `
   body: (declaration_list
     (use_declaration
       [(name) (qualified_name)] @heritage.trait))) @heritage
+
+; Write access: $obj->field = value
+(assignment_expression
+  left: (member_access_expression
+    object: (_) @assignment.receiver
+    name: (name) @assignment.property)
+  right: (_)) @assignment
+
+; Write access: ClassName::$field = value (static property)
+(assignment_expression
+  left: (scoped_property_access_expression
+    scope: (_) @assignment.receiver
+    name: (variable_name (name) @assignment.property))
+  right: (_)) @assignment
 `;
 // Ruby queries - works with tree-sitter-ruby
 // NOTE: Ruby uses `call` for require, include, extend, prepend, attr_* etc.
@@ -534,6 +696,20 @@ export const RUBY_QUERIES = `
   name: (constant) @heritage.class
   superclass: (superclass
     (constant) @heritage.extends)) @heritage
+
+; Write access: obj.field = value (Ruby setter — syntactically a method call to field=)
+(assignment
+  left: (call
+    receiver: (_) @assignment.receiver
+    method: (identifier) @assignment.property)
+  right: (_)) @assignment
+
+; Write access: obj.field += value (compound assignment — operator_assignment node, not assignment)
+(operator_assignment
+  left: (call
+    receiver: (_) @assignment.receiver
+    method: (identifier) @assignment.property)
+  right: (_)) @assignment
 `;
 // Kotlin queries - works with tree-sitter-kotlin (fwcd/tree-sitter-kotlin)
 // Based on official tags.scm; functions use simple_identifier, classes use type_identifier
@@ -569,6 +745,12 @@ export const KOTLIN_QUERIES = `
   (variable_declaration
     (simple_identifier) @name)) @definition.property
 
+; Primary constructor val/var parameters (data class, value class, regular class)
+; binding_pattern_kind contains "val" or "var" — without it, the param is not a property
+(class_parameter
+  (binding_pattern_kind)
+  (simple_identifier) @name) @definition.property
+
 ; ── Enum entries ─────────────────────────────────────────────────────────
 (enum_entry
   (simple_identifier) @name) @definition.enum
@@ -613,6 +795,15 @@ export const KOTLIN_QUERIES = `
   (delegation_specifier
     (constructor_invocation
       (user_type (type_identifier) @heritage.extends)))) @heritage
+
+; Write access: obj.field = value
+(assignment
+  (directly_assignable_expression
+    (_) @assignment.receiver
+    (navigation_suffix
+      (simple_identifier) @assignment.property))
+  (_)) @assignment
+
 `;
 // Swift queries - works with tree-sitter-swift
 export const SWIFT_QUERIES = `
@@ -670,6 +861,15 @@ export const SWIFT_QUERIES = `
 ; Extensions wrap the name in user_type unlike class/struct/enum declarations
 (class_declaration "extension" name: (user_type (type_identifier) @heritage.class)
   (inheritance_specifier inherits_from: (user_type (type_identifier) @heritage.extends))) @heritage
+
+; Write access: obj.field = value
+(assignment
+  (directly_assignable_expression
+    (_) @assignment.receiver
+    (navigation_suffix
+      (simple_identifier) @assignment.property))
+  (_)) @assignment
+
 `;
 export const LANGUAGE_QUERIES = {
     [SupportedLanguages.TypeScript]: TYPESCRIPT_QUERIES,

package/dist/core/ingestion/type-env.js

@@ -296,6 +296,47 @@ const SKIP_SUBTREE_TYPES = new Set([
     // Regex
     'regex', 'regex_pattern',
 ]);
+const CLASS_LIKE_TYPES = new Set(['Class', 'Struct', 'Interface']);
+/** Resolve a field's declared type given a receiver variable and field name.
+ *  Uses SymbolTable to find the class nodeId for the receiver's type, then
+ *  looks up the field via the eagerly-populated fieldByOwner index. */
+const resolveFieldType = (receiver, field, scopeEnv, symbolTable) => {
+    if (!symbolTable)
+        return undefined;
+    const receiverType = scopeEnv.get(receiver);
+    if (!receiverType)
+        return undefined;
+    const classDefs = symbolTable.lookupFuzzy(receiverType)
+        .filter(d => CLASS_LIKE_TYPES.has(d.type));
+    if (classDefs.length !== 1)
+        return undefined;
+    const fieldDef = symbolTable.lookupFieldByOwner(classDefs[0].nodeId, field);
+    if (!fieldDef?.declaredType)
+        return undefined;
+    return extractReturnTypeName(fieldDef.declaredType);
+};
+/** Resolve a method's return type given a receiver variable and method name.
+ *  Uses SymbolTable to find class nodeIds for the receiver's type, then
+ *  looks up the method via lookupFuzzyCallable filtered by ownerId. */
+const resolveMethodReturnType = (receiver, method, scopeEnv, symbolTable) => {
+    if (!symbolTable)
+        return undefined;
+    const receiverType = scopeEnv.get(receiver);
+    if (!receiverType)
+        return undefined;
+    const classDefs = symbolTable.lookupFuzzy(receiverType)
+        .filter(d => CLASS_LIKE_TYPES.has(d.type));
+    if (classDefs.length === 0)
+        return undefined;
+    const classNodeIds = new Set(classDefs.map(d => d.nodeId));
+    const methods = symbolTable.lookupFuzzyCallable(method)
+        .filter(d => d.ownerId && classNodeIds.has(d.ownerId));
+    if (methods.length !== 1)
+        return undefined;
+    if (!methods[0].returnType)
+        return undefined;
+    return extractReturnTypeName(methods[0].returnType);
+};
 export const buildTypeEnv = (tree, language, symbolTable) => {
     const env = new Map();
     const patternOverrides = new Map();
@@ -336,12 +377,10 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
     TYPED_PARAMETER_TYPES.forEach(t => interestingNodeTypes.add(t));
     config.declarationNodeTypes.forEach(t => interestingNodeTypes.add(t));
     config.forLoopNodeTypes?.forEach(t => interestingNodeTypes.add(t));
-    // Tier 2: copy-propagation (`const b = a`) and call-result propagation (`const b = foo()`)
-    const pendingCopies = [];
-    // NOTE: Infrastructure-ready — no language extractor currently returns { kind: 'callResult' }
-    // from extractPendingAssignment. When one does, this array will bind variables to their
-    // function return types at TypeEnv build time. See PendingAssignment in types.ts.
-    const pendingCallResults = [];
+    // Tier 2: unified fixpoint propagation — collects copy, callResult, fieldAccess, and
+    // methodCallResult items during walk(), then iterates until no new bindings are produced.
+    // Handles arbitrary-depth mixed chains: callResult → fieldAccess → methodCallResult → copy.
+    const pendingItems = [];
     // Maps `scope\0varName` → the type annotation AST node from the original declaration.
     // Allows pattern extractors to navigate back to the declaration's generic type arguments
     // (e.g., to extract T from Result<T, E> for `if let Ok(x) = res`).
@@ -371,7 +410,9 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
             let typeNode = node.childForFieldName('type');
             if (typeNode) {
                 const nameNode = node.childForFieldName('name')
-                    ?? node.childForFieldName('pattern');
+                    ?? node.childForFieldName('pattern')
+                    // Python typed_parameter: name is a positional child (identifier), not a named field
+                    ?? (node.firstNamedChild?.type === 'identifier' ? node.firstNamedChild : null);
                 if (nameNode) {
                     const varName = extractVarName(nameNode);
                     if (varName && !declarationTypeNodes.has(`${scope}\0${varName}`)) {
@@ -549,12 +590,7 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
             if (scopeEnv) {
                 const pending = config.extractPendingAssignment(node, scopeEnv);
                 if (pending) {
-                    if (pending.kind === 'copy') {
-                        pendingCopies.push({ scope, lhs: pending.lhs, rhs: pending.rhs });
-                    }
-                    else {
-                        pendingCallResults.push({ scope, lhs: pending.lhs, callee: pending.callee });
-                    }
+                    pendingItems.push({ scope, ...pending });
                 }
             }
         }
@@ -577,31 +613,51 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
         }
     };
     walk(tree.rootNode, FILE_SCOPE);
-    // Tier 2a: copy-propagation — `const b = a` where `a` has a known type from Tier 0/1.
-    // Multi-hop chains resolve when forward-declared (a→b→c in source order);
-    // reverse-order assignments are depth-1 only. No fixpoint iteration —
-    // this covers 95%+ of real-world patterns.
-    for (const { scope, lhs, rhs } of pendingCopies) {
-        const scopeEnv = env.get(scope);
-        if (!scopeEnv || scopeEnv.has(lhs))
-            continue;
-        const rhsType = scopeEnv.get(rhs) ?? env.get(FILE_SCOPE)?.get(rhs);
-        if (rhsType)
-            scopeEnv.set(lhs, rhsType);
-    }
-    // Tier 2b: call-result propagation — `const b = foo()` where `foo` has a declared return type.
-    // Uses ReturnTypeLookup which is backed by SymbolTable.lookupFuzzyCallable.
-    // Conservative: only binds when exactly one callable matches (avoids overload ambiguity).
-    // NOTE: Currently dormant — no extractPendingAssignment implementation emits 'callResult' yet.
-    // The loop is structurally complete and will activate when any language extractor starts
-    // returning { kind: 'callResult', lhs, callee } from extractPendingAssignment.
-    for (const { scope, lhs, callee } of pendingCallResults) {
-        const scopeEnv = env.get(scope);
-        if (!scopeEnv || scopeEnv.has(lhs))
-            continue;
-        const typeName = returnTypeLookup.lookupReturnType(callee);
-        if (typeName)
-            scopeEnv.set(lhs, typeName);
+    // Unified fixpoint propagation: iterate over ALL pending items (copy, callResult,
+    // fieldAccess, methodCallResult) until no new bindings are produced.
+    // Handles arbitrary-depth mixed chains:
+    //   const user = getUser();      // callResult → User
+    //   const addr = user.address;   // fieldAccess → Address (depends on user)
+    //   const city = addr.getCity(); // methodCallResult → City (depends on addr)
+    //   const alias = city;          // copy → City (depends on city)
+    // Data flow: SymbolTable (immutable) + scopeEnv → resolve → scopeEnv.
+    // Termination: finite entries, each bound at most once (first-writer-wins), max 10 iterations.
+    const MAX_FIXPOINT_ITERATIONS = 10;
+    const resolved = new Set();
+    for (let iter = 0; iter < MAX_FIXPOINT_ITERATIONS; iter++) {
+        let changed = false;
+        for (let i = 0; i < pendingItems.length; i++) {
+            if (resolved.has(i))
+                continue;
+            const item = pendingItems[i];
+            const scopeEnv = env.get(item.scope);
+            if (!scopeEnv || scopeEnv.has(item.lhs)) {
+                resolved.add(i);
+                continue;
+            }
+            let typeName;
+            switch (item.kind) {
+                case 'callResult':
+                    typeName = returnTypeLookup.lookupReturnType(item.callee);
+                    break;
+                case 'copy':
+                    typeName = scopeEnv.get(item.rhs) ?? env.get(FILE_SCOPE)?.get(item.rhs);
+                    break;
+                case 'fieldAccess':
+                    typeName = resolveFieldType(item.receiver, item.field, scopeEnv, symbolTable);
+                    break;
+                case 'methodCallResult':
+                    typeName = resolveMethodReturnType(item.receiver, item.method, scopeEnv, symbolTable);
+                    break;
+            }
+            if (typeName) {
+                scopeEnv.set(item.lhs, typeName);
+                resolved.add(i);
+                changed = true;
+            }
+        }
+        if (!changed)
+            break;
     }
     return {
         lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides),

package/dist/core/ingestion/type-extractors/c-cpp.js

@@ -186,7 +186,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
     if (!declarator || declarator.type !== 'init_declarator')
         return undefined;
     const value = declarator.childForFieldName('value');
-    if (!value || value.type !== 'identifier')
+    if (!value)
         return undefined;
     const nameNode = declarator.childForFieldName('declarator');
     if (!nameNode)
@@ -198,7 +198,32 @@ const extractPendingAssignment = (node, scopeEnv) => {
     const lhs = extractVarName(finalName);
     if (!lhs || scopeEnv.has(lhs))
         return undefined;
-    return { kind: 'copy', lhs, rhs: value.text };
+    if (value.type === 'identifier')
+        return { kind: 'copy', lhs, rhs: value.text };
+    // field_expression RHS → fieldAccess (a.field)
+    if (value.type === 'field_expression') {
+        const obj = value.firstNamedChild;
+        const field = value.lastNamedChild;
+        if (obj?.type === 'identifier' && field?.type === 'field_identifier') {
+            return { kind: 'fieldAccess', lhs, receiver: obj.text, field: field.text };
+        }
+    }
+    // call_expression RHS
+    if (value.type === 'call_expression') {
+        const funcNode = value.childForFieldName('function');
+        if (funcNode?.type === 'identifier') {
+            return { kind: 'callResult', lhs, callee: funcNode.text };
+        }
+        // method call with receiver: call_expression → function: field_expression
+        if (funcNode?.type === 'field_expression') {
+            const obj = funcNode.firstNamedChild;
+            const field = funcNode.lastNamedChild;
+            if (obj?.type === 'identifier' && field?.type === 'field_identifier') {
+                return { kind: 'methodCallResult', lhs, receiver: obj.text, method: field.text };
+            }
+        }
+    }
+    return undefined;
 };
 // --- For-loop Tier 1c ---
 const FOR_LOOP_NODE_TYPES = new Set(['for_range_loop']);

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

@@ -367,6 +367,46 @@ const extractPendingAssignment = (node, scopeEnv) => {
         if (valueNode && valueNode !== nameNode && (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier')) {
             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

@@ -419,6 +419,29 @@ const extractPendingAssignment = (node, scopeEnv) => {
             return undefined;
         if (rhsNode.type === 'identifier')
             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') {
@@ -452,6 +475,28 @@ const extractPendingAssignment = (node, scopeEnv) => {
             const rhsNode = exprList?.firstNamedChild;
             if (rhsNode?.type === 'identifier')
                 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;