gitnexus 1.4.0 → 1.4.5

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

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';
+import { extractSimpleTypeName, extractVarName, findChildByType, hasTypeAnnotation } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'property_declaration',
 ]);
@@ -36,8 +36,102 @@ const extractParameter = (node, env) => {
     if (varName && typeName)
         env.set(varName, typeName);
 };
+/** Swift: let user = User(name: "alice") — infer type from call when callee is a known class.
+ *  Swift initializers are syntactically identical to function calls, so we verify
+ *  against classNames (which may include cross-file SymbolTable lookups). */
+const extractInitializer = (node, env, classNames) => {
+    if (node.type !== 'property_declaration')
+        return;
+    // Skip if has type annotation — extractDeclaration handled it
+    if (node.childForFieldName('type') || findChildByType(node, 'type_annotation'))
+        return;
+    // Find pattern (variable name)
+    const pattern = node.childForFieldName('pattern') ?? findChildByType(node, 'pattern');
+    if (!pattern)
+        return;
+    const varName = extractVarName(pattern) ?? pattern.text;
+    if (!varName || env.has(varName))
+        return;
+    // Find call_expression in the value
+    const callExpr = findChildByType(node, 'call_expression');
+    if (!callExpr)
+        return;
+    const callee = callExpr.firstNamedChild;
+    if (!callee)
+        return;
+    // Direct call: User(name: "alice")
+    if (callee.type === 'simple_identifier') {
+        const calleeName = callee.text;
+        if (calleeName && classNames.has(calleeName)) {
+            env.set(varName, calleeName);
+        }
+        return;
+    }
+    // Explicit init: User.init(name: "alice") — navigation_expression with .init suffix
+    if (callee.type === 'navigation_expression') {
+        const receiver = callee.firstNamedChild;
+        const suffix = callee.lastNamedChild;
+        if (receiver?.type === 'simple_identifier' && suffix?.text === 'init') {
+            const calleeName = receiver.text;
+            if (calleeName && classNames.has(calleeName)) {
+                env.set(varName, calleeName);
+            }
+        }
+    }
+};
+/** Swift: let user = User(name: "alice") — scan property_declaration for constructor binding */
+const scanConstructorBinding = (node) => {
+    if (node.type !== 'property_declaration')
+        return undefined;
+    if (hasTypeAnnotation(node))
+        return undefined;
+    const pattern = node.childForFieldName('pattern');
+    if (!pattern)
+        return undefined;
+    const varName = pattern.text;
+    if (!varName)
+        return undefined;
+    let callExpr = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'call_expression') {
+            callExpr = child;
+            break;
+        }
+    }
+    if (!callExpr)
+        return undefined;
+    const callee = callExpr.firstNamedChild;
+    if (!callee)
+        return undefined;
+    if (callee.type === 'simple_identifier') {
+        return { varName, calleeName: callee.text };
+    }
+    if (callee.type === 'navigation_expression') {
+        const receiver = callee.firstNamedChild;
+        const suffix = callee.lastNamedChild;
+        if (receiver?.type === 'simple_identifier' && suffix?.text === 'init') {
+            return { varName, calleeName: receiver.text };
+        }
+        // General qualified call: service.getUser() → extract method name.
+        // tree-sitter-swift may wrap the identifier in navigation_suffix, so
+        // check both direct simple_identifier and navigation_suffix > simple_identifier.
+        if (suffix?.type === 'simple_identifier') {
+            return { varName, calleeName: suffix.text };
+        }
+        if (suffix?.type === 'navigation_suffix') {
+            const inner = suffix.lastNamedChild;
+            if (inner?.type === 'simple_identifier') {
+                return { varName, calleeName: inner.text };
+            }
+        }
+    }
+    return undefined;
+};
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
     extractDeclaration,
     extractParameter,
+    extractInitializer,
+    scanConstructorBinding,
 };

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

@@ -3,12 +3,93 @@ import type { SyntaxNode } from '../utils.js';
 export type TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>) => void;
 /** Extracts type bindings from a parameter node into the env map */
 export type ParameterExtractor = (node: SyntaxNode, env: Map<string, string>) => void;
