gitnexus 1.4.0 → 1.4.5

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

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName } from './shared.js';
+import { extractSimpleTypeName, extractVarName, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'declaration',
 ]);
@@ -29,6 +29,77 @@ const extractDeclaration = (node, env) => {
     if (varName)
         env.set(varName, typeName);
 };
+/** C++: auto x = new User(); auto x = User(); */
+const extractInitializer = (node, env, classNames) => {
+    const typeNode = node.childForFieldName('type');
+    if (!typeNode)
+        return;
+    // Only handle auto/placeholder — typed declarations are handled by extractDeclaration
+    const typeText = typeNode.text;
+    if (typeText !== 'auto' &&
+        typeText !== 'decltype(auto)' &&
+        typeNode.type !== 'placeholder_type_specifier')
+        return;
+    const declarator = node.childForFieldName('declarator');
+    if (!declarator)
+        return;
+    // Must be an init_declarator (i.e., has an initializer value)
+    if (declarator.type !== 'init_declarator')
+        return;
+    const value = declarator.childForFieldName('value');
+    if (!value)
+        return;
+    // Resolve the variable name, unwrapping pointer/reference declarators
+    const nameNode = declarator.childForFieldName('declarator');
+    if (!nameNode)
+        return;
+    const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
+        ? nameNode.firstNamedChild
+        : nameNode;
+    if (!finalName)
+        return;
+    const varName = extractVarName(finalName);
+    if (!varName)
+        return;
+    // auto x = new User() — new_expression
+    if (value.type === 'new_expression') {
+        const ctorType = value.childForFieldName('type');
+        if (ctorType) {
+            const typeName = extractSimpleTypeName(ctorType);
+            if (typeName)
+                env.set(varName, typeName);
+        }
+        return;
+    }
+    // auto x = User() — call_expression where function is a type name
+    // tree-sitter-cpp may parse the constructor name as type_identifier or identifier.
+    // For plain identifiers, verify against known class names from the file's AST
+    // to distinguish constructor calls (User()) from function calls (getUser()).
+    if (value.type === 'call_expression') {
+        const func = value.childForFieldName('function');
+        if (!func)
+            return;
+        if (func.type === 'type_identifier') {
+            const typeName = func.text;
+            if (typeName)
+                env.set(varName, typeName);
+        }
+        else if (func.type === 'identifier') {
+            const text = func.text;
+            if (text && classNames.has(text))
+                env.set(varName, text);
+        }
+        return;
+    }
+    // auto x = User{} — compound_literal_expression (brace initialization)
+    // AST: compound_literal_expression > type_identifier + initializer_list
+    if (value.type === 'compound_literal_expression') {
+        const typeId = value.firstNamedChild;
+        const typeName = typeId ? extractSimpleTypeName(typeId) : undefined;
+        if (typeName)
+            env.set(varName, typeName);
+    }
+};
 /** C/C++: parameter_declaration → type declarator */
 const extractParameter = (node, env) => {
     let nameNode = null;
@@ -53,8 +124,262 @@ const extractParameter = (node, env) => {
     if (varName && typeName)
         env.set(varName, typeName);
 };
+/** C/C++: auto x = User() where function is an identifier (not type_identifier) */
+const scanConstructorBinding = (node) => {
+    if (node.type !== 'declaration')
+        return undefined;
+    const typeNode = node.childForFieldName('type');
+    if (!typeNode)
+        return undefined;
+    const typeText = typeNode.text;
+    if (typeText !== 'auto' && typeText !== 'decltype(auto)' && typeNode.type !== 'placeholder_type_specifier')
+        return undefined;
+    const declarator = node.childForFieldName('declarator');
+    if (!declarator || declarator.type !== 'init_declarator')
+        return undefined;
+    const value = declarator.childForFieldName('value');
+    if (!value || value.type !== 'call_expression')
+        return undefined;
+    const func = value.childForFieldName('function');
+    if (!func)
+        return undefined;
+    if (func.type === 'qualified_identifier' || func.type === 'scoped_identifier') {
+        const last = func.lastNamedChild;
+        if (!last)
+            return undefined;
+        const nameNode = declarator.childForFieldName('declarator');
+        if (!nameNode)
+            return undefined;
+        const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
+            ? nameNode.firstNamedChild : nameNode;
+        if (!finalName)
+            return undefined;
+        return { varName: finalName.text, calleeName: last.text };
+    }
+    if (func.type !== 'identifier')
+        return undefined;
+    const nameNode = declarator.childForFieldName('declarator');
+    if (!nameNode)
+        return undefined;
+    const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
+        ? nameNode.firstNamedChild : nameNode;
+    if (!finalName)
+        return undefined;
+    const varName = finalName.text;
+    if (!varName)
+        return undefined;
+    return { varName, calleeName: func.text };
+};
+/** C++: auto alias = user → declaration with auto type + init_declarator where value is identifier */
+const extractPendingAssignment = (node, scopeEnv) => {
+    if (node.type !== 'declaration')
+        return undefined;
+    const typeNode = node.childForFieldName('type');
+    if (!typeNode)
+        return undefined;
+    // Only handle auto — typed declarations already resolved by extractDeclaration
+    const typeText = typeNode.text;
+    if (typeText !== 'auto' && typeText !== 'decltype(auto)'
+        && typeNode.type !== 'placeholder_type_specifier')
+        return undefined;
+    const declarator = node.childForFieldName('declarator');
+    if (!declarator || declarator.type !== 'init_declarator')
+        return undefined;
+    const value = declarator.childForFieldName('value');
+    if (!value || value.type !== 'identifier')
+        return undefined;
+    const nameNode = declarator.childForFieldName('declarator');
+    if (!nameNode)
+        return undefined;
+    const finalName = nameNode.type === 'pointer_declarator' || nameNode.type === 'reference_declarator'
+        ? nameNode.firstNamedChild : nameNode;
+    if (!finalName)
+        return undefined;
+    const lhs = extractVarName(finalName);
+    if (!lhs || scopeEnv.has(lhs))
+        return undefined;
+    return { lhs, rhs: value.text };
+};
+// --- For-loop Tier 1c ---
+const FOR_LOOP_NODE_TYPES = new Set(['for_range_loop']);
+/** Extract template type arguments from a C++ template_type node.
+ *  C++ template_type uses template_argument_list (not type_arguments), and each
+ *  argument is a type_descriptor with a 'type' field containing the type_specifier. */
+const extractCppTemplateTypeArgs = (templateTypeNode) => {
+    const argsNode = templateTypeNode.childForFieldName('arguments');
+    if (!argsNode || argsNode.type !== 'template_argument_list')
+        return [];
+    const result = [];
+    for (let i = 0; i < argsNode.namedChildCount; i++) {
+        let argNode = argsNode.namedChild(i);
+        if (!argNode)
+            continue;
+        // type_descriptor wraps the actual type specifier in a 'type' field
+        if (argNode.type === 'type_descriptor') {
+            const inner = argNode.childForFieldName('type');
+            if (inner)
+                argNode = inner;
+        }
+        const name = extractSimpleTypeName(argNode);
+        if (name)
+            result.push(name);
+    }
+    return result;
+};
+/** Extract element type from a C++ type annotation AST node.
+ *  Handles: template_type (vector<User>, map<string, User>),
+ *  pointer/reference types (User*, User&). */
+const extractCppElementTypeFromTypeNode = (typeNode, pos = 'last', depth = 0) => {
+    if (depth > 50)
+        return undefined;
+    // template_type: vector<User>, map<string, User> — extract type arg based on position
+    if (typeNode.type === 'template_type') {
+        const args = extractCppTemplateTypeArgs(typeNode);
+        if (args.length >= 1)
+            return pos === 'first' ? args[0] : args[args.length - 1];
+    }
+    // reference/pointer types: unwrap and recurse (vector<User>& → vector<User>)
+    if (typeNode.type === 'reference_type' || typeNode.type === 'pointer_type'
+        || typeNode.type === 'type_descriptor') {
+        const inner = typeNode.lastNamedChild;
+        if (inner)
+            return extractCppElementTypeFromTypeNode(inner, pos, depth + 1);
+    }
+    // qualified/scoped types: std::vector<User> → unwrap to template_type child
+    if (typeNode.type === 'qualified_identifier' || typeNode.type === 'scoped_type_identifier') {
+        const inner = typeNode.lastNamedChild;
+        if (inner)
+            return extractCppElementTypeFromTypeNode(inner, pos, depth + 1);
+    }
+    return undefined;
+};
+/** Walk up from a for-range-loop to the enclosing function_definition and search parameters
+ *  for one named `iterableName`. Returns the element type from its annotation. */
+const findCppParamElementType = (iterableName, startNode, pos = 'last') => {
+    let current = startNode.parent;
+    while (current) {
+        if (current.type === 'function_definition') {
+            const declarator = current.childForFieldName('declarator');
+            // function_definition > declarator (function_declarator) > parameters (parameter_list)
+            const paramsNode = declarator?.childForFieldName('parameters');
+            if (paramsNode) {
+                for (let i = 0; i < paramsNode.namedChildCount; i++) {
+                    const param = paramsNode.namedChild(i);
+                    if (!param || param.type !== 'parameter_declaration')
+                        continue;
+                    const paramDeclarator = param.childForFieldName('declarator');
+                    if (!paramDeclarator)
+                        continue;
+                    // Unwrap reference/pointer declarators: vector<User>& users → &users
+                    let identNode = paramDeclarator;
+                    if (identNode.type === 'reference_declarator' || identNode.type === 'pointer_declarator') {
+                        identNode = identNode.firstNamedChild ?? identNode;
+                    }
+                    if (identNode.text !== iterableName)
+                        continue;
+                    const typeNode = param.childForFieldName('type');
+                    if (typeNode)
+                        return extractCppElementTypeFromTypeNode(typeNode, pos);
+                }
+            }
+            break;
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/** 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) => {
+    if (node.type !== 'for_range_loop')
+        return;
+    const typeNode = node.childForFieldName('type');
+    const declaratorNode = node.childForFieldName('declarator');
+    const rightNode = node.childForFieldName('right');
+    if (!typeNode || !declaratorNode || !rightNode)
+        return;
+    // Unwrap reference/pointer declarator to get the loop variable name
+    let nameNode = declaratorNode;
+    if (nameNode.type === 'reference_declarator' || nameNode.type === 'pointer_declarator') {
+        nameNode = nameNode.firstNamedChild ?? nameNode;
+    }
+    // Handle structured bindings: auto& [key, value] or auto [key, value]
+    // Bind the last identifier (value heuristic for [key, value] patterns)
+    let loopVarName;
+    if (nameNode.type === 'structured_binding_declarator') {
+        const lastChild = nameNode.lastNamedChild;
+        if (lastChild?.type === 'identifier') {
+            loopVarName = lastChild.text;
+        }
+    }
+    else if (declaratorNode.type === 'structured_binding_declarator') {
+        const lastChild = declaratorNode.lastNamedChild;
+        if (lastChild?.type === 'identifier') {
+            loopVarName = lastChild.text;
+        }
+    }
+    const varName = loopVarName ?? extractVarName(nameNode);
+    if (!varName)
+        return;
+    // Check if the type is auto/placeholder — if not, use the explicit type directly
+    const isAuto = typeNode.type === 'placeholder_type_specifier'
+        || typeNode.text === 'auto'
+        || typeNode.text === 'const auto'
+        || typeNode.text === 'decltype(auto)';
+    if (!isAuto) {
+        // Explicit type: for (User& user : users) — extract directly
+        const typeName = extractSimpleTypeName(typeNode);
+        if (typeName)
+            scopeEnv.set(varName, typeName);
+        return;
+    }
+    // auto/const auto/auto& — resolve from the iterable's container type
+    // Extract iterable name + optional method
+    let iterableName;
+    let methodName;
+    if (rightNode.type === 'identifier') {
+        iterableName = rightNode.text;
+    }
+    else if (rightNode.type === 'field_expression') {
+        const prop = rightNode.lastNamedChild;
+        if (prop)
+            iterableName = prop.text;
+    }
+    else if (rightNode.type === 'call_expression') {
+        // users.begin() is NOT used in range-for, but container.items() etc. might be
+        const fieldExpr = rightNode.childForFieldName('function');
+        if (fieldExpr?.type === 'field_expression') {
+            const obj = fieldExpr.firstNamedChild;
+            if (obj?.type === 'identifier')
+                iterableName = obj.text;
+            const field = fieldExpr.lastNamedChild;
+            if (field?.type === 'field_identifier')
+                methodName = field.text;
+        }
+    }
+    else if (rightNode.type === 'pointer_expression') {
+        // Dereference: for (auto& user : *ptr) → pointer_expression > identifier
+        // Only handles simple *identifier; *this->field and **ptr are not resolved.
+        const operand = rightNode.lastNamedChild;
+        if (operand?.type === 'identifier')
+            iterableName = operand.text;
+    }
+    if (!iterableName)
+        return;
+    const containerTypeName = scopeEnv.get(iterableName);
+    const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
+    const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractCppElementTypeFromTypeNode, findCppParamElementType, typeArgPos);
+    if (elementType)
+        scopeEnv.set(varName, elementType);
+};
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
+    forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
     extractDeclaration,
     extractParameter,
+    extractInitializer,
+    scanConstructorBinding,
+    extractForLoopBinding,
+    extractPendingAssignment,
 };

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

@@ -1,4 +1,6 @@
-import { extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';
+import { extractSimpleTypeName, extractVarName, findChildByType, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
+/** Known container property accessors that operate on the container itself (e.g., dict.Keys, dict.Values) */
+const KNOWN_CONTAINER_PROPS = new Set(['Keys', 'Values']);
 const DECLARATION_NODE_TYPES = new Set([
     'local_declaration_statement',
     'variable_declaration',
@@ -38,7 +40,8 @@ const extractDeclaration = (node, env) => {
     let typeName;
     if (typeNode.type === 'implicit_type' && typeNode.text === 'var') {
         // Try to infer from initializer: var x = new Foo()
-        // C# tree-sitter puts object_creation_expression as direct child of variable_declarator
+        // tree-sitter-c-sharp may put object_creation_expression as direct child
+        // or inside equals_value_clause depending on grammar version
         if (declarators.length === 1) {
             const initializer = findChildByType(declarators[0], 'object_creation_expression')
                 ?? findChildByType(declarators[0], 'equals_value_clause')?.firstNamedChild;
@@ -82,8 +85,285 @@ const extractParameter = (node, env) => {
     if (varName && typeName)
         env.set(varName, typeName);
 };
+/** C#: var x = SomeFactory(...) → bind x to SomeFactory (constructor-like call) */
+const scanConstructorBinding = (node) => {
+    if (node.type !== 'variable_declaration')
+        return undefined;
+    // Find type and declarator children by iterating (C# grammar doesn't expose 'type' as a named field)
+    let typeNode = null;
+    let declarator = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'variable_declarator') {
+            if (!declarator)
+                declarator = child;
+        }
+        else if (!typeNode) {
+            typeNode = child;
+        }
+    }
+    // Only handle implicit_type (var) — explicit types handled by extractDeclaration
+    if (!typeNode || typeNode.type !== 'implicit_type')
+        return undefined;
+    if (!declarator)
+        return undefined;
+    const nameNode = declarator.childForFieldName('name') ?? declarator.firstNamedChild;
+    if (!nameNode || nameNode.type !== 'identifier')
+        return undefined;
+    // Find the initializer value: either inside equals_value_clause or as a direct child
+    // (tree-sitter-c-sharp puts invocation_expression directly inside variable_declarator)
+    let value = null;
+    for (let i = 0; i < declarator.namedChildCount; i++) {
+        const child = declarator.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'equals_value_clause') {
+            value = child.firstNamedChild;
+            break;
+        }
+        if (child.type === 'invocation_expression' || child.type === 'object_creation_expression' || child.type === 'await_expression') {
+            value = child;
+            break;
+        }
+    }
+    if (!value)
+        return undefined;
+    // Unwrap await: `var user = await svc.GetUserAsync()` → await_expression wraps invocation_expression
+    value = unwrapAwait(value);
+    if (!value)
+        return undefined;
+    // Skip object_creation_expression (new User()) — handled by extractInitializer
+    if (value.type === 'object_creation_expression')
+        return undefined;
+    if (value.type !== 'invocation_expression')
+        return undefined;
+    const func = value.firstNamedChild;
+    if (!func)
+        return undefined;
+    const calleeName = extractSimpleTypeName(func);
+    if (!calleeName)
+        return undefined;
+    return { varName: nameNode.text, calleeName };
+};
+const FOR_LOOP_NODE_TYPES = new Set([
+    'foreach_statement',
+]);
+/** Extract element type from a C# type annotation AST node.
+ *  Handles generic_name (List<User>), array_type (User[]), nullable_type (?).
+ *  `pos` selects which type arg: 'first' for keys, 'last' for values (default). */
+const extractCSharpElementTypeFromTypeNode = (typeNode, pos = 'last', depth = 0) => {
+    if (depth > 50)
+        return undefined;
+    // generic_name: List<User>, IEnumerable<User>, Dictionary<string, User>
+    // C# uses generic_name (not generic_type)
+    if (typeNode.type === 'generic_name') {
+        const argList = findChildByType(typeNode, 'type_argument_list');
+        if (argList && argList.namedChildCount >= 1) {
+            if (pos === 'first') {
+                const firstArg = argList.namedChild(0);
+                if (firstArg)
+                    return extractSimpleTypeName(firstArg);
+            }
+            else {
+                const lastArg = argList.namedChild(argList.namedChildCount - 1);
+                if (lastArg)
+                    return extractSimpleTypeName(lastArg);
+            }
+        }
+    }
+    // array_type: User[]
+    if (typeNode.type === 'array_type') {
+        const elemNode = typeNode.firstNamedChild;
+        if (elemNode)
+            return extractSimpleTypeName(elemNode);
+    }
+    // nullable_type: unwrap and recurse (List<User>? → List<User> → User)
+    if (typeNode.type === 'nullable_type') {
+        const inner = typeNode.firstNamedChild;
+        if (inner)
+            return extractCSharpElementTypeFromTypeNode(inner, pos, depth + 1);
+    }
+    return undefined;
+};
+/** Walk up from a foreach to the enclosing method and search parameters. */
+const findCSharpParamElementType = (iterableName, startNode, pos = 'last') => {
+    let current = startNode.parent;
+    while (current) {
+        if (current.type === 'method_declaration' || current.type === 'local_function_statement') {
+            const paramsNode = current.childForFieldName('parameters');
+            if (paramsNode) {
+                for (let i = 0; i < paramsNode.namedChildCount; i++) {
+                    const param = paramsNode.namedChild(i);
+                    if (!param || param.type !== 'parameter')
+                        continue;
+                    const nameNode = param.childForFieldName('name');
+                    if (nameNode?.text !== iterableName)
+                        continue;
+                    const typeNode = param.childForFieldName('type');
+                    if (typeNode)
+                        return extractCSharpElementTypeFromTypeNode(typeNode, pos);
+                }
+            }
+            break;
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/** C#: foreach (User user in users) — extract loop variable binding.
+ *  Tier 1c: for `foreach (var user in users)`, resolves element type from iterable. */
+const extractForLoopBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+    const typeNode = node.childForFieldName('type');
+    const nameNode = node.childForFieldName('left');
+    if (!typeNode || !nameNode)
+        return;
+    const varName = extractVarName(nameNode);
+    if (!varName)
+        return;
+    // Explicit type (existing behavior): foreach (User user in users)
+    if (!(typeNode.type === 'implicit_type' && typeNode.text === 'var')) {
+        const typeName = extractSimpleTypeName(typeNode);
+        if (typeName)
+            scopeEnv.set(varName, typeName);
+        return;
+    }
+    // Tier 1c: implicit type (var) — resolve from iterable's container type
+    const rightNode = node.childForFieldName('right');
+    let iterableName;
+    let methodName;
+    if (rightNode?.type === 'identifier') {
+        iterableName = rightNode.text;
+    }
+    else if (rightNode?.type === 'member_access_expression') {
+        // C# property access: data.Keys, data.Values → member_access_expression
+        // Also handles bare member access: this.users, repo.users → use property as iterableName
+        const obj = rightNode.childForFieldName('expression');
+        const prop = rightNode.childForFieldName('name');
+        const propText = prop?.type === 'identifier' ? prop.text : undefined;
+        if (propText && KNOWN_CONTAINER_PROPS.has(propText)) {
+            if (obj?.type === 'identifier') {
+                iterableName = obj.text;
+            }
+            else if (obj?.type === 'member_access_expression') {
+                // Nested member access: this.data.Values → obj is "this.data", extract "data"
+                const innerProp = obj.childForFieldName('name');
+                if (innerProp)
+                    iterableName = innerProp.text;
+            }
+            methodName = propText;
+        }
+        else if (propText) {
+            // Bare member access: this.users → use property name for scopeEnv lookup
+            iterableName = propText;
+        }
+    }
+    else if (rightNode?.type === 'invocation_expression') {
+        // C# method call: data.Select(...) → invocation_expression > member_access_expression
+        const fn = rightNode.firstNamedChild;
+        if (fn?.type === 'member_access_expression') {
+            const obj = fn.childForFieldName('expression');
+            const prop = fn.childForFieldName('name');
+            if (obj?.type === 'identifier')
+                iterableName = obj.text;
+            if (prop?.type === 'identifier')
+                methodName = prop.text;
+        }
+    }
+    if (!iterableName)
+        return;
+    const containerTypeName = scopeEnv.get(iterableName);
+    const typeArgPos = methodToTypeArgPosition(methodName, containerTypeName);
+    const elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractCSharpElementTypeFromTypeNode, findCSharpParamElementType, typeArgPos);
+    if (elementType)
+        scopeEnv.set(varName, elementType);
+};
+/**
+ * C# pattern binding extractor for `obj is Type variable` (type pattern).
+ *
+ * AST structure:
+ *   is_pattern_expression
+ *     expression: (the variable being tested)
+ *     pattern: declaration_pattern
+ *       type: (the declared type)
+ *       name: single_variable_designation > identifier (the new variable name)
+ *
+ * Conservative: returns undefined when the pattern field is absent, is not a
+ * declaration_pattern, or when the type/name cannot be extracted.
+ * No scopeEnv lookup is needed — the pattern explicitly declares the new variable's type.
+ */
+const extractPatternBinding = (node) => {
+    // is_pattern_expression: `obj is User user` — has a declaration_pattern child
+    if (node.type === 'is_pattern_expression') {
+        const pattern = node.childForFieldName('pattern');
+        if (pattern?.type !== 'declaration_pattern' && pattern?.type !== 'recursive_pattern')
+            return undefined;
+        const typeNode = pattern.childForFieldName('type');
+        const nameNode = pattern.childForFieldName('name');
+        if (!typeNode || !nameNode)
+            return undefined;
+        const typeName = extractSimpleTypeName(typeNode);
+        const varName = extractVarName(nameNode);
+        if (!typeName || !varName)
+            return undefined;
+        return { varName, typeName };
+    }
+    // declaration_pattern / recursive_pattern: standalone in switch statements and switch expressions
+    // `case User u:` or `User u =>` or `User { Name: "Alice" } u =>`
+    // Both use the same 'type' and 'name' fields.
+    if (node.type === 'declaration_pattern' || node.type === 'recursive_pattern') {
+        const typeNode = node.childForFieldName('type');
+        const nameNode = node.childForFieldName('name');
+        if (!typeNode || !nameNode)
+            return undefined;
+        const typeName = extractSimpleTypeName(typeNode);
+        const varName = extractVarName(nameNode);
+        if (!typeName || !varName)
+            return undefined;
+        return { varName, typeName };
+    }
+    return undefined;
+};
+/** C#: var alias = u → variable_declarator with name + equals_value_clause.
+ *  Only local_declaration_statement and variable_declaration contain variable_declarator children;
+ *  is_pattern_expression and field_declaration never do — skip them early. */
+const extractPendingAssignment = (node, scopeEnv) => {
+    if (node.type === 'is_pattern_expression' || node.type === 'field_declaration')
+        return undefined;
+    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');
+        if (!nameNode)
+            continue;
+        const lhs = nameNode.text;
+        if (scopeEnv.has(lhs))
+            continue;
+        // C# wraps value in equals_value_clause; fall back to last named child
+        let evc = null;
+        for (let j = 0; j < child.childCount; j++) {
+            if (child.child(j)?.type === 'equals_value_clause') {
+                evc = child.child(j);
+                break;
+            }
+        }
+        const valueNode = evc?.firstNamedChild ?? child.namedChild(child.namedChildCount - 1);
+        if (valueNode && valueNode !== nameNode && (valueNode.type === 'identifier' || valueNode.type === 'simple_identifier')) {
+            return { lhs, rhs: valueNode.text };
+        }
+    }
+    return undefined;
+};
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
+    forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
+    patternBindingNodeTypes: new Set(['is_pattern_expression', 'declaration_pattern', 'recursive_pattern']),
     extractDeclaration,
     extractParameter,
+    scanConstructorBinding,
+    extractForLoopBinding,
+    extractPendingAssignment,
+    extractPatternBinding,
 };