gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/ts-js-hoc-utils.d.ts

@@ -0,0 +1,12 @@
+import type { SyntaxNode } from './utils/ast-helpers.js';
+export declare const ARRAY_METHOD_HOC_BLOCKLIST: readonly ["map", "filter", "reduce", "forEach", "find", "findIndex", "some", "every", "flatMap", "sort", "splice", "slice", "concat", "fill", "copyWithin", "join", "flat", "at", "entries", "keys", "values", "indexOf", "lastIndexOf", "includes", "pop", "push", "shift", "unshift", "reverse", "reduceRight", "toSorted", "toReversed", "toSpliced", "with"];
+export declare const ARRAY_METHOD_HOC_BLOCKLIST_SET: ReadonlySet<string>;
+export declare const DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST: readonly ["setTimeout", "setInterval", "queueMicrotask", "requestAnimationFrame", "requestIdleCallback"];
+export declare const DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET: ReadonlySet<string>;
+export declare const ARRAY_CALLBACK_METHODS: ReadonlySet<string>;
+export declare function buildNotAnyOfPredicate(captureName: string, values: readonly string[]): string;
+export declare const ARRAY_METHOD_NOT_ANY_OF_PREDICATE: string;
+export declare const DEFAULT_EXPORT_IDENTIFIER_NOT_ANY_OF_PREDICATE: string;
+export declare function deriveDefaultExportHocName(filePath: string): string;
+export declare function isDefaultExportHocFunctionNode(node: SyntaxNode): boolean;
+export declare function isBlockedDefaultExportHoc(node: SyntaxNode): boolean;

package/dist/core/ingestion/ts-js-hoc-utils.js

@@ -0,0 +1,105 @@
+import path from 'node:path';
+// Member-expression callees that should never classify a callback-wrapped
+// binding as a top-level Function. This covers callback-taking Array methods
+// plus a few value-returning methods that share the same AST shape.
+export const ARRAY_METHOD_HOC_BLOCKLIST = [
+    'map',
+    'filter',
+    'reduce',
+    'forEach',
+    'find',
+    'findIndex',
+    'some',
+    'every',
+    'flatMap',
+    'sort',
+    'splice',
+    'slice',
+    'concat',
+    'fill',
+    'copyWithin',
+    'join',
+    'flat',
+    'at',
+    'entries',
+    'keys',
+    'values',
+    'indexOf',
+    'lastIndexOf',
+    'includes',
+    'pop',
+    'push',
+    'shift',
+    'unshift',
+    'reverse',
+    'reduceRight',
+    'toSorted',
+    'toReversed',
+    'toSpliced',
+    'with',
+];
+export const ARRAY_METHOD_HOC_BLOCKLIST_SET = new Set(ARRAY_METHOD_HOC_BLOCKLIST);
+// Identifier-callee default exports stay intentionally conservative: only a
+// few obvious callback-taking built-ins are suppressed here. Framework HOCs
+// like defineEventHandler still pass through and are named from the module.
+export const DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST = [
+    'setTimeout',
+    'setInterval',
+    'queueMicrotask',
+    'requestAnimationFrame',
+    'requestIdleCallback',
+];
+export const DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET = new Set(DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST);
+export const ARRAY_CALLBACK_METHODS = new Set([
+    'map',
+    'filter',
+    'find',
+    'findIndex',
+    'findLast',
+    'findLastIndex',
+    'forEach',
+    'reduce',
+    'reduceRight',
+    'some',
+    'every',
+    'flatMap',
+    'sort',
+]);
+export function buildNotAnyOfPredicate(captureName, values) {
+    return `(#not-any-of? @${captureName} ${values.map((value) => `"${value}"`).join(' ')})`;
+}
+export const ARRAY_METHOD_NOT_ANY_OF_PREDICATE = buildNotAnyOfPredicate('callee', ARRAY_METHOD_HOC_BLOCKLIST);
+export const DEFAULT_EXPORT_IDENTIFIER_NOT_ANY_OF_PREDICATE = buildNotAnyOfPredicate('hoc', DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST);
+export function deriveDefaultExportHocName(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    // Use individual path.posix helpers instead of path.posix.parse() to avoid
+    // triggering the require-safe-parse ESLint rule (which treats any .parse()
+    // call in src/core/ as a potential unsafe tree-sitter direct-parse).
+    const ext = path.posix.extname(normalized);
+    const name = path.posix.basename(normalized, ext);
+    const dir = path.posix.dirname(normalized);
+    if (name === 'index') {
+        const parent = path.posix.basename(dir);
+        if (parent !== '' && parent !== '.' && parent !== '/')
+            return parent;
+    }
+    return name || 'default';
+}
+export function isDefaultExportHocFunctionNode(node) {
+    const args = node.parent;
+    if (args === null || args.type !== 'arguments')
+        return false;
+    const callExpr = args.parent;
+    if (callExpr === null || callExpr.type !== 'call_expression')
+        return false;
+    return callExpr.parent?.type === 'export_statement';
+}
+export function isBlockedDefaultExportHoc(node) {
+    if (!isDefaultExportHocFunctionNode(node))
+        return false;
+    const callExpr = node.parent?.parent;
+    if (callExpr === null || callExpr?.type !== 'call_expression')
+        return false;
+    const callee = callExpr.childForFieldName?.('function');
+    return callee?.type === 'identifier' && DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET.has(callee.text);
+}

package/dist/core/ingestion/type-env.d.ts

@@ -36,6 +36,7 @@ export declare const isSubclassOf: (child: string, parent: string, parentMap: Re
  * Uses an options object to allow future extensions without positional parameter sprawl.
  */
 export interface BuildTypeEnvOptions {
+    filePath?: string;
     model?: SemanticModel;
     parentMap?: ReadonlyMap<string, readonly string[]>;
     /** Pre-resolved bindings from upstream files (Phase 14).
@@ -61,7 +62,7 @@ export interface BuildTypeEnvOptions {
      *  Replaces the generic name-field lookup for languages with non-standard
      *  AST structures (C/C++ declarator unwrapping, Swift init/deinit, etc.).
      *  When null is returned or not provided, falls back to node.childForFieldName('name')?.text. */
-    extractFunctionName?: (node: SyntaxNode) => {
+    extractFunctionName?: (node: SyntaxNode, filePath?: string) => {
         funcName: string | null;
         label: NodeLabel;
     } | null;

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

@@ -35,7 +35,6 @@ const findTypeIdentifierChild = (node) => {
  *  Includes both multi-arm pattern-match branches AND if-statement bodies for null-check narrowing. */
 const NARROWING_BRANCH_TYPES = new Set([
     'when_entry', // Kotlin when
-    'switch_block_label', // Java switch (enhanced)
     'if_statement', // TS/JS, Java, C/C++
     'if_expression', // Kotlin (if is an expression)
     'statement_block', // TS/JS: { ... } body of if
@@ -67,8 +66,8 @@ const fastStripNullable = (typeName) => {
         ? typeName
         : stripNullable(typeName);
 };
-/** Implementation of the lookup logic — shared between TypeEnvironment and the legacy export. */
-const lookupInEnv = (env, varName, callNode, patternOverrides, enclosingFunctionFinder, extractFunctionNameHook) => {
+/** Implementation of the lookup logic backing TypeEnvironment.lookup. */
+const lookupInEnv = (env, varName, callNode, patternOverrides, enclosingFunctionFinder, extractFunctionNameHook, filePath) => {
     // Self/this receiver: resolve to enclosing class name via AST walk
     if (varName === 'self' || varName === 'this' || varName === '$this') {
         return findEnclosingClassName(callNode);
@@ -79,7 +78,7 @@ const lookupInEnv = (env, varName, callNode, patternOverrides, enclosingFunction
         return findEnclosingParentClassName(callNode);
     }
     // Determine the enclosing function scope for the call
-    const scopeKey = findEnclosingScopeKey(callNode, enclosingFunctionFinder, extractFunctionNameHook);
+    const scopeKey = findEnclosingScopeKey(callNode, enclosingFunctionFinder, extractFunctionNameHook, filePath);
     // Check position-indexed pattern overrides first (e.g., Kotlin when/is smart casts).
     // These take priority over flat scopeEnv because they represent per-branch narrowing.
     if (scopeKey && patternOverrides) {
@@ -287,11 +286,11 @@ const extractParentClassFromNode = (classNode) => {
  *  it is consulted for each ancestor before the default FUNCTION_NODE_TYPES check.
  *  This handles languages like Dart where the function body is a sibling of the
  *  signature instead of a child. */
-const findEnclosingScopeKey = (node, enclosingFunctionFinder, extractFunctionNameHook) => {
+const findEnclosingScopeKey = (node, enclosingFunctionFinder, extractFunctionNameHook, filePath) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
-            const funcName = extractFunctionNameHook?.(current)?.funcName ?? genericFuncName(current);
+            const funcName = extractFunctionNameHook?.(current, filePath)?.funcName ?? genericFuncName(current);
             if (funcName)
                 return `${funcName}@${current.startIndex}`;
         }
@@ -796,7 +795,6 @@ export const buildTypeEnv = (tree, language, options) => {
                         (child.type === 'user_type' ||
                             child.type === 'type_identifier' ||
                             child.type === 'generic_type' ||
-                            child.type === 'parameterized_type' ||
                             child.type === 'nullable_type')) {
                         fallbackType = child;
                     }
@@ -1084,7 +1082,7 @@ export const buildTypeEnv = (tree, language, options) => {
         }
     }
     return {
-        lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides, options?.enclosingFunctionFinder, extractFuncNameHook),
+        lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides, options?.enclosingFunctionFinder, extractFuncNameHook, options?.filePath),
         constructorBindings: bindings,
         fileScope: () => env.get(FILE_SCOPE) ?? emptyFileScope(),
         allScopes: () => env,

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

@@ -111,13 +111,13 @@ const extractInitializer = (node, env, classNames) => {
             //   or: call_expression > function: template_function (unqualified)
             const templateFunc = func.type === 'template_function'
                 ? func
-                : func.type === 'qualified_identifier' || func.type === 'scoped_identifier'
+                : func.type === 'qualified_identifier'
                     ? (func.namedChildren.find((c) => c.type === 'template_function') ?? null)
                     : null;
             if (templateFunc) {
                 const nameNode = templateFunc.firstNamedChild;
                 if (nameNode) {
-                    const funcName = nameNode.type === 'qualified_identifier' || nameNode.type === 'scoped_identifier'
+                    const funcName = nameNode.type === 'qualified_identifier'
                         ? (nameNode.lastNamedChild?.text ?? '')
                         : nameNode.text;
                     if (SMART_PTR_FACTORIES.has(funcName)) {
@@ -185,7 +185,7 @@ const scanConstructorBinding = (node) => {
     const func = value.childForFieldName('function');
     if (!func)
         return undefined;
-    if (func.type === 'qualified_identifier' || func.type === 'scoped_identifier') {
+    if (func.type === 'qualified_identifier') {
         const last = func.lastNamedChild;
         if (!last)
             return undefined;
@@ -309,16 +309,14 @@ const extractCppElementTypeFromTypeNode = (typeNode, pos = 'last', depth = 0) =>
         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') {
+    // type_descriptor wrapper: unwrap and recurse (vector<User>& → vector<User>)
+    if (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') {
+    // qualified types: std::vector<User> → unwrap to template_type child
+    if (typeNode.type === 'qualified_identifier') {
         const inner = typeNode.lastNamedChild;
         if (inner)
             return extractCppElementTypeFromTypeNode(inner, pos, depth + 1);
@@ -497,7 +495,7 @@ const detectCppConstructorType = (node, classNames) => {
     if (!nameNode)
         return undefined;
     let funcName;
-    if (nameNode.type === 'qualified_identifier' || nameNode.type === 'scoped_identifier') {
+    if (nameNode.type === 'qualified_identifier') {
         funcName = nameNode.lastNamedChild?.text ?? '';
     }
     else {

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

@@ -27,7 +27,7 @@ const extractDeclaration = (node, env) => {
         const child = node.namedChild(i);
         if (!child)
             continue;
-        if (!typeNode && child.type !== 'variable_declarator' && child.type !== 'equals_value_clause') {
+        if (!typeNode && child.type !== 'variable_declarator') {
             // First non-declarator child is the type (identifier, implicit_type, generic_name, etc.)
             typeNode = child;
         }
@@ -41,11 +41,9 @@ const extractDeclaration = (node, env) => {
     let typeName;
     if (typeNode.type === 'implicit_type' && typeNode.text === 'var') {
         // Try to infer from initializer: var x = new Foo()
-        // tree-sitter-c-sharp may put object_creation_expression as direct child
-        // or inside equals_value_clause depending on grammar version
+        // tree-sitter-c-sharp puts object_creation_expression as a direct child
         if (declarators.length === 1) {
-            const initializer = findChild(declarators[0], 'object_creation_expression') ??
-                findChild(declarators[0], 'equals_value_clause')?.firstNamedChild;
+            const initializer = findChild(declarators[0], 'object_creation_expression');
             if (initializer?.type === 'object_creation_expression') {
                 const ctorType = initializer.childForFieldName('type');
                 if (ctorType)
@@ -76,7 +74,7 @@ const extractParameter = (node, env) => {
         nameNode = node.childForFieldName('name');
     }
     else {
-        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        nameNode = node.childForFieldName('name');
         typeNode = node.childForFieldName('type');
     }
     if (!nameNode || !typeNode)
@@ -113,17 +111,13 @@ const scanConstructorBinding = (node) => {
     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
+    // Find the initializer value 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') {
@@ -462,18 +456,9 @@ const extractPendingAssignment = (node, scopeEnv) => {
         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')) {
+        // C# variable_declarator holds the initializer value as a direct named child
+        const valueNode = child.namedChild(child.namedChildCount - 1);
+        if (valueNode && valueNode !== nameNode && valueNode.type === 'identifier') {
             return { kind: 'copy', lhs, rhs: valueNode.text };
         }
         // member_access_expression RHS → fieldAccess (a.Field)
@@ -487,7 +472,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
         // invocation_expression RHS
         if (valueNode?.type === 'invocation_expression') {
             const funcNode = valueNode.firstNamedChild;
-            if (funcNode?.type === 'identifier_name' || funcNode?.type === 'identifier') {
+            if (funcNode?.type === 'identifier') {
                 return { kind: 'callResult', lhs, callee: funcNode.text };
             }
             // method call with receiver → methodCallResult: a.GetC()
@@ -504,7 +489,7 @@ const extractPendingAssignment = (node, scopeEnv) => {
             const inner = valueNode.firstNamedChild;
             if (inner?.type === 'invocation_expression') {
                 const funcNode = inner.firstNamedChild;
-                if (funcNode?.type === 'identifier_name' || funcNode?.type === 'identifier') {
+                if (funcNode?.type === 'identifier') {
                     return { kind: 'callResult', lhs, callee: funcNode.text };
                 }
                 if (funcNode?.type === 'member_access_expression') {
@@ -555,15 +540,14 @@ export const typeConfig = {
         const direct = node.childForFieldName('type');
         if (direct)
             return direct;
-        const wrapped = node.childForFieldName('declaration') ??
-            (() => {
-                for (let i = 0; i < node.namedChildCount; i++) {
-                    const c = node.namedChild(i);
-                    if (c?.type === 'variable_declaration')
-                        return c;
-                }
-                return null;
-            })();
+        const wrapped = (() => {
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (c?.type === 'variable_declaration')
+                    return c;
+            }
+            return null;
+        })();
         return wrapped?.childForFieldName('type') ?? null;
     },
     forLoopNodeTypes: FOR_LOOP_NODE_TYPES,

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

@@ -131,16 +131,8 @@ const extractDeclaration = (node, env) => {
 };
 /** Go: parameter → name type */
 const extractParameter = (node, env) => {
-    let nameNode = null;
-    let typeNode = null;
-    if (node.type === 'parameter') {
-        nameNode = node.childForFieldName('name');
-        typeNode = node.childForFieldName('type');
-    }
-    else {
-        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
-        typeNode = node.childForFieldName('type');
-    }
+    const nameNode = node.childForFieldName('name');
+    const typeNode = node.childForFieldName('type');
     if (!nameNode || !typeNode)
         return;
     const varName = extractVarName(nameNode);

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

@@ -60,7 +60,7 @@ const extractJavaParameter = (node, env) => {
     }
     else {
         // Generic fallback
-        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        nameNode = node.childForFieldName('name');
         typeNode = node.childForFieldName('type');
     }
     if (!nameNode || !typeNode)
@@ -359,9 +359,10 @@ const extractKotlinDeclaration = (node, env) => {
                 env.set(varName, typeName);
             return;
         }
-        // Fallback: try direct fields
-        const nameNode = node.childForFieldName('name') ?? findChild(node, 'simple_identifier');
-        const typeNode = node.childForFieldName('type') ?? findChild(node, 'user_type');
+        // Fallback: Kotlin property_declaration has no name/type fields (verified by
+        // real parse, #1920); the name/type are positional children.
+        const nameNode = findChild(node, 'simple_identifier');
+        const typeNode = findChild(node, 'user_type');
         if (!nameNode || !typeNode)
             return;
         const varName = extractVarName(nameNode);
@@ -393,7 +394,7 @@ const extractKotlinParameter = (node, env) => {
         nameNode = node.childForFieldName('name');
     }
     else {
-        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        nameNode = node.childForFieldName('name');
         typeNode = node.childForFieldName('type');
     }
     // Fallback: Kotlin `parameter` nodes use positional children, not named fields

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

@@ -269,7 +269,7 @@ const extractParameter = (node, env) => {
         nameNode = node.childForFieldName('name');
     }
     else {
-        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        nameNode = node.childForFieldName('name');
         typeNode = node.childForFieldName('type');
     }
     if (!nameNode || !typeNode)

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

@@ -59,7 +59,7 @@ const extractParameter = (node, env) => {
         typeNode = node.childForFieldName('type');
     }
     else {
-        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        nameNode = node.childForFieldName('name');
         typeNode = node.childForFieldName('type');
         // Python typed_parameter: name is a positional child (identifier), not a named field
         if (!nameNode && node.type === 'typed_parameter') {

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

@@ -345,8 +345,8 @@ const extractPendingAssignment = (node, scopeEnv) => {
         return undefined;
     if (rhsNode.type === 'identifier')
         return { kind: 'copy', lhs: varName, rhs: rhsNode.text };
-    // call/method_call RHS — Ruby uses method calls for both field access and method calls
-    if (rhsNode.type === 'call' || rhsNode.type === 'method_call') {
+    // call RHS — Ruby uses method calls for both field access and method calls
+    if (rhsNode.type === 'call') {
         const methodNode = rhsNode.childForFieldName('method');
         const receiverNode = rhsNode.childForFieldName('receiver');
         if (!receiverNode && methodNode?.type === 'identifier') {

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

@@ -266,16 +266,6 @@ const extractPendingAssignment = (node, scopeEnv) => {
             return { kind: 'callResult', lhs, callee: funcNode.text };
         }
     }
-    // method_call_expression RHS → methodCallResult (receiver.method())
-    if (unwrapped.type === 'method_call_expression') {
-        const obj = unwrapped.firstNamedChild;
-        if (obj?.type === 'identifier') {
-            const methodNode = unwrapped.childForFieldName('name') ?? unwrapped.namedChild(1);
-            if (methodNode?.type === 'field_identifier') {
-                return { kind: 'methodCallResult', lhs, receiver: obj.text, method: methodNode.text };
-            }
-        }
-    }
     return undefined;
 };
 /**
@@ -395,12 +385,6 @@ const extractRustElementTypeFromTypeNode = (typeNode, pos = 'last', depth = 0) =
         if (elemNode)
             return extractSimpleTypeName(elemNode);
     }
-    // slice_type: [User] — element is the first child
-    if (typeNode.type === 'slice_type') {
-        const elemNode = typeNode.firstNamedChild;
-        if (elemNode)
-            return extractSimpleTypeName(elemNode);
-    }
     return undefined;
 };
 /** Walk up from a for-loop to the enclosing function_item and search parameters

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

@@ -65,8 +65,8 @@ export declare const TYPED_PARAMETER_TYPES: Set<string>;
  * Note: Go slices/maps use slice_type/map_type, not generic_type — those are
  * NOT handled here. Use language-specific extractors for Go container types.
  *
- * @param typeNode A generic_type or parameterized_type AST node (or any node —
- *   returns [] for non-generic types).
+ * @param typeNode A generic_type / generic_name / user_type AST node (or any
+ *   node — returns [] for non-generic types).
  * @returns Array of resolved type argument names. Unresolvable arguments are omitted.
  */
 export declare const extractGenericTypeArgs: (typeNode: SyntaxNode, depth?: number) => string[];

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

@@ -204,9 +204,7 @@ 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') {
+    if (typeNode.type === 'generic_type' || typeNode.type === 'generic_name') {
         const base = typeNode.childForFieldName('name') ??
             typeNode.childForFieldName('type') ??
             typeNode.firstNamedChild;
@@ -348,17 +346,20 @@ export const TYPED_PARAMETER_TYPES = new Set([
  * Note: Go slices/maps use slice_type/map_type, not generic_type — those are
  * NOT handled here. Use language-specific extractors for Go container types.
  *
- * @param typeNode A generic_type or parameterized_type AST node (or any node —
- *   returns [] for non-generic types).
+ * @param typeNode A generic_type / generic_name / user_type AST node (or any
+ *   node — returns [] for non-generic types).
  * @returns Array of resolved type argument names. Unresolvable arguments are omitted.
  */
 export const extractGenericTypeArgs = (typeNode, depth = 0) => {
     if (depth > 50)
         return [];
-    // Unwrap wrapper nodes that may sit above the generic_type
+    // Unwrap pure wrapper nodes (which carry no type_arguments of their own) that
+    // may sit above the generic type. `user_type` is intentionally NOT unwrapped
+    // here: a Kotlin `user_type` can itself carry a `type_arguments` child
+    // (`List<User>` → user_type > [type_identifier, type_arguments]), so it is
+    // handled as a generic-bearing node below.
     if (typeNode.type === 'type_annotation' ||
         typeNode.type === 'type' ||
-        typeNode.type === 'user_type' ||
         typeNode.type === 'nullable_type' ||
         typeNode.type === 'optional_type') {
         const inner = typeNode.firstNamedChild;
@@ -366,10 +367,14 @@ export const extractGenericTypeArgs = (typeNode, depth = 0) => {
             return extractGenericTypeArgs(inner, depth + 1);
         return [];
     }
-    // Only process generic/parameterized type nodes (includes C#'s generic_name)
+    // Generic-bearing nodes hold their arguments in a `type_arguments` /
+    // `type_argument_list` child: generic_type (Java/TypeScript/Rust/Go),
+    // generic_name (C#), and Kotlin's user_type. Verified against the installed
+    // grammars by real parse (#1920). A user_type without its own type_arguments
+    // is unwrapped at the argsNode guard below.
     if (typeNode.type !== 'generic_type' &&
-        typeNode.type !== 'parameterized_type' &&
-        typeNode.type !== 'generic_name') {
+        typeNode.type !== 'generic_name' &&
+        typeNode.type !== 'user_type') {
         return [];
     }
     // Find the type_arguments / type_argument_list child
@@ -381,8 +386,17 @@ export const extractGenericTypeArgs = (typeNode, depth = 0) => {
             break;
         }
     }
-    if (!argsNode)
+    if (!argsNode) {
+        // A `user_type` without its own type_arguments wraps an inner type node
+        // (e.g. user_type > generic_type, or a plain user_type > type_identifier with
+        // no generics) — recurse into that child. generic_type / generic_name with no
+        // args simply have no type arguments to report.
+        if (typeNode.type === 'user_type') {
+            const inner = typeNode.firstNamedChild;
+            return inner ? extractGenericTypeArgs(inner, depth + 1) : [];
+        }
         return [];
+    }
     const result = [];
     for (let i = 0; i < argsNode.namedChildCount; i++) {
         let argNode = argsNode.namedChild(i);

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

@@ -27,7 +27,7 @@ function swiftNavigationSuffixName(node) {
 /** Swift: let x: Foo = ... */
 const extractDeclaration = (node, env) => {
     // Swift property_declaration has pattern and type_annotation
-    const pattern = node.childForFieldName('pattern') ?? findChild(node, 'pattern');
+    const pattern = findChild(node, 'pattern');
     const typeAnnotation = node.childForFieldName('type') ?? findChild(node, 'type_annotation');
     if (!pattern || !typeAnnotation)
         return;
@@ -41,11 +41,11 @@ const extractParameter = (node, env) => {
     let nameNode = null;
     let typeNode = null;
     if (node.type === 'parameter') {
-        nameNode = node.childForFieldName('name') ?? node.childForFieldName('internal_name');
+        nameNode = node.childForFieldName('name');
         typeNode = node.childForFieldName('type');
     }
     else {
-        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        nameNode = node.childForFieldName('name');
         typeNode = node.childForFieldName('type');
     }
     if (!nameNode || !typeNode)
@@ -65,7 +65,7 @@ const extractInitializer = (node, env, classNames) => {
     if (node.childForFieldName('type') || findChild(node, 'type_annotation'))
         return;
     // Find pattern (variable name)
-    const pattern = node.childForFieldName('pattern') ?? findChild(node, 'pattern');
+    const pattern = findChild(node, 'pattern');
     if (!pattern)
         return;
     const varName = extractVarName(pattern) ?? pattern.text;
@@ -117,7 +117,7 @@ const scanConstructorBinding = (node) => {
         return undefined;
     if (hasTypeAnnotation(node))
         return undefined;
-    const pattern = node.childForFieldName('pattern') ?? findChild(node, 'pattern');
+    const pattern = findChild(node, 'pattern');
     if (!pattern)
         return undefined;
     const varName = pattern.text;

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

@@ -25,7 +25,7 @@ export type ConstructorBindingScanner = (node: SyntaxNode) => {
 } | undefined;
 /** Infer the type name of a literal AST node for overload disambiguation.
  *  Returns the canonical type name (e.g. 'int', 'String', 'boolean') or undefined
- *  for non-literal nodes. Only used when resolveCallTarget has multiple candidates
+ *  for non-literal nodes. Only used when the call resolver has multiple candidates
  *  with parameterTypes — ~1-3% of call sites. */
 export type LiteralTypeInferrer = (node: SyntaxNode) => string | undefined;
 /** Detect constructor-style call expressions that don't use `new` keyword.

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

@@ -269,7 +269,7 @@ const findTsIterableElementType = (iterableName, startNode, pos = 'last') => {
     while (current) {
         if (TS_FUNCTION_NODE_TYPES.has(current.type)) {
             // Search function parameters
-            const paramsNode = current.childForFieldName('parameters') ?? current.childForFieldName('formal_parameters');
+            const paramsNode = current.childForFieldName('parameters');
             if (paramsNode) {
                 for (let i = 0; i < paramsNode.namedChildCount; i++) {
                     const param = paramsNode.namedChild(i);