+/** Minimal interface for checking whether a name is a known class/struct.
+ *  Narrower than ReadonlySet — only `.has()` is used by extractors. */
+export type ClassNameLookup = {
+    has(name: string): boolean;
+};
+/** Extracts type bindings from a constructor-call initializer, with access to known class names */
+export type InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup) => void;
+/** Scans an AST node for untyped `var = callee()` patterns for return-type inference.
+ *  Returns { varName, calleeName } if the node matches, undefined otherwise.
+ *  `receiverClassName` — optional hint for method calls on known receivers
+ *  (e.g. $this->getUser() in PHP provides the enclosing class name). */
+export type ConstructorBindingScanner = (node: SyntaxNode) => {
+    varName: string;
+    calleeName: string;
+    receiverClassName?: string;
+} | undefined;
+/** Extracts a return type string from a method/function definition node.
+ *  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>) => {
+    lhs: string;
+    rhs: string;
+} | 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).
+ *  Conservative: returns undefined when the source variable's type is unknown.
+ *
+ *  @param scopeEnv   Read-only view of already-resolved type bindings in the current scope.
+ *  @param declarationTypeNodes  Maps `scope\0varName` to the original declaration's type
+ *    annotation AST node. Allows extracting generic type arguments (e.g., T from Result<T,E>)
+ *    that are stripped during normal TypeEnv extraction.
+ *  @param scope  Current scope key (e.g. `"process@42"`) for declarationTypeNodes lookups. */
+export type PatternBindingExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMap<string, string>, declarationTypeNodes: ReadonlyMap<string, SyntaxNode>, scope: string) => {
+    varName: string;
+    typeName: string;
+} | undefined;
 /** Per-language type extraction configuration */
 export interface LanguageTypeConfig {
+    /** Allow pattern binding to overwrite existing scopeEnv entries.
+     *  WARNING: Enables function-scope type pollution. Only for languages with
+     *  smart-cast semantics (e.g., Kotlin `when/is`) where the subject variable
+     *  already exists in scopeEnv from its declaration. */
+    readonly allowPatternBindingOverwrite?: boolean;
     /** Node types that represent typed declarations for this language */
     declarationNodeTypes: ReadonlySet<string>;
+    /** AST node types for for-each/for-in statements with explicit element types. */
+    forLoopNodeTypes?: ReadonlySet<string>;
+    /** Optional allowlist of AST node types on which extractPatternBinding should run.
+     *  When present, extractPatternBinding is only invoked for nodes whose type is in this set,
+     *  short-circuiting the call for all other node types. When absent, every node is passed to
+     *  extractPatternBinding (legacy behaviour). */
+    patternBindingNodeTypes?: ReadonlySet<string>;
     /** Extract a (varName → typeName) binding from a declaration node */
     extractDeclaration: TypeBindingExtractor;
     /** Extract a (varName → typeName) binding from a parameter node */
     extractParameter: ParameterExtractor;
+    /** Extract a (varName → typeName) binding from a constructor-call initializer.
+     *  Called as fallback when extractDeclaration produces no binding for a declaration node.
+     *  Only for languages with syntactic constructor markers (new, composite_literal, ::new).
+     *  Receives classNames — the set of class/struct names visible in the current file's AST. */
+    extractInitializer?: InitializerExtractor;
+    /** Scan for untyped `var = callee()` assignments for return-type inference.
+     *  Called on every AST node during buildTypeEnv walk; returns undefined for non-matches.
+     *  The callee binding is unverified — the caller must confirm against the SymbolTable. */
+    scanConstructorBinding?: ConstructorBindingScanner;
+    /** Extract return type from comment-based annotations (e.g. YARD @return [Type]).
+     *  Called as fallback when extractMethodSignature finds no AST-based return type. */
+    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. */
+    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
+     *  typed variable via pattern matching (e.g. `if let Some(x) = opt`, `x instanceof T t`).
+     *  The extractor receives the current scope's resolved bindings (read-only) to look up the
+     *  source variable's type. Returns undefined for non-matching nodes or unknown source types. */
+    extractPatternBinding?: PatternBindingExtractor;
 }

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

@@ -1,10 +1,97 @@
-import { extractSimpleTypeName, extractVarName } from './shared.js';
+import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, unwrapAwait, extractCalleeName, extractElementTypeFromString, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'lexical_declaration',
     'variable_declaration',
+    'function_declaration', // JSDoc @param on function declarations
+    'method_definition', // JSDoc @param on class methods
+    'public_field_definition', // class field: private users: User[]
 ]);
-/** TypeScript: const x: Foo = ..., let x: Foo */
+const normalizeJsDocType = (raw) => {
+    let type = raw.trim();
+    // Strip JSDoc nullable/non-nullable prefixes: ?User → User, !User → User
+    if (type.startsWith('?') || type.startsWith('!'))
+        type = type.slice(1);
+    // Strip union with null/undefined/void: User|null → User
+    const parts = type.split('|').map(p => p.trim()).filter(p => p !== 'null' && p !== 'undefined' && p !== 'void');
+    if (parts.length !== 1)
+        return undefined; // ambiguous union
+    type = parts[0];
+    // Strip module: prefix — module:models.User → models.User
+    if (type.startsWith('module:'))
+        type = type.slice(7);
+    // Take last segment of dotted path: models.User → User
+    const segments = type.split('.');
+    type = segments[segments.length - 1];
+    // Strip generic wrapper: Promise<User> → Promise (base type, not inner)
+    const genericMatch = type.match(/^(\w+)\s*</);
+    if (genericMatch)
+        type = genericMatch[1];
+    // Simple identifier check
+    if (/^\w+$/.test(type))
+        return type;
+    return undefined;
+};
+/** Regex to extract JSDoc @param annotations: `@param {Type} name` */
+const JSDOC_PARAM_RE = /@param\s*\{([^}]+)\}\s+\[?(\w+)[\]=]?[^\s]*/g;
+/**
+ * Collect JSDoc @param type bindings from comment nodes preceding a function/method.
+ * Returns a map of paramName → typeName.
+ */
+const collectJsDocParams = (funcNode) => {
+    const commentTexts = [];
+    let sibling = funcNode.previousSibling;
+    while (sibling) {
+        if (sibling.type === 'comment') {
+            commentTexts.unshift(sibling.text);
+        }
+        else if (sibling.isNamed && sibling.type !== 'decorator') {
+            break;
+        }
+        sibling = sibling.previousSibling;
+    }
+    if (commentTexts.length === 0)
+        return new Map();
+    const params = new Map();
+    const commentBlock = commentTexts.join('\n');
+    JSDOC_PARAM_RE.lastIndex = 0;
+    let match;
+    while ((match = JSDOC_PARAM_RE.exec(commentBlock)) !== null) {
+        const typeName = normalizeJsDocType(match[1]);
+        const paramName = match[2];
+        if (typeName) {
+            params.set(paramName, typeName);
+        }
+    }
+    return params;
+};
+/**
+ * TypeScript: const x: Foo = ..., let x: Foo
+ * Also: JSDoc @param annotations on function/method definitions (for .js files).
+ */
 const extractDeclaration = (node, env) => {
+    // JSDoc @param on functions/methods — pre-populate env with param types
+    if (node.type === 'function_declaration' || node.type === 'method_definition') {
+        const jsDocParams = collectJsDocParams(node);
+        for (const [paramName, typeName] of jsDocParams) {
+            if (!env.has(paramName))
+                env.set(paramName, typeName);
+        }
+        return;
+    }
+    // Class field: `private users: User[]` — public_field_definition has name + type fields directly.
+    if (node.type === 'public_field_definition') {
+        const nameNode = node.childForFieldName('name');
+        const typeAnnotation = node.childForFieldName('type');
+        if (!nameNode || !typeAnnotation)
+            return;
+        const varName = nameNode.text;
+        if (!varName)
+            return;
+        const typeName = extractSimpleTypeName(typeAnnotation);
+        if (typeName)
+            env.set(varName, typeName);
+        return;
+    }
     for (let i = 0; i < node.namedChildCount; i++) {
         const declarator = node.namedChild(i);
         if (declarator?.type !== 'variable_declarator')
@@ -39,8 +126,355 @@ const extractParameter = (node, env) => {
     if (varName && typeName)
         env.set(varName, typeName);
 };
+/** TypeScript: const x = new User() — infer type from new_expression */
+const extractInitializer = (node, env, _classNames) => {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const declarator = node.namedChild(i);
+        if (declarator?.type !== 'variable_declarator')
+            continue;
+        // Only activate when there is no explicit type annotation — extractDeclaration already
+        // handles the annotated case and this function is called as a fallback.
+        if (declarator.childForFieldName('type') !== null)
+            continue;
+        let valueNode = declarator.childForFieldName('value');
+        // Unwrap `new User() as T`, `new User()!`, and double-cast `new User() as unknown as T`
+        while (valueNode?.type === 'as_expression' || valueNode?.type === 'non_null_expression') {
+            valueNode = valueNode.firstNamedChild;
+        }
+        if (valueNode?.type !== 'new_expression')
+            continue;
+        const constructorNode = valueNode.childForFieldName('constructor');
+        if (!constructorNode)
+            continue;
+        const nameNode = declarator.childForFieldName('name');
+        if (!nameNode)
+            continue;
+        const varName = extractVarName(nameNode);
+        const typeName = extractSimpleTypeName(constructorNode);
+        if (varName && typeName)
+            env.set(varName, typeName);
+    }
+};
+/**
+ * TypeScript/JavaScript: const user = getUser() — variable_declarator with call_expression value.
+ * Only matches unannotated declarators; annotated ones are handled by extractDeclaration.
+ * await is unwrapped: const user = await fetchUser() → callee = 'fetchUser'.
+ */
+const scanConstructorBinding = (node) => {
+    if (node.type !== 'variable_declarator')
+        return undefined;
+    if (hasTypeAnnotation(node))
+        return undefined;
+    const nameNode = node.childForFieldName('name');
+    if (!nameNode || nameNode.type !== 'identifier')
+        return undefined;
+    const value = unwrapAwait(node.childForFieldName('value'));
+    if (!value || value.type !== 'call_expression')
+        return undefined;
+    const calleeName = extractCalleeName(value);
+    if (!calleeName)
+        return undefined;
+    return { varName: nameNode.text, calleeName };
+};
+/** Regex to extract @returns or @return from JSDoc comments: `@returns {Type}` */
+const JSDOC_RETURN_RE = /@returns?\s*\{([^}]+)\}/;
+/**
+ * Minimal sanitization for JSDoc return types — preserves generic wrappers
+ * (e.g. `Promise<User>`) so that extractReturnTypeName in call-processor
+ * can apply WRAPPER_GENERICS unwrapping. Unlike normalizeJsDocType (which
+ * strips generics), this only strips JSDoc-specific syntax markers.
+ */
+const sanitizeReturnType = (raw) => {
+    let type = raw.trim();
+    // Strip JSDoc nullable/non-nullable prefixes: ?User → User, !User → User
+    if (type.startsWith('?') || type.startsWith('!'))
+        type = type.slice(1);
+    // Strip module: prefix — module:models.User → models.User
+    if (type.startsWith('module:'))
+        type = type.slice(7);
+    // Reject unions (ambiguous)
+    if (type.includes('|'))
+        return undefined;
+    if (!type)
+        return undefined;
+    return type;
+};
+/**
+ * Extract return type from JSDoc `@returns {Type}` or `@return {Type}` annotation
+ * preceding a function/method definition. Walks backwards through preceding siblings
+ * looking for comment nodes containing the annotation.
+ */
+const extractReturnType = (node) => {
+    let sibling = node.previousSibling;
+    while (sibling) {
+        if (sibling.type === 'comment') {
+            const match = JSDOC_RETURN_RE.exec(sibling.text);
+            if (match)
+                return sanitizeReturnType(match[1]);
+        }
+        else if (sibling.isNamed && sibling.type !== 'decorator')
+            break;
+        sibling = sibling.previousSibling;
+    }
+    return undefined;
+};
+const FOR_LOOP_NODE_TYPES = new Set([
+    'for_in_statement',
+]);
+/** TS function/method node types that carry a parameters list. */
+const TS_FUNCTION_NODE_TYPES = new Set([
+    'function_declaration', 'function_expression', 'arrow_function',
+    'method_definition', 'generator_function', 'generator_function_declaration',
+]);
+/**
+ * Extract element type from a TypeScript type annotation AST node.
+ * Handles:
+ *   type_annotation ": User[]"  →  array_type → type_identifier "User"
+ *   type_annotation ": Array<User>"  →  generic_type → extractGenericTypeArgs → "User"
+ * Falls back to text-based extraction via extractElementTypeFromString.
+ */
+const extractTsElementTypeFromAnnotation = (typeAnnotation, pos = 'last', depth = 0) => {
+    if (depth > 50)
+        return undefined;
+    // Unwrap type_annotation (the node text includes ': ' prefix)
+    const inner = typeAnnotation.type === 'type_annotation'
+        ? (typeAnnotation.firstNamedChild ?? typeAnnotation)
+        : typeAnnotation;
+    // readonly User[] — readonly_type wraps array_type: unwrap and recurse
+    if (inner.type === 'readonly_type') {
+        const wrapped = inner.firstNamedChild;
+        if (wrapped)
+            return extractTsElementTypeFromAnnotation(wrapped, pos, depth + 1);
+    }
+    // User[] — array_type: first named child is the element type
+    if (inner.type === 'array_type') {
+        const elem = inner.firstNamedChild;
+        if (elem)
+            return extractSimpleTypeName(elem);
+    }
+    // Array<User>, Map<string, User> — generic_type
+    // pos determines which type arg: 'first' for keys, 'last' for values
+    if (inner.type === 'generic_type') {
+        const args = extractGenericTypeArgs(inner);
+        if (args.length >= 1)
+            return pos === 'first' ? args[0] : args[args.length - 1];
+    }
+    // Fallback: strip ': ' prefix from type_annotation text and use string extraction
+    const rawText = inner.text;
+    return extractElementTypeFromString(rawText, pos);
+};
+/**
+ * Search a statement_block (function body) for a variable_declarator named `iterableName`
+ * that has a type annotation, preceding the given `beforeNode`.
+ * Returns the element type from the type annotation, or undefined.
+ */
+const findTsLocalDeclElementType = (iterableName, blockNode, beforeNode, pos = 'last') => {
+    for (let i = 0; i < blockNode.namedChildCount; i++) {
+        const stmt = blockNode.namedChild(i);
+        if (!stmt)
+            continue;
+        // Stop when we reach the for-loop itself
+        if (stmt === beforeNode || stmt.startIndex >= beforeNode.startIndex)
+            break;
+        // Look for lexical_declaration or variable_declaration
+        if (stmt.type !== 'lexical_declaration' && stmt.type !== 'variable_declaration')
+            continue;
+        for (let j = 0; j < stmt.namedChildCount; j++) {
+            const decl = stmt.namedChild(j);
+            if (decl?.type !== 'variable_declarator')
+                continue;
+            const nameNode = decl.childForFieldName('name');
+            if (nameNode?.text !== iterableName)
+                continue;
+            const typeAnnotation = decl.childForFieldName('type');
+            if (typeAnnotation)
+                return extractTsElementTypeFromAnnotation(typeAnnotation, pos);
+        }
+    }
+    return undefined;
+};
+/**
+ * Walk up the AST from a for-loop node to find the enclosing function scope,
+ * then search (1) its parameter list and (2) local declarations in the body
+ * for a variable named `iterableName` with a container type annotation.
+ * Returns the element type extracted from the annotation, or undefined.
+ */
+const findTsIterableElementType = (iterableName, startNode, pos = 'last') => {
+    let current = startNode.parent;
+    // Capture the immediate statement_block parent to search local declarations
+    const blockNode = current?.type === 'statement_block' ? current : null;
+    while (current) {
+        if (TS_FUNCTION_NODE_TYPES.has(current.type)) {
+            // Search function parameters
+            const paramsNode = current.childForFieldName('parameters')
+                ?? current.childForFieldName('formal_parameters');
+            if (paramsNode) {
+                for (let i = 0; i < paramsNode.namedChildCount; i++) {
+                    const param = paramsNode.namedChild(i);
+                    if (!param)
+                        continue;
+                    const patternNode = param.childForFieldName('pattern') ?? param.childForFieldName('name');
+                    if (patternNode?.text === iterableName) {
+                        const typeAnnotation = param.childForFieldName('type');
+                        if (typeAnnotation)
+                            return extractTsElementTypeFromAnnotation(typeAnnotation, pos);
+                    }
+                }
+            }
+            // Search local declarations in the function body (statement_block)
+            if (blockNode) {
+                const result = findTsLocalDeclElementType(iterableName, blockNode, startNode, pos);
+                if (result)
+                    return result;
+            }
+            break; // stop at the nearest function boundary
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/**
+ * TypeScript/JavaScript: for (const user of users) where users has a known array type.
+ *
+ * Both `for...of` and `for...in` use the same `for_in_statement` AST node in tree-sitter.
+ * We differentiate by checking for the `of` keyword among the unnamed children.
+ *
+ * Tier 1c: resolves the element type via three strategies in priority order:
+ *   1. declarationTypeNodes — raw type annotation AST node (covers Array<User> from declarations)
+ *   2. scopeEnv string — extractElementTypeFromString on the stored type (covers locally annotated vars)
+ *   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) => {
+    if (node.type !== 'for_in_statement')
+        return;
+    // Confirm this is `for...of`, not `for...in`, by scanning unnamed children for the keyword text.
+    let isForOf = false;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && !child.isNamed && child.text === 'of') {
+            isForOf = true;
+            break;
+        }
+    }
+    if (!isForOf)
+        return;
+    // The iterable is the `right` field — may be identifier or call_expression.
+    const rightNode = node.childForFieldName('right');
+    let iterableName;
+    let methodName;
+    if (rightNode?.type === 'identifier') {
+        iterableName = rightNode.text;
+    }
+    else if (rightNode?.type === 'member_expression') {
+        const prop = rightNode.childForFieldName('property');
+        if (prop)
+            iterableName = prop.text;
+    }
+    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
+        const fn = rightNode.childForFieldName('function');
+        if (fn?.type === 'member_expression') {
+            const obj = fn.childForFieldName('object');
+            const prop = fn.childForFieldName('property');
+            if (obj?.type === 'identifier') {
+                iterableName = obj.text;
+            }
+            else if (obj?.type === 'member_expression') {
+                // this.repos.values() → obj = this.repos → extract 'repos'
+                const innerProp = obj.childForFieldName('property');
+                if (innerProp)
+                    iterableName = innerProp.text;
+            }
+            if (prop?.type === 'property_identifier')
+                methodName = prop.text;
+        }
+    }
+    if (!iterableName)
+        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);
+    if (!elementType)
+        return;
+    // The loop variable is the `left` field.
+    const leftNode = node.childForFieldName('left');
+    if (!leftNode)
+        return;
+    // Handle destructured for-of: for (const [k, v] of entries)
+    // AST: left = array_pattern directly (no variable_declarator wrapper)
+    // Bind the LAST identifier to the element type (value in [key, value] patterns)
+    if (leftNode.type === 'array_pattern') {
+        const lastChild = leftNode.lastNamedChild;
+        if (lastChild?.type === 'identifier') {
+            scopeEnv.set(lastChild.text, elementType);
+        }
+        return;
+    }
+    if (leftNode.type === 'object_pattern') {
+        // Object destructuring (e.g., `for (const { id } of users)`) destructures
+        // into fields of the element type. Without field-level resolution, we cannot
+        // bind individual properties to their correct types. Skip to avoid false bindings.
+        return;
+    }
+    let loopVarNode = leftNode;
+    // `const user` parses as: left → variable_declarator containing an identifier named `user`
+    if (loopVarNode.type === 'variable_declarator') {
+        loopVarNode = loopVarNode.childForFieldName('name') ?? loopVarNode.firstNamedChild;
+    }
+    if (!loopVarNode)
+        return;
+    const loopVarName = extractVarName(loopVarNode);
+    if (loopVarName)
+        scopeEnv.set(loopVarName, elementType);
+};
+/** TS/JS: const alias = u → variable_declarator with name/value fields */
+const extractPendingAssignment = (node, scopeEnv) => {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child || child.type !== 'variable_declarator')
+            continue;
+        const nameNode = child.childForFieldName('name');
+        const valueNode = child.childForFieldName('value');
+        if (!nameNode || !valueNode)
+            continue;
+        const lhs = nameNode.text;
+        if (scopeEnv.has(lhs))
+            continue;
+        if (valueNode.type === 'identifier')
+            return { lhs, rhs: valueNode.text };
+    }
+    return undefined;
+};
+/** TS instanceof narrowing: `x instanceof User` → bind x to User.
+ *  Only works when x has no prior type binding (e.g. x: unknown, untyped params).
+ *  Typed params (x: Animal) are blocked by the !scopeEnv.has() guard in buildTypeEnv.
+ *  Uses first-writer-wins, same as Rust match arm bindings. */
+const extractPatternBinding = (node) => {
+    if (node.type !== 'binary_expression')
+        return undefined;
+    const op = node.children.find(c => !c.isNamed && c.text === 'instanceof');
+    if (!op)
+        return undefined;
+    // binary_expression children are positional — no left/right fields
+    const left = node.namedChild(0);
+    const right = node.namedChild(1);
+    if (left?.type !== 'identifier' || right?.type !== 'identifier')
+        return undefined;
+    return { varName: left.text, typeName: right.text };
+};
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
+    forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
+    patternBindingNodeTypes: new Set(['binary_expression']),
     extractDeclaration,
     extractParameter,
+    extractInitializer,
+    scanConstructorBinding,
+    extractReturnType,
+    extractForLoopBinding,
+    extractPendingAssignment,
+    extractPatternBinding,
 };