gitnexus 1.4.9 → 1.5.0

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

@@ -1,5 +1,5 @@
 import { findChild } from '../utils/ast-helpers.js';
-import { extractSimpleTypeName, extractVarName, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
+import { extractSimpleTypeName, extractVarName, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString, } from './shared.js';
 // ── Java ──────────────────────────────────────────────────────────────────
 const JAVA_DECLARATION_NODE_TYPES = new Set([
     'local_variable_declaration',
@@ -95,9 +95,7 @@ const scanJavaConstructorBinding = (node) => {
         return undefined;
     return { varName: nameNode.text, calleeName: methodName.text };
 };
-const JAVA_FOR_LOOP_NODE_TYPES = new Set([
-    'enhanced_for_statement',
-]);
+const JAVA_FOR_LOOP_NODE_TYPES = new Set(['enhanced_for_statement']);
 /** Extract element type from a Java type annotation AST node.
  *  Handles generic_type (List<User>), array_type (User[]). */
 const extractJavaElementTypeFromTypeNode = (typeNode, pos = 'last') => {
@@ -352,8 +350,7 @@ const extractKotlinDeclaration = (node, env) => {
         const varDecl = findChild(node, 'variable_declaration');
         if (varDecl) {
             const nameNode = findChild(varDecl, 'simple_identifier');
-            const typeNode = findChild(varDecl, 'user_type')
-                ?? findChild(varDecl, 'nullable_type');
+            const typeNode = findChild(varDecl, 'user_type') ?? findChild(varDecl, 'nullable_type');
             if (!nameNode || !typeNode)
                 return;
             const varName = extractVarName(nameNode);
@@ -363,10 +360,8 @@ const extractKotlinDeclaration = (node, env) => {
             return;
         }
         // Fallback: try direct fields
-        const nameNode = node.childForFieldName('name')
-            ?? findChild(node, 'simple_identifier');
-        const typeNode = node.childForFieldName('type')
-            ?? findChild(node, 'user_type');
+        const nameNode = node.childForFieldName('name') ?? findChild(node, 'simple_identifier');
+        const typeNode = node.childForFieldName('type') ?? findChild(node, 'user_type');
         if (!nameNode || !typeNode)
             return;
         const varName = extractVarName(nameNode);
@@ -405,8 +400,7 @@ const extractKotlinParameter = (node, env) => {
     if (!nameNode)
         nameNode = findChild(node, 'simple_identifier');
     if (!typeNode)
-        typeNode = findChild(node, 'user_type')
-            ?? findChild(node, 'nullable_type');
+        typeNode = findChild(node, 'user_type') ?? findChild(node, 'nullable_type');
     if (!nameNode || !typeNode)
         return;
     const varName = extractVarName(nameNode);
@@ -419,8 +413,7 @@ const extractKotlinParameter = (node, env) => {
 const findKotlinConstructorCallee = (node, classNames) => {
     if (node.type !== 'property_declaration')
         return undefined;
-    const value = node.childForFieldName('value')
-        ?? findChild(node, 'call_expression');
+    const value = node.childForFieldName('value') ?? findChild(node, 'call_expression');
     if (!value || value.type !== 'call_expression')
         return undefined;
     const callee = value.firstNamedChild;
@@ -495,9 +488,7 @@ const scanKotlinConstructorBinding = (node) => {
         return undefined;
     return { varName: nameNode.text, calleeName };
 };
-const KOTLIN_FOR_LOOP_NODE_TYPES = new Set([
-    'for_statement',
-]);
+const KOTLIN_FOR_LOOP_NODE_TYPES = new Set(['for_statement']);
 /** Extract element type from a Kotlin type annotation AST node (user_type wrapping generic).
  *  Kotlin: user_type → [type_identifier, type_arguments → [type_projection → user_type]]
  *  Handles the type_projection wrapper that Kotlin uses for generic type arguments. */
@@ -511,9 +502,7 @@ const extractKotlinElementTypeFromTypeNode = (typeNode, pos = 'last') => {
             if (!targetArg)
                 return undefined;
             // Kotlin wraps type args in type_projection — unwrap to get the inner type
-            const inner = targetArg.type === 'type_projection'
-                ? targetArg.firstNamedChild
-                : targetArg;
+            const inner = targetArg.type === 'type_projection' ? targetArg.firstNamedChild : targetArg;
             if (inner)
                 return extractSimpleTypeName(inner);
         }
@@ -792,7 +781,7 @@ const extractKotlinPatternBinding = (node, scopeEnv, declarationTypeNodes, scope
     // Kotlin AST: equality_expression > simple_identifier, "!=" [anon], "null" [anon]
     // Note: `null` is an anonymous node in tree-sitter-kotlin, not `null_literal`.
     if (node.type === 'equality_expression') {
-        const op = node.children.find(c => !c.isNamed && c.text === '!=');
+        const op = node.children.find((c) => !c.isNamed && c.text === '!=');
         if (!op)
             return undefined;
         // `null` is anonymous in Kotlin grammar — use positional child scan

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

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName, extractCalleeName, resolveIterableElementType, extractElementTypeFromString } from './shared.js';
+import { extractSimpleTypeName, extractVarName, extractCalleeName, resolveIterableElementType, extractElementTypeFromString, } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'assignment_expression', // For constructor inference: $x = new User()
     'property_declaration', // PHP 7.4+ typed properties: private UserRepo $repo;
@@ -51,7 +51,9 @@ const normalizePhpType = (raw) => {
     // Strip array suffix: User[] → User
     type = type.replace(/\[\]$/, '');
     // Strip union with null/false/void: User|null → User
-    const parts = type.split('|').filter(p => p !== 'null' && p !== 'false' && p !== 'void' && p !== 'mixed');
+    const parts = type
+        .split('|')
+        .filter((p) => p !== 'null' && p !== 'false' && p !== 'void' && p !== 'mixed');
     if (parts.length !== 1)
         return undefined;
     type = parts[0];
@@ -59,7 +61,11 @@ const normalizePhpType = (raw) => {
     const segments = type.split('\\');
     type = segments[segments.length - 1];
     // Skip uninformative types
-    if (type === 'mixed' || type === 'void' || type === 'self' || type === 'static' || type === 'object')
+    if (type === 'mixed' ||
+        type === 'void' ||
+        type === 'self' ||
+        type === 'static' ||
+        type === 'object')
         return undefined;
     // Extract element type from generic: Collection<User> → User
     // PHPDoc generics encode the element type in angle brackets. Since PHP's Strategy B
@@ -124,8 +130,8 @@ const extractClassPropertyElementType = (propDecl) => {
  * both fail to find the type.
  */
 const findClassPropertyElementType = (propName, classNode) => {
-    const declList = classNode.childForFieldName('body')
-        ?? (classNode.namedChild(classNode.namedChildCount - 1)?.type === 'declaration_list'
+    const declList = classNode.childForFieldName('body') ??
+        (classNode.namedChild(classNode.namedChildCount - 1)?.type === 'declaration_list'
             ? classNode.namedChild(classNode.namedChildCount - 1)
             : null); // fallback: last named child, only if it's a declaration_list
     if (!declList)
@@ -245,7 +251,7 @@ const extractInitializer = (node, env, _classNames) => {
     if (!typeName)
         return;
     // Resolve PHP self/static/parent to actual class names
-    const resolvedType = (typeName === 'self' || typeName === 'static' || typeName === 'parent')
+    const resolvedType = typeName === 'self' || typeName === 'static' || typeName === 'parent'
         ? resolvePhpKeyword(typeName, node)
         : typeName;
     if (!resolvedType)
@@ -331,7 +337,9 @@ const normalizePhpReturnType = (raw) => {
     // Strip nullable prefix: ?User[] → User[]
     let type = raw.startsWith('?') ? raw.slice(1) : raw;
     // Strip union with null/false/void: User[]|null → User[]
-    const parts = type.split('|').filter(p => p !== 'null' && p !== 'false' && p !== 'void' && p !== 'mixed');
+    const parts = type
+        .split('|')
+        .filter((p) => p !== 'null' && p !== 'false' && p !== 'void' && p !== 'mixed');
     if (parts.length !== 1)
         return undefined;
     type = parts[0];
@@ -339,7 +347,12 @@ const normalizePhpReturnType = (raw) => {
     const segments = type.split('\\');
     type = segments[segments.length - 1];
     // Skip uninformative types
-    if (type === 'mixed' || type === 'void' || type === 'self' || type === 'static' || type === 'object' || type === 'array')
+    if (type === 'mixed' ||
+        type === 'void' ||
+        type === 'self' ||
+        type === 'static' ||
+        type === 'object' ||
+        type === 'array')
         return undefined;
     if (/^\w+(\[\])?$/.test(type) || /^\w+\s*</.test(type))
         return type;
@@ -408,9 +421,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
     }
     return undefined;
 };
-const FOR_LOOP_NODE_TYPES = new Set([
-    'foreach_statement',
-]);
+const FOR_LOOP_NODE_TYPES = new Set(['foreach_statement']);
 /** Extract element type from a PHP type annotation AST node.
  *  PHP has limited AST-level container types — `array` is a primitive_type with no generic args.
  *  Named types (e.g., `Collection`) are returned as-is (container descriptor lookup handles them). */
@@ -482,11 +493,13 @@ const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, re
         if (!lastChild)
             return;
         // Handle by_ref: foreach ($arr as $k => &$v)
-        loopVarNode = lastChild.type === 'by_ref' ? (lastChild.firstNamedChild ?? lastChild) : lastChild;
+        loopVarNode =
+            lastChild.type === 'by_ref' ? (lastChild.firstNamedChild ?? lastChild) : lastChild;
     }
     else {
         // Simple: foreach ($users as $user) or foreach ($users as &$user)
-        loopVarNode = valueOrPair.type === 'by_ref' ? (valueOrPair.firstNamedChild ?? valueOrPair) : valueOrPair;
+        loopVarNode =
+            valueOrPair.type === 'by_ref' ? (valueOrPair.firstNamedChild ?? valueOrPair) : valueOrPair;
     }
     const varName = extractVarName(loopVarNode);
     if (!varName)

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

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName, extractElementTypeFromString, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
+import { extractSimpleTypeName, extractVarName, extractElementTypeFromString, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'assignment',
     'named_expression',
@@ -147,13 +147,9 @@ const scanConstructorBinding = (node) => {
         return undefined;
     return { varName: left.text, calleeName };
 };
-const FOR_LOOP_NODE_TYPES = new Set([
-    'for_statement',
-]);
+const FOR_LOOP_NODE_TYPES = new Set(['for_statement']);
 /** Python function/method node types that carry a parameters list. */
-const PY_FUNCTION_NODE_TYPES = new Set([
-    'function_definition', 'decorated_definition',
-]);
+const PY_FUNCTION_NODE_TYPES = new Set(['function_definition', 'decorated_definition']);
 /**
  * Extract element type from a Python type annotation AST node.
  * Handles:
@@ -215,13 +211,13 @@ const findPyParamElementType = (iterableName, startNode, pos = 'last') => {
                         continue;
                     // Try named `name` field first (parameter node), then first identifier child
                     // (typed_parameter node may store name as first positional child)
-                    const nameNode = param.childForFieldName('name')
-                        ?? (param.firstNamedChild?.type === 'identifier' ? param.firstNamedChild : null);
+                    const nameNode = param.childForFieldName('name') ??
+                        (param.firstNamedChild?.type === 'identifier' ? param.firstNamedChild : null);
                     if (nameNode?.text !== iterableName)
                         continue;
                     // Try `type` field, then last named child (typed_parameter stores type last)
-                    const typeAnnotation = param.childForFieldName('type')
-                        ?? (param.namedChildCount >= 2 ? param.namedChild(param.namedChildCount - 1) : null);
+                    const typeAnnotation = param.childForFieldName('type') ??
+                        (param.namedChildCount >= 2 ? param.namedChild(param.namedChildCount - 1) : null);
                     if (typeAnnotation && typeAnnotation !== nameNode) {
                         return extractPyElementTypeFromAnnotation(typeAnnotation, pos);
                     }
@@ -245,7 +241,7 @@ const extractMethodCall = (callNode) => {
     if (obj?.type !== 'identifier')
         return undefined;
     const method = fn.lastNamedChild;
-    const methodName = (method?.type === 'identifier' && method !== obj) ? method.text : undefined;
+    const methodName = method?.type === 'identifier' && method !== obj ? method.text : undefined;
     return { iterableName: obj.text, methodName };
 };
 /**
@@ -428,8 +424,7 @@ const extractPatternBinding = (node, scopeEnv) => {
     if (node.namedChildCount < 2)
         return undefined;
     const patternChild = node.namedChild(0);
-    const varNameNode = node.childForFieldName('alias')
-        ?? node.namedChild(node.namedChildCount - 1);
+    const varNameNode = node.childForFieldName('alias') ?? node.namedChild(node.namedChildCount - 1);
     if (!patternChild || !varNameNode)
         return undefined;
     if (varNameNode.type !== 'identifier')
@@ -456,7 +451,8 @@ const extractPatternBinding = (node, scopeEnv) => {
         return undefined;
     // class_pattern children: dotted_name (the class name) + optional keyword_pattern args.
     const classNameNode = classPattern.firstNamedChild;
-    if (!classNameNode || (classNameNode.type !== 'dotted_name' && classNameNode.type !== 'identifier'))
+    if (!classNameNode ||
+        (classNameNode.type !== 'dotted_name' && classNameNode.type !== 'identifier'))
         return undefined;
     const typeName = classNameNode.text;
     if (!typeName)

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

@@ -1,4 +1,4 @@
-import { extractRubyConstructorAssignment, extractSimpleTypeName, extractElementTypeFromString, extractVarName, resolveIterableElementType } from './shared.js';
+import { extractRubyConstructorAssignment, extractSimpleTypeName, extractElementTypeFromString, extractVarName, resolveIterableElementType, } from './shared.js';
 /**
  * Ruby type extractor — YARD annotation parsing.
  *
@@ -51,7 +51,7 @@ const extractYardTypeName = (yardType) => {
         }
     }
     parts.push(trimmed.slice(start).trim());
-    const filtered = parts.filter(p => p !== '' && p !== 'nil');
+    const filtered = parts.filter((p) => p !== '' && p !== 'nil');
     if (filtered.length !== 1)
         return undefined; // ambiguous union
     const typePart = filtered[0];
@@ -386,7 +386,12 @@ const extractPendingAssignment = (node, scopeEnv) => {
         }
         if (receiverNode?.type === 'identifier' && methodNode?.type === 'identifier') {
             // With receiver → methodCallResult (a.method)
-            return { kind: 'methodCallResult', lhs: varName, receiver: receiverNode.text, method: methodNode.text };
+            return {
+                kind: 'methodCallResult',
+                lhs: varName,
+                receiver: receiverNode.text,
+                method: methodNode.text,
+            };
         }
     }
     return undefined;

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

@@ -1,8 +1,5 @@
-import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, unwrapAwait, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
-const DECLARATION_NODE_TYPES = new Set([
-    'let_declaration',
-    'let_condition',
-]);
+import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, unwrapAwait, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString, } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set(['let_declaration', 'let_condition']);
 /** Walk up the AST to find the enclosing impl block and extract the implementing type name. */
 const findEnclosingImplType = (node) => {
     let current = node.parent;
@@ -308,9 +305,10 @@ const extractPatternBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
         // match_arm → pattern field is match_pattern wrapping the actual pattern
         const matchPatternNode = node.childForFieldName('pattern');
         // Unwrap match_pattern to get the tuple_struct_pattern inside
-        patternNode = matchPatternNode?.type === 'match_pattern'
-            ? matchPatternNode.firstNamedChild
-            : matchPatternNode;
+        patternNode =
+            matchPatternNode?.type === 'match_pattern'
+                ? matchPatternNode.firstNamedChild
+                : matchPatternNode;
         // source variable is in the parent match_expression's 'value' field
         const matchExpr = node.parent?.parent; // match_arm → match_block → match_expression
         if (matchExpr?.type === 'match_expression') {

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

@@ -8,8 +8,18 @@ const CSHARP_KEY_METHODS = new Set(['Keys']);
 const STD_VALUE_METHODS = new Set(['values', 'get', 'pop', 'remove']);
 const CSHARP_VALUE_METHODS = new Set(['Values', 'TryGetValue']);
 const SINGLE_ELEMENT_METHODS = new Set([
-    'iter', 'into_iter', 'iterator', 'get', 'first', 'last', 'pop',
-    'peek', 'poll', 'find', 'filter', 'map',
+    'iter',
+    'into_iter',
+    'iterator',
+    'get',
+    'first',
+    'last',
+    'pop',
+    'peek',
+    'poll',
+    'find',
+    'filter',
+    'map',
 ]);
 const CONTAINER_DESCRIPTORS = new Map([
     // --- Map / Dict types (arity 2: key + value) ---
@@ -22,11 +32,20 @@ const CONTAINER_DESCRIPTORS = new Map([
     ['dict', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }],
     ['Dict', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }],
     ['Dictionary', { arity: 2, keyMethods: CSHARP_KEY_METHODS, valueMethods: CSHARP_VALUE_METHODS }],
-    ['SortedDictionary', { arity: 2, keyMethods: CSHARP_KEY_METHODS, valueMethods: CSHARP_VALUE_METHODS }],
+    [
+        'SortedDictionary',
+        { arity: 2, keyMethods: CSHARP_KEY_METHODS, valueMethods: CSHARP_VALUE_METHODS },
+    ],
     ['Record', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }],
     ['OrderedDict', { arity: 2, keyMethods: STD_KEY_METHODS, valueMethods: STD_VALUE_METHODS }],
-    ['ConcurrentHashMap', { arity: 2, keyMethods: JAVA_KEY_METHODS, valueMethods: STD_VALUE_METHODS }],
-    ['ConcurrentDictionary', { arity: 2, keyMethods: CSHARP_KEY_METHODS, valueMethods: CSHARP_VALUE_METHODS }],
+    [
+        'ConcurrentHashMap',
+        { arity: 2, keyMethods: JAVA_KEY_METHODS, valueMethods: STD_VALUE_METHODS },
+    ],
+    [
+        'ConcurrentDictionary',
+        { arity: 2, keyMethods: CSHARP_KEY_METHODS, valueMethods: CSHARP_VALUE_METHODS },
+    ],
     // --- Single-element containers (arity 1) ---
     ['Array', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }],
     ['List', { arity: 1, keyMethods: NO_KEYS, valueMethods: SINGLE_ELEMENT_METHODS }],
@@ -110,8 +129,8 @@ export function getContainerDescriptor(typeName) {
  */
 export function resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractFromTypeNode, findParamElementType, typeArgPos = 'last') {
     // Strategy 1: declarationTypeNodes AST node (check current scope, then file scope)
-    const typeNode = declarationTypeNodes.get(`${scope}\0${iterableName}`)
-        ?? (scope !== '' ? declarationTypeNodes.get(`\0${iterableName}`) : undefined);
+    const typeNode = declarationTypeNodes.get(`${scope}\0${iterableName}`) ??
+        (scope !== '' ? declarationTypeNodes.get(`\0${iterableName}`) : undefined);
     if (typeNode) {
         const t = extractFromTypeNode(typeNode, typeArgPos);
         if (t)
@@ -148,23 +167,32 @@ export const extractSimpleTypeName = (typeNode, depth = 0) => {
     if (depth > 50 || typeNode.text.length > 2048)
         return undefined;
     // Direct type identifier (includes Ruby 'constant' for class names)
-    if (typeNode.type === 'type_identifier' || typeNode.type === 'identifier'
-        || typeNode.type === 'simple_identifier' || typeNode.type === 'constant') {
+    if (typeNode.type === 'type_identifier' ||
+        typeNode.type === 'identifier' ||
+        typeNode.type === 'simple_identifier' ||
+        typeNode.type === 'constant') {
         return typeNode.text;
     }
     // Qualified/scoped names: take the last segment (e.g., models.User → User, Models::User → User)
-    if (typeNode.type === 'scoped_identifier' || typeNode.type === 'qualified_identifier'
-        || typeNode.type === 'scoped_type_identifier' || typeNode.type === 'qualified_name'
-        || typeNode.type === 'qualified_type'
-        || typeNode.type === 'member_expression' || typeNode.type === 'member_access_expression'
-        || typeNode.type === 'attribute'
-        || typeNode.type === 'scope_resolution'
-        || typeNode.type === 'selector_expression') {
+    if (typeNode.type === 'scoped_identifier' ||
+        typeNode.type === 'qualified_identifier' ||
+        typeNode.type === 'scoped_type_identifier' ||
+        typeNode.type === 'qualified_name' ||
+        typeNode.type === 'qualified_type' ||
+        typeNode.type === 'member_expression' ||
+        typeNode.type === 'member_access_expression' ||
+        typeNode.type === 'attribute' ||
+        typeNode.type === 'scope_resolution' ||
+        typeNode.type === 'selector_expression') {
         const last = typeNode.lastNamedChild;
-        if (last && (last.type === 'type_identifier' || last.type === 'identifier'
-            || last.type === 'simple_identifier' || last.type === 'name'
-            || last.type === 'constant' || last.type === 'property_identifier'
-            || last.type === 'field_identifier')) {
+        if (last &&
+            (last.type === 'type_identifier' ||
+                last.type === 'identifier' ||
+                last.type === 'simple_identifier' ||
+                last.type === 'name' ||
+                last.type === 'constant' ||
+                last.type === 'property_identifier' ||
+                last.type === 'field_identifier')) {
             return last.text;
         }
     }
@@ -176,11 +204,12 @@ export const extractSimpleTypeName = (typeNode, depth = 0) => {
     }
     // Generic types: extract the base type (e.g., List<User> → List)
     // For nullable wrappers (Optional<User>, Option<User>), unwrap to inner type.
-    if (typeNode.type === 'generic_type' || typeNode.type === 'parameterized_type'
-        || typeNode.type === 'generic_name') {
-        const base = typeNode.childForFieldName('name')
-            ?? typeNode.childForFieldName('type')
-            ?? typeNode.firstNamedChild;
+    if (typeNode.type === 'generic_type' ||
+        typeNode.type === 'parameterized_type' ||
+        typeNode.type === 'generic_name') {
+        const base = typeNode.childForFieldName('name') ??
+            typeNode.childForFieldName('type') ??
+            typeNode.firstNamedChild;
         if (!base)
             return undefined;
         const baseName = extractSimpleTypeName(base, depth + 1);
@@ -218,8 +247,9 @@ export const extractSimpleTypeName = (typeNode, depth = 0) => {
         }
     }
     // Type annotations that wrap the actual type (TS/Python: `: Foo`, Kotlin: user_type)
-    if (typeNode.type === 'type_annotation' || typeNode.type === 'type'
-        || typeNode.type === 'user_type') {
+    if (typeNode.type === 'type_annotation' ||
+        typeNode.type === 'type' ||
+        typeNode.type === 'user_type') {
         const inner = typeNode.firstNamedChild;
         if (inner)
             return extractSimpleTypeName(inner, depth + 1);
@@ -239,9 +269,12 @@ export const extractSimpleTypeName = (typeNode, depth = 0) => {
     // PHP: primitive_type; TS/JS: predefined_type
     // Java: integral_type (int/long/short/byte), floating_point_type (float/double),
     //       boolean_type (boolean), void_type (void)
-    if (typeNode.type === 'primitive_type' || typeNode.type === 'predefined_type'
-        || typeNode.type === 'integral_type' || typeNode.type === 'floating_point_type'
-        || typeNode.type === 'boolean_type' || typeNode.type === 'void_type') {
+    if (typeNode.type === 'primitive_type' ||
+        typeNode.type === 'predefined_type' ||
+        typeNode.type === 'integral_type' ||
+        typeNode.type === 'floating_point_type' ||
+        typeNode.type === 'boolean_type' ||
+        typeNode.type === 'void_type') {
         return typeNode.text;
     }
     // PHP named_type / optional_type
@@ -261,9 +294,12 @@ export const extractSimpleTypeName = (typeNode, depth = 0) => {
  * Returns the simple identifier text, or undefined for destructuring/complex patterns.
  */
 export const extractVarName = (node) => {
-    if (node.type === 'identifier' || node.type === 'simple_identifier'
-        || node.type === 'variable_name' || node.type === 'name'
-        || node.type === 'constant' || node.type === 'property_identifier') {
+    if (node.type === 'identifier' ||
+        node.type === 'simple_identifier' ||
+        node.type === 'variable_name' ||
+        node.type === 'name' ||
+        node.type === 'constant' ||
+        node.type === 'property_identifier') {
         return node.text;
     }
     // variable_declarator (Java/C#): has a 'name' field
@@ -320,17 +356,20 @@ export const extractGenericTypeArgs = (typeNode, depth = 0) => {
     if (depth > 50)
         return [];
     // Unwrap wrapper nodes that may sit above the generic_type
-    if (typeNode.type === 'type_annotation' || typeNode.type === 'type'
-        || typeNode.type === 'user_type' || typeNode.type === 'nullable_type'
-        || typeNode.type === 'optional_type') {
+    if (typeNode.type === 'type_annotation' ||
+        typeNode.type === 'type' ||
+        typeNode.type === 'user_type' ||
+        typeNode.type === 'nullable_type' ||
+        typeNode.type === 'optional_type') {
         const inner = typeNode.firstNamedChild;
         if (inner)
             return extractGenericTypeArgs(inner, depth + 1);
         return [];
     }
     // Only process generic/parameterized type nodes (includes C#'s generic_name)
-    if (typeNode.type !== 'generic_type' && typeNode.type !== 'parameterized_type'
-        && typeNode.type !== 'generic_name') {
+    if (typeNode.type !== 'generic_type' &&
+        typeNode.type !== 'parameterized_type' &&
+        typeNode.type !== 'generic_name') {
         return [];
     }
     // Find the type_arguments / type_argument_list child
@@ -438,7 +477,10 @@ export const stripNullable = (typeName) => {
         text = text.slice(0, -1).trim();
     // Strip union with null/undefined/None/nil/void
     if (text.includes('|')) {
-        const parts = text.split('|').map(p => p.trim()).filter(p => p !== '' && !NULLABLE_KEYWORDS.has(p));
+        const parts = text
+            .split('|')
+            .map((p) => p.trim())
+            .filter((p) => p !== '' && !NULLABLE_KEYWORDS.has(p));
         if (parts.length === 1)
             return parts[0];
         return undefined; // genuine union or all-nullable — refuse
@@ -581,10 +623,35 @@ export function extractElementTypeFromString(typeStr, pos = 'last') {
 // Extracts the base user-defined type name.
 /** Primitive / built-in types that should NOT produce a receiver binding. */
 const PRIMITIVE_TYPES = new Set([
-    'string', 'number', 'boolean', 'void', 'int', 'float', 'double', 'long',
-    'short', 'byte', 'char', 'bool', 'str', 'i8', 'i16', 'i32', 'i64',
-    'u8', 'u16', 'u32', 'u64', 'f32', 'f64', 'usize', 'isize',
-    'undefined', 'null', 'None', 'nil',
+    'string',
+    'number',
+    'boolean',
+    'void',
+    'int',
+    'float',
+    'double',
+    'long',
+    'short',
+    'byte',
+    'char',
+    'bool',
+    'str',
+    'i8',
+    'i16',
+    'i32',
+    'i64',
+    'u8',
+    'u16',
+    'u32',
+    'u64',
+    'f32',
+    'f64',
+    'usize',
+    'isize',
+    'undefined',
+    'null',
+    'None',
+    'nil',
 ]);
 /**
  * Extract a simple type name from raw return-type text.
@@ -600,13 +667,27 @@ const PRIMITIVE_TYPES = new Set([
  * Returns undefined for complex types or primitives.
  */
 const WRAPPER_GENERICS = new Set([
-    'Promise', 'Observable', 'Future', 'CompletableFuture', 'Task', 'ValueTask', // async wrappers
-    'Option', 'Some', 'Optional', 'Maybe', // nullable wrappers
-    'Result', 'Either', // result wrappers
+    'Promise',
+    'Observable',
+    'Future',
+    'CompletableFuture',
+    'Task',
+    'ValueTask', // async wrappers
+    'Option',
+    'Some',
+    'Optional',
+    'Maybe', // nullable wrappers
+    'Result',
+    'Either', // result wrappers
     // Rust smart pointers (Deref to inner type)
-    'Rc', 'Arc', 'Weak', // pointer types
-    'MutexGuard', 'RwLockReadGuard', 'RwLockWriteGuard', // guard types
-    'Ref', 'RefMut', // RefCell guards
+    'Rc',
+    'Arc',
+    'Weak', // pointer types
+    'MutexGuard',
+    'RwLockReadGuard',
+    'RwLockWriteGuard', // guard types
+    'Ref',
+    'RefMut', // RefCell guards
     'Cow', // copy-on-write
     // Containers (List, Array, Vec, Set, etc.) are intentionally excluded —
     // methods are called on the container, not the element type.
@@ -668,7 +749,10 @@ export const extractReturnTypeName = (raw, depth = 0) => {
     text = text.replace(/\?$/, '');
     // Handle union types: "User | null" → "User"
     if (text.includes('|')) {
-        const parts = text.split('|').map(p => p.trim()).filter(p => p !== 'null' && p !== 'undefined' && p !== 'void' && p !== 'None' && p !== 'nil');
+        const parts = text
+            .split('|')
+            .map((p) => p.trim())
+            .filter((p) => p !== 'null' && p !== 'undefined' && p !== 'void' && p !== 'None' && p !== 'nil');
         if (parts.length === 1)
             text = parts[0];
         else