gitnexus 1.5.3 → 1.6.1

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

@@ -1,4 +1,4 @@
-import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
+import { FUNCTION_NODE_TYPES, CLASS_CONTAINER_TYPES, genericFuncName, } from './utils/ast-helpers.js';
 import { CALL_EXPRESSION_TYPES } from './utils/call-analysis.js';
 import { TYPED_PARAMETER_TYPES } from './type-extractors/shared.js';
 import { getProvider } from './languages/index.js';
@@ -6,7 +6,21 @@ import { extractSimpleTypeName, extractVarName, stripNullable, extractReturnType
 /** File-level scope key */
 const FILE_SCOPE = '';
 /** Shared empty map for files with no file-scope bindings. */
-const EMPTY_FILE_SCOPE = new Map();
+/**
+ * Create a fresh empty Map for the "no file-scope bindings" fallback.
+ *
+ * **Why not a shared sentinel**: we previously used a module-level
+ * `const EMPTY_FILE_SCOPE = new Map()` typed as `ReadonlyMap` and shared
+ * across every TypeEnv instance. That was a latent singleton-poisoning
+ * footgun: any caller that did `(fileScope() as Map).set(...)` — or any
+ * future refactor that widened the return type — would silently corrupt
+ * every subsequent "empty" return for the process lifetime. A Proxy
+ * wrapper was considered but broke Map's internal-slot methods (`.size`,
+ * iteration protocol). Allocating a fresh empty Map per call is a few
+ * bytes per file — immediately GC'd, no measurable cost even at 10k files
+ * — and eliminates the shared-mutation hazard entirely.
+ */
+const emptyFileScope = () => new Map();
 /** Fallback for languages where class names aren't in a 'name' field (e.g. Kotlin uses type_identifier). */
 const findTypeIdentifierChild = (node) => {
     for (let i = 0; i < node.childCount; i++) {
@@ -53,7 +67,7 @@ const fastStripNullable = (typeName) => {
         : stripNullable(typeName);
 };
 /** Implementation of the lookup logic — shared between TypeEnvironment and the legacy export. */
-const lookupInEnv = (env, varName, callNode, patternOverrides, enclosingFunctionFinder) => {
+const lookupInEnv = (env, varName, callNode, patternOverrides, enclosingFunctionFinder, extractFunctionNameHook) => {
     // Self/this receiver: resolve to enclosing class name via AST walk
     if (varName === 'self' || varName === 'this' || varName === '$this') {
         return findEnclosingClassName(callNode);
@@ -64,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);
+    const scopeKey = findEnclosingScopeKey(callNode, enclosingFunctionFinder, extractFunctionNameHook);
     // 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) {
@@ -272,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) => {
+const findEnclosingScopeKey = (node, enclosingFunctionFinder, extractFunctionNameHook) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
-            const { funcName } = extractFunctionName(current);
+            const funcName = extractFunctionNameHook?.(current)?.funcName ?? genericFuncName(current);
             if (funcName)
                 return `${funcName}@${current.startIndex}`;
         }
@@ -300,10 +314,10 @@ const findEnclosingScopeKey = (node, enclosingFunctionFinder) => {
  * using cross-file type information when available.
  *
  * Only `.has()` is exposed — the SymbolTable doesn't support iteration.
- * Results are memoized to avoid redundant lookupFuzzy scans across declarations.
+ * Results are memoized to avoid redundant class-index scans across declarations.
  */
-const createClassNameLookup = (localNames, symbolTable) => {
-    if (!symbolTable)
+const createClassNameLookup = (localNames, model) => {
+    if (!model)
         return localNames;
     const memo = new Map();
     return {
@@ -313,8 +327,8 @@ const createClassNameLookup = (localNames, symbolTable) => {
             const cached = memo.get(name);
             if (cached !== undefined)
                 return cached;
-            const result = symbolTable
-                .lookupFuzzy(name)
+            const result = model.types
+                .lookupClassByName(name)
                 .some((def) => def.type === 'Class' || def.type === 'Enum' || def.type === 'Struct');
             memo.set(name, result);
             return result;
@@ -361,17 +375,16 @@ const SKIP_SUBTREE_TYPES = new Set([
     'regex_pattern',
 ]);
 const CLASS_LIKE_TYPES = new Set(['Class', 'Struct', 'Interface']);
+const lookupClassDefsByName = (model, name, allowedTypes = CLASS_LIKE_TYPES) => model.types.lookupClassByName(name).filter((d) => allowedTypes.has(d.type));
 /** Memoize class definition lookups during fixpoint iteration.
  *  SymbolTable is immutable during type resolution, so results never change.
  *  Eliminates redundant array allocations + filter scans across iterations. */
-const createClassDefCache = (symbolTable) => {
+const createClassDefCache = (model) => {
     const cache = new Map();
     return (typeName) => {
         let result = cache.get(typeName);
         if (result === undefined) {
-            result = symbolTable
-                ? symbolTable.lookupFuzzy(typeName).filter((d) => CLASS_LIKE_TYPES.has(d.type))
-                : [];
+            result = model ? lookupClassDefsByName(model, typeName) : [];
             cache.set(typeName, result);
         }
         return result;
@@ -484,60 +497,75 @@ const walkParentChain = (typeName, parentMap, getClassDefs, lookupOnClass) => {
  *  Uses SymbolTable to find the class nodeId for the receiver's type, then
  *  looks up the field via the eagerly-populated fieldByOwner index.
  *  Falls back to MRO parent chain walking if direct lookup fails (Phase 11A). */
-const resolveFieldType = (receiver, field, scopeEnv, symbolTable, getClassDefs, parentMap) => {
-    if (!symbolTable)
+const resolveFieldType = (receiver, field, scopeEnv, model, getClassDefs, parentMap) => {
+    if (!model)
         return undefined;
     const receiverType = scopeEnv.get(receiver);
     if (!receiverType)
         return undefined;
-    const lookup = getClassDefs ??
-        ((name) => symbolTable.lookupFuzzy(name).filter((d) => CLASS_LIKE_TYPES.has(d.type)));
+    const lookup = getClassDefs ?? ((name) => lookupClassDefsByName(model, name));
     const classDefs = lookup(receiverType);
     if (classDefs.length !== 1)
         return undefined;
     // Direct lookup first
-    const fieldDef = symbolTable.lookupFieldByOwner(classDefs[0].nodeId, field);
+    const fieldDef = model.fields.lookupFieldByOwner(classDefs[0].nodeId, field);
     if (fieldDef?.declaredType)
         return extractReturnTypeName(fieldDef.declaredType);
     // MRO parent chain walking on miss
     const inherited = walkParentChain(receiverType, parentMap, lookup, (nodeId) => {
-        const f = symbolTable.lookupFieldByOwner(nodeId, field);
+        const f = model.fields.lookupFieldByOwner(nodeId, field);
         return f?.declaredType ? extractReturnTypeName(f.declaredType) : undefined;
     });
     return inherited;
 };
 /** Resolve a method's return type given a receiver variable and method name.
  *  Uses SymbolTable to find class nodeIds for the receiver's type, then
- *  looks up the method via lookupFuzzyCallable filtered by ownerId.
+ *  looks up the method via owner-scoped lookupMethodByOwner.
  *  Falls back to MRO parent chain walking if direct lookup fails (Phase 11A). */
-const resolveMethodReturnType = (receiver, method, scopeEnv, symbolTable, getClassDefs, parentMap) => {
-    if (!symbolTable)
+const resolveMethodReturnType = (receiver, method, scopeEnv, model, getClassDefs, parentMap) => {
+    if (!model)
         return undefined;
-    const receiverType = scopeEnv.get(receiver);
+    let receiverType = scopeEnv.get(receiver);
+    // When substituteThisReceiver replaced $this/self with the enclosing class name,
+    // the receiver IS the type — look it up directly as a class name.
+    if (!receiverType) {
+        const lookup = getClassDefs ?? ((name) => lookupClassDefsByName(model, name));
+        if (lookup(receiver).length > 0)
+            receiverType = receiver;
+    }
     if (!receiverType)
         return undefined;
-    const lookup = getClassDefs ??
-        ((name) => symbolTable.lookupFuzzy(name).filter((d) => CLASS_LIKE_TYPES.has(d.type)));
+    const lookup = getClassDefs ?? ((name) => lookupClassDefsByName(model, name));
     const classDefs = lookup(receiverType);
     if (classDefs.length === 0)
         return undefined;
     // Direct lookup first
-    const classNodeIds = new Set(classDefs.map((d) => d.nodeId));
-    const methods = symbolTable
-        .lookupFuzzyCallable(method)
-        .filter((d) => d.ownerId && classNodeIds.has(d.ownerId));
+    const directMethodLookups = classDefs.map((d) => ({
+        classDef: d,
+        methodDef: model.methods.lookupMethodByOwner(d.nodeId, method),
+    }));
+    const hasAmbiguousDirectLookup = directMethodLookups.some(({ classDef, methodDef }) => {
+        if (methodDef)
+            return false;
+        return model.symbols
+            .lookupExactAll(classDef.filePath, method)
+            .some((d) => d.ownerId === classDef.nodeId);
+    });
+    if (hasAmbiguousDirectLookup)
+        return undefined;
+    const methods = directMethodLookups
+        .map(({ methodDef }) => methodDef)
+        .filter((d) => d !== undefined);
     if (methods.length === 1 && methods[0].returnType) {
         return extractReturnTypeName(methods[0].returnType);
     }
     // MRO parent chain walking on miss
     if (methods.length === 0) {
         const inherited = walkParentChain(receiverType, parentMap, lookup, (nodeId) => {
-            const parentMethods = symbolTable
-                .lookupFuzzyCallable(method)
-                .filter((d) => d.ownerId === nodeId);
-            if (parentMethods.length !== 1 || !parentMethods[0].returnType)
+            const parentMethod = model.methods.lookupMethodByOwner(nodeId, method);
+            if (!parentMethod?.returnType)
                 return undefined;
-            return extractReturnTypeName(parentMethods[0].returnType);
+            return extractReturnTypeName(parentMethod.returnType);
         });
         return inherited;
     }
@@ -555,10 +583,10 @@ const resolveMethodReturnType = (receiver, method, scopeEnv, symbolTable, getCla
  * Termination: finite entries, each bound at most once (first-writer-wins), max 10 iterations.
  */
 const MAX_FIXPOINT_ITERATIONS = 10;
-const resolveFixpointBindings = (pendingItems, env, returnTypeLookup, symbolTable, parentMap) => {
+const resolveFixpointBindings = (pendingItems, env, returnTypeLookup, model, parentMap) => {
     if (pendingItems.length === 0)
         return;
-    const getClassDefs = createClassDefCache(symbolTable);
+    const getClassDefs = createClassDefCache(model);
     const resolved = new Set();
     for (let iter = 0; iter < MAX_FIXPOINT_ITERATIONS; iter++) {
         let changed = false;
@@ -583,10 +611,10 @@ const resolveFixpointBindings = (pendingItems, env, returnTypeLookup, symbolTabl
                     typeName = scopeEnv.get(item.rhs) ?? env.get(FILE_SCOPE)?.get(item.rhs);
                     break;
                 case 'fieldAccess':
-                    typeName = resolveFieldType(item.receiver, item.field, scopeEnv, symbolTable, getClassDefs, parentMap);
+                    typeName = resolveFieldType(item.receiver, item.field, scopeEnv, model, getClassDefs, parentMap);
                     break;
                 case 'methodCallResult':
-                    typeName = resolveMethodReturnType(item.receiver, item.method, scopeEnv, symbolTable, getClassDefs, parentMap);
+                    typeName = resolveMethodReturnType(item.receiver, item.method, scopeEnv, model, getClassDefs, parentMap);
                     break;
                 default: {
                     // Exhaustive check: TypeScript will error here if a new PendingAssignment
@@ -630,50 +658,68 @@ export const buildTypeEnv = (tree, language, options) => {
     // Clear per-file memoization caches from the previous file.
     enclosingClassNameCache.clear();
     enclosingParentClassNameCache.clear();
-    const symbolTable = options?.symbolTable;
+    const model = options?.model;
     const parentMap = options?.parentMap;
+    const extractFuncNameHook = options?.extractFunctionName;
     const env = new Map();
+    let flushed = false;
     const patternOverrides = new Map();
     // Phase P: maps `scope\0varName` → constructor type when a declaration has BOTH
     // a base type annotation AND a more specific constructor initializer.
     // e.g., `Animal a = new Dog()` → constructorTypeMap.set('func@42\0a', 'Dog')
     const constructorTypeMap = new Map();
     const localClassNames = new Set();
-    const classNames = createClassNameLookup(localClassNames, symbolTable);
+    const classNames = createClassNameLookup(localClassNames, model);
     const provider = getProvider(language);
     const config = provider.typeConfig;
     const bindings = [];
     // Build ReturnTypeLookup: SymbolTable is authoritative when it has an unambiguous match.
     // Cross-file importedReturnTypes are consulted ONLY when SymbolTable has 0 matches.
     // Ambiguous (2+) → undefined, no cross-file fallback (conservative, local-first principle).
+    // Post-A4 Unit 4: callableByName no longer holds Method/Constructor, so
+    // for-loop binding inference must also consult methodsByName to find
+    // return types on class methods (e.g. `user.getItems()` iteration).
+    // Take `model` as an explicit argument so the non-null precondition
+    // is visible at the type level. Callers must enter these via an
+    // `if (model)` guard on their side and pass the narrowed reference.
+    const getCallableUnionCount = (m, callee) => {
+        return (m.symbols.lookupCallableByName(callee).length + m.methods.lookupMethodByName(callee).length);
+    };
+    const getFirstCallable = (m, callee) => {
+        const free = m.symbols.lookupCallableByName(callee);
+        if (free.length > 0)
+            return free[0];
+        const methods = m.methods.lookupMethodByName(callee);
+        return methods.length > 0 ? methods[0] : undefined;
+    };
     const returnTypeLookup = {
         lookupReturnType(callee) {
             // SymbolTable is authoritative when it has an unambiguous match
-            if (symbolTable) {
+            if (model) {
                 if (provider.isBuiltInName(callee))
                     return undefined;
-                const callables = symbolTable.lookupFuzzyCallable(callee);
-                if (callables.length === 1) {
-                    const rawReturn = callables[0].returnType;
+                const count = getCallableUnionCount(model, callee);
+                if (count === 1) {
+                    const rawReturn = getFirstCallable(model, callee)?.returnType;
                     if (rawReturn)
                         return extractReturnTypeName(rawReturn);
                 }
                 // Ambiguous (2+) → return undefined (conservative, no cross-file fallback)
-                if (callables.length > 1)
+                if (count > 1)
                     return undefined;
             }
             // No match (0 results or no symbolTable) → fall back to cross-file
             return options?.importedReturnTypes?.get(callee);
         },
         lookupRawReturnType(callee) {
-            if (symbolTable) {
+            if (model) {
                 if (provider.isBuiltInName(callee))
                     return undefined;
-                const callables = symbolTable.lookupFuzzyCallable(callee);
-                if (callables.length === 1)
-                    return callables[0].returnType;
+                const count = getCallableUnionCount(model, callee);
+                if (count === 1)
+                    return getFirstCallable(model, callee)?.returnType;
                 // Ambiguous (2+) → return undefined (conservative, no cross-file fallback)
-                if (callables.length > 1)
+                if (count > 1)
                     return undefined;
             }
             // Cross-file fallback uses importedRawReturnTypes (raw declared types, e.g., 'User[]')
@@ -789,47 +835,18 @@ export const buildTypeEnv = (tree, language, options) => {
             // This decouples type node capture from scopeEnv success — container types
             // (User[], []User, List[User]) that fail extractSimpleTypeName still get
             // their AST type node recorded for Strategy 1 for-loop resolution.
-            // Try direct extraction first (works for Go var_spec, Python assignment, Rust let_declaration).
-            // Try direct type field first, then unwrap wrapper nodes (C# field_declaration,
-            // local_declaration_statement wrap their type inside a variable_declaration child).
-            let typeNode = node.childForFieldName('type');
+            //
+            // Prefer language-specific locator when provided (keeps buildTypeEnv generic),
+            // then fall back to a small set of safe, cross-grammar heuristics.
+            let typeNode = config.getDeclarationTypeNode?.(node) ?? node.childForFieldName('type') ?? null;
+            // Fallback: some grammars wrap type annotations in a `type_annotation` child
+            // instead of exposing a named `type` field on the declaration node.
             if (!typeNode) {
-                // C# field_declaration / local_declaration_statement wrap type inside variable_declaration.
-                // Use manual loop instead of namedChildren.find() to avoid array allocation on hot path.
-                let wrapped = node.childForFieldName('declaration');
-                if (!wrapped) {
-                    for (let i = 0; i < node.namedChildCount; i++) {
-                        const c = node.namedChild(i);
-                        if (c?.type === 'variable_declaration') {
-                            wrapped = c;
-                            break;
-                        }
-                    }
-                }
-                if (wrapped) {
-                    typeNode = wrapped.childForFieldName('type');
-                    // Kotlin: variable_declaration stores the type as user_type / nullable_type
-                    // child rather than a named 'type' field.
-                    if (!typeNode) {
-                        for (let i = 0; i < wrapped.namedChildCount; i++) {
-                            const c = wrapped.namedChild(i);
-                            if (c && (c.type === 'user_type' || c.type === 'nullable_type')) {
-                                typeNode = c;
-                                break;
-                            }
-                        }
-                    }
-                }
-                // Swift: property_declaration has type_annotation as a direct child (not a 'type' field).
-                // Extract the inner type node (array_type, user_type, etc.) for declarationTypeNodes.
-                if (!typeNode) {
-                    for (let i = 0; i < node.namedChildCount; i++) {
-                        const c = node.namedChild(i);
-                        if (c?.type === 'type_annotation') {
-                            // Use the inner type (array_type, user_type) rather than the annotation wrapper
-                            typeNode = c.firstNamedChild ?? c;
-                            break;
-                        }
+                for (let i = 0; i < node.namedChildCount; i++) {
+                    const c = node.namedChild(i);
+                    if (c?.type === 'type_annotation') {
+                        typeNode = c.firstNamedChild ?? c;
+                        break;
                     }
                 }
             }
@@ -900,7 +917,10 @@ export const buildTypeEnv = (tree, language, options) => {
             }
         }
     };
-    const walk = (node, currentScope) => {
+    const stack = [
+        { node: tree.rootNode, scope: FILE_SCOPE },
+    ];
+    const processNode = (node, currentScope) => {
         // Fast skip: subtrees that can never contain type-relevant nodes (leaf-like literals).
         if (SKIP_SUBTREE_TYPES.has(node.type))
             return;
@@ -916,7 +936,7 @@ export const buildTypeEnv = (tree, language, options) => {
         // Detect scope boundaries (function/method definitions)
         let scope = currentScope;
         if (FUNCTION_NODE_TYPES.has(node.type)) {
-            const { funcName } = extractFunctionName(node);
+            const funcName = extractFuncNameHook?.(node)?.funcName ?? genericFuncName(node);
             if (funcName)
                 scope = `${funcName}@${node.startIndex}`;
         }
@@ -1014,20 +1034,25 @@ export const buildTypeEnv = (tree, language, options) => {
                 }
             }
         }
-        // Recurse into children
-        for (let i = 0; i < node.childCount; i++) {
+        // Push children onto stack (reverse order so first child is processed first)
+        for (let i = node.childCount - 1; i >= 0; i--) {
             const child = node.child(i);
             if (child)
-                walk(child, scope);
+                stack.push({ node: child, scope });
         }
     };
-    walk(tree.rootNode, FILE_SCOPE);
+    // Iterative traversal using explicit stack instead of recursion
+    // to avoid "Maximum call stack size exceeded" on large files (2000+ lines)
+    while (stack.length > 0) {
+        const { node, scope } = stack.pop();
+        processNode(node, scope);
+    }
     // Phase 14: Seed cross-file bindings from upstream files AFTER walk
     // (local declarations from walk() take precedence — first-writer-wins)
     if (options?.importedBindings && options.importedBindings.size > 0) {
         seedImportedBindings(env, options.importedBindings);
     }
-    resolveFixpointBindings(pendingItems, env, returnTypeLookup, symbolTable, parentMap);
+    resolveFixpointBindings(pendingItems, env, returnTypeLookup, model, parentMap);
     // Post-fixpoint for-loop replay (Phase 10 / ex-9B loop-fixpoint bridge):
     // For-loop nodes whose iterables were unresolved at walk-time may now be
     // resolvable because the fixpoint bound the iterable's type.
@@ -1054,14 +1079,50 @@ export const buildTypeEnv = (tree, language, options) => {
             return scopeEnv && !scopeEnv.has(item.lhs);
         });
         if (unresolvedBefore.length > 0) {
-            resolveFixpointBindings(unresolvedBefore, env, returnTypeLookup, symbolTable);
+            resolveFixpointBindings(unresolvedBefore, env, returnTypeLookup, model);
         }
     }
     return {
-        lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides, options?.enclosingFunctionFinder),
+        lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides, options?.enclosingFunctionFinder, extractFuncNameHook),
         constructorBindings: bindings,
-        fileScope: () => env.get(FILE_SCOPE) ?? EMPTY_FILE_SCOPE,
+        fileScope: () => env.get(FILE_SCOPE) ?? emptyFileScope(),
         allScopes: () => env,
         constructorTypeMap,
+        flush(filePath, accumulator) {
+            if (flushed) {
+                throw new Error(`[TypeEnvironment] flush called twice for ${filePath} — flush is single-use`);
+            }
+            // Narrow flush() to iterate only the FILE_SCOPE entry, mirroring the
+            // worker-path narrowing in parse-worker.ts (commit 803631fe). Before
+            // this change, both execution paths had the same asymmetry bug: the
+            // worker path was fixed but the sequential path (this code) still
+            // wrote function-scope entries into long-lived accumulator storage
+            // that no consumer reads until Phase 9 lands.
+            //
+            // Phase 9 reversion: when a downstream consumer of function-scope
+            // bindings exists, restore the nested iteration:
+            //
+            //   for (const [scope, scopeMap] of env) {
+            //     for (const [varName, typeName] of scopeMap) {
+            //       entries.push({ scope, varName, typeName });
+            //     }
+            //   }
+            //
+            // See BindingAccumulator class JSDoc and FileScopeBindings JSDoc in
+            // parse-worker.ts for the full reversion checklist.
+            const fileScope = env.get(FILE_SCOPE) ?? emptyFileScope();
+            const entries = [];
+            for (const [varName, typeName] of fileScope) {
+                entries.push({ scope: '', varName, typeName });
+            }
+            if (entries.length > 0) {
+                accumulator.appendFile(filePath, entries);
+            }
+            // Mark the env as flushed AFTER the successful append. If appendFile
+            // throws (e.g., accumulator is already finalized due to a lifecycle
+            // ordering bug), the caller can catch and retry — the single-use
+            // guard now tracks "data was written", not "flush was attempted".
+            flushed = true;
+        },
     };
 };

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

@@ -549,6 +549,23 @@ const inferLiteralType = (node) => {
 };
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
+    getDeclarationTypeNode: (node) => {
+        // C# field_declaration / local_declaration_statement wrap type inside variable_declaration.
+        // Prefer the wrapper node's `type` field when present.
+        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;
+            })();
+        return wrapped?.childForFieldName('type') ?? null;
+    },
     forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
     patternBindingNodeTypes: new Set([
         'is_pattern_expression',

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

@@ -831,6 +831,17 @@ const extractKotlinPatternBinding = (node, scopeEnv, declarationTypeNodes, scope
 export const kotlinTypeConfig = {
     allowPatternBindingOverwrite: true,
     declarationNodeTypes: KOTLIN_DECLARATION_NODE_TYPES,
+    getDeclarationTypeNode: (node) => {
+        // Kotlin property_declaration wraps the actual declaration in variable_declaration.
+        // The type is commonly a user_type / nullable_type child (positional, not 'type' field).
+        const varDecl = node.type === 'property_declaration' ? findChild(node, 'variable_declaration') : node;
+        if (varDecl) {
+            return (varDecl.childForFieldName('type') ??
+                findChild(varDecl, 'user_type') ??
+                findChild(varDecl, 'nullable_type'));
+        }
+        return node.childForFieldName('type') ?? findChild(node, 'user_type') ?? null;
+    },
     forLoopNodeTypes: KOTLIN_FOR_LOOP_NODE_TYPES,
     patternBindingNodeTypes: new Set(['type_test', 'equality_expression']),
     extractDeclaration: extractKotlinDeclaration,

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

@@ -323,60 +323,6 @@ const scanConstructorBinding = (node) => {
     }
     return undefined;
 };
-/** Regex to extract PHPDoc @return annotations: `@return User` */
-const PHPDOC_RETURN_RE = /@return\s+(\S+)/;
-/**
- * Normalize a PHPDoc return type for storage in the SymbolTable.
- * Unlike normalizePhpType (which strips User[] → User for scopeEnv), this preserves
- * array notation so lookupRawReturnType can extract element types for for-loop resolution.
- *   \App\Models\User[] → User[]
- *   ?User → User
- *   Collection<User> → Collection<User>  (preserved for extractElementTypeFromString)
- */
-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');
-    if (parts.length !== 1)
-        return undefined;
-    type = parts[0];
-    // Strip namespace: \App\Models\User[] → User[]
-    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')
-        return undefined;
-    if (/^\w+(\[\])?$/.test(type) || /^\w+\s*</.test(type))
-        return type;
-    return undefined;
-};
-/**
- * Extract return type from PHPDoc `@return Type` annotation preceding a method.
- * Walks backwards through preceding siblings looking for comment nodes.
- * Preserves array notation (e.g., User[]) for for-loop element type extraction.
- */
-const extractReturnType = (node) => {
-    let sibling = node.previousSibling;
-    while (sibling) {
-        if (sibling.type === 'comment') {
-            const match = PHPDOC_RETURN_RE.exec(sibling.text);
-            if (match)
-                return normalizePhpReturnType(match[1]);
-        }
-        else if (sibling.isNamed && !SKIP_NODE_TYPES.has(sibling.type))
-            break;
-        sibling = sibling.previousSibling;
-    }
-    return undefined;
-};
 /** PHP: $alias = $user → assignment_expression with variable_name left/right.
  *  PHP TypeEnv stores variables WITH $ prefix ($user → User), so we keep $ in lhs/rhs. */
 const extractPendingAssignment = (node, scopeEnv) => {
@@ -583,7 +529,6 @@ export const typeConfig = {
     extractParameter,
     extractInitializer,
     scanConstructorBinding,
-    extractReturnType,
     extractForLoopBinding,
     extractPendingAssignment,
 };

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

@@ -23,8 +23,6 @@ import { extractRubyConstructorAssignment, extractSimpleTypeName, extractElement
 const YARD_PARAM_RE = /@param\s+(\w+)\s+\[([^\]]+)\]/g;
 /** Alternate YARD order: `@param [Type] name` */
 const YARD_PARAM_ALT_RE = /@param\s+\[([^\]]+)\]\s+(\w+)/g;
-/** Regex to extract @return annotations: `@return [Type]` */
-const YARD_RETURN_RE = /@return\s+\[([^\]]+)\]/;
 /**
  * Extract the simple type name from a YARD type string.
  * Handles:
@@ -190,35 +188,6 @@ const extractInitializer = (node, env, classNames) => {
         env.set(result.varName, result.calleeName);
     }
 };
-/**
- * Extract return type from YARD `@return [Type]` annotation preceding a method.
- * Reuses the same comment-walking strategy as collectYardParams: try direct
- * siblings first, fall back to parent (body_statement) siblings for class methods.
- */
-const extractReturnType = (node) => {
-    const search = (startNode) => {
-        let sibling = startNode.previousSibling;
-        while (sibling) {
-            if (sibling.type === 'comment') {
-                const match = YARD_RETURN_RE.exec(sibling.text);
-                if (match)
-                    return extractYardTypeName(match[1]);
-            }
-            else if (sibling.isNamed) {
-                break;
-            }
-            sibling = sibling.previousSibling;
-        }
-        return undefined;
-    };
-    const result = search(node);
-    if (result)
-        return result;
-    if (node.parent?.type === 'body_statement') {
-        return search(node.parent);
-    }
-    return undefined;
-};
 /**
  * Ruby constructor binding scanner: captures both `user = User.new` and
  * plain call assignments like `user = get_user()`.
@@ -403,7 +372,6 @@ export const typeConfig = {
     extractParameter,
     extractInitializer,
     scanConstructorBinding,
-    extractReturnType,
     extractForLoopBinding,
     extractPendingAssignment,
 };

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

@@ -461,6 +461,19 @@ function extractSwiftElementTypeFromTypeNode(typeNode) {
 }
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
+    getDeclarationTypeNode: (node) => {
+        // Swift: many declarations store type as a type_annotation child (not a 'type' field).
+        // Prefer a direct 'type' field if present, else unwrap type_annotation to its inner type.
+        const direct = node.childForFieldName('type');
+        if (direct)
+            return direct;
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (c?.type === 'type_annotation')
+                return c.firstNamedChild ?? c;
+        }
+        return null;
+    },
     forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
     extractDeclaration,
     extractParameter,