gitnexus 1.4.5 → 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

@@ -1,6 +1,6 @@
-import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES } from './utils.js';
+import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES, isBuiltInOrNoise } from './utils.js';
 import { typeConfigs, TYPED_PARAMETER_TYPES } from './type-extractors/index.js';
-import { extractSimpleTypeName, extractVarName, stripNullable } from './type-extractors/shared.js';
+import { extractSimpleTypeName, extractVarName, stripNullable, extractReturnTypeName } from './type-extractors/shared.js';
 /** File-level scope key */
 const FILE_SCOPE = '';
 /** Fallback for languages where class names aren't in a 'name' field (e.g. Kotlin uses type_identifier). */
@@ -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();
@@ -303,13 +344,43 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
     const classNames = createClassNameLookup(localClassNames, symbolTable);
     const config = typeConfigs[language];
     const bindings = [];
+    // Build ReturnTypeLookup from optional SymbolTable.
+    // Conservative: returns undefined when callee is ambiguous (0 or 2+ matches).
+    const returnTypeLookup = {
+        lookupReturnType(callee) {
+            if (!symbolTable)
+                return undefined;
+            if (isBuiltInOrNoise(callee))
+                return undefined;
+            const callables = symbolTable.lookupFuzzyCallable(callee);
+            if (callables.length !== 1)
+                return undefined;
+            const rawReturn = callables[0].returnType;
+            if (!rawReturn)
+                return undefined;
+            return extractReturnTypeName(rawReturn);
+        },
+        lookupRawReturnType(callee) {
+            if (!symbolTable)
+                return undefined;
+            if (isBuiltInOrNoise(callee))
+                return undefined;
+            const callables = symbolTable.lookupFuzzyCallable(callee);
+            if (callables.length !== 1)
+                return undefined;
+            return callables[0].returnType;
+        }
+    };
     // Pre-compute combined set of node types that need extractTypeBinding.
     // Single Set.has() replaces 3 separate checks per node in walk().
     const interestingNodeTypes = new Set();
     TYPED_PARAMETER_TYPES.forEach(t => interestingNodeTypes.add(t));
     config.declarationNodeTypes.forEach(t => interestingNodeTypes.add(t));
     config.forLoopNodeTypes?.forEach(t => interestingNodeTypes.add(t));
-    const pendingAssignments = [];
+    // 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`).
@@ -339,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}`)) {
@@ -376,7 +449,10 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
         // For-each loop variable bindings (Java/C#/Kotlin): explicit element types in the AST.
         // Checked before declarationNodeTypes — loop variables are not declarations.
         if (config.forLoopNodeTypes?.has(node.type)) {
-            config.extractForLoopBinding?.(node, scopeEnv, declarationTypeNodes, scope);
+            if (config.extractForLoopBinding) {
+                const forLoopCtx = { scopeEnv, declarationTypeNodes, scope, returnTypeLookup };
+                config.extractForLoopBinding(node, forLoopCtx);
+            }
             return;
         }
         if (config.declarationNodeTypes.has(node.type)) {
@@ -514,7 +590,7 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
             if (scopeEnv) {
                 const pending = config.extractPendingAssignment(node, scopeEnv);
                 if (pending) {
-                    pendingAssignments.push({ scope, ...pending });
+                    pendingItems.push({ scope, ...pending });
                 }
             }
         }
@@ -537,19 +613,51 @@ export const buildTypeEnv = (tree, language, symbolTable) => {
         }
     };
     walk(tree.rootNode, FILE_SCOPE);
-    // Tier 2: single-pass assignment chain propagation in source order.
-    // Resolves `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 pendingAssignments) {
-        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);
+    // 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 { 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']);
@@ -291,7 +316,7 @@ const findCppParamElementType = (iterableName, startNode, pos = 'last') => {
 /** C++: for (auto& user : users) — extract loop variable binding.
  *  Handles explicit types (for (User& user : users)) and auto (for (auto& user : users)).
  *  For auto, resolves element type from the iterable's container type. */
-const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope }) => {
     if (node.type !== 'for_range_loop')
         return;
     const typeNode = node.childForFieldName('type');