gitnexus 1.4.8 → 1.4.10

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

@@ -1,8 +1,12 @@
-import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES, CALL_EXPRESSION_TYPES, isBuiltInOrNoise } from './utils.js';
-import { typeConfigs, TYPED_PARAMETER_TYPES } from './type-extractors/index.js';
+import { FUNCTION_NODE_TYPES, extractFunctionName, CLASS_CONTAINER_TYPES } 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';
 import { extractSimpleTypeName, extractVarName, stripNullable, extractReturnTypeName } from './type-extractors/shared.js';
 /** File-level scope key */
 const FILE_SCOPE = '';
+/** Shared empty map for files with no file-scope bindings. */
+const EMPTY_FILE_SCOPE = 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++) {
@@ -49,7 +53,7 @@ const fastStripNullable = (typeName) => {
         : stripNullable(typeName);
 };
 /** Implementation of the lookup logic — shared between TypeEnvironment and the legacy export. */
-const lookupInEnv = (env, varName, callNode, patternOverrides) => {
+const lookupInEnv = (env, varName, callNode, patternOverrides, enclosingFunctionFinder) => {
     // Self/this receiver: resolve to enclosing class name via AST walk
     if (varName === 'self' || varName === 'this' || varName === '$this') {
         return findEnclosingClassName(callNode);
@@ -60,7 +64,7 @@ const lookupInEnv = (env, varName, callNode, patternOverrides) => {
         return findEnclosingParentClassName(callNode);
     }
     // Determine the enclosing function scope for the call
-    const scopeKey = findEnclosingScopeKey(callNode);
+    const scopeKey = findEnclosingScopeKey(callNode, enclosingFunctionFinder);
     // 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) {
@@ -88,21 +92,31 @@ const lookupInEnv = (env, varName, callNode, patternOverrides) => {
     const raw = fileEnv?.get(varName);
     return raw ? fastStripNullable(raw) : undefined;
 };
+/** Per-file memoization caches for expensive parent-walk functions.
+ *  Cleared at the start of each buildTypeEnv call (one call per file). */
+const enclosingClassNameCache = new Map();
+const enclosingParentClassNameCache = new Map();
 /**
  * Walk up the AST from a node to find the enclosing class/module name.
  * Used to resolve `self`/`this` receivers to their containing type.
+ * Memoized per-file: cache is cleared at buildTypeEnv entry.
  */
 const findEnclosingClassName = (node) => {
+    if (enclosingClassNameCache.has(node))
+        return enclosingClassNameCache.get(node);
     let current = node.parent;
     while (current) {
         if (CLASS_CONTAINER_TYPES.has(current.type)) {
             const nameNode = current.childForFieldName('name')
                 ?? findTypeIdentifierChild(current);
-            if (nameNode)
+            if (nameNode) {
+                enclosingClassNameCache.set(node, nameNode.text);
                 return nameNode.text;
+            }
         }
         current = current.parent;
     }
+    enclosingClassNameCache.set(node, undefined);
     return undefined;
 };
 /** Keywords that refer to the current instance across languages. */
@@ -138,13 +152,18 @@ const substituteThisReceiver = (item, node) => {
  * - Swift: unnamed `inheritance_specifier` child → user_type → type_identifier
  */
 const findEnclosingParentClassName = (node) => {
+    if (enclosingParentClassNameCache.has(node))
+        return enclosingParentClassNameCache.get(node);
     let current = node.parent;
     while (current) {
         if (CLASS_CONTAINER_TYPES.has(current.type)) {
-            return extractParentClassFromNode(current);
+            const result = extractParentClassFromNode(current);
+            enclosingParentClassNameCache.set(node, result);
+            return result;
         }
         current = current.parent;
     }
+    enclosingParentClassNameCache.set(node, undefined);
     return undefined;
 };
 /** Extract the parent/superclass name from a class declaration AST node. */
@@ -251,8 +270,12 @@ const extractParentClassFromNode = (classNode) => {
     }
     return undefined;
 };
-/** Find the enclosing function name for scope lookup. */
-const findEnclosingScopeKey = (node) => {
+/** Find the enclosing function name for scope lookup.
+ *  When an `enclosingFunctionFinder` hook is provided (from the language provider),
+ *  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) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
@@ -260,6 +283,15 @@ const findEnclosingScopeKey = (node) => {
             if (funcName)
                 return `${funcName}@${current.startIndex}`;
         }
+        // Language-specific hook (e.g., Dart function_body → sibling function_signature)
+        if (enclosingFunctionFinder) {
+            const result = enclosingFunctionFinder(current);
+            if (result) {
+                const sigNode = current.previousSibling;
+                const startIdx = sigNode?.startIndex ?? current.startIndex;
+                return `${result.funcName}@${startIdx}`;
+            }
+        }
         current = current.parent;
     }
     return undefined;
@@ -530,7 +562,10 @@ const resolveFixpointBindings = (pendingItems, env, returnTypeLookup, symbolTabl
             let typeName;
             switch (item.kind) {
                 case 'callResult':
-                    typeName = returnTypeLookup.lookupReturnType(item.callee);
+                    // Phase 9: Prefer FQN lookup when available for higher precision
+                    typeName = item.calleeFqn
+                        ? returnTypeLookup.lookupReturnType(item.calleeFqn)
+                        : returnTypeLookup.lookupReturnType(item.callee);
                     break;
                 case 'copy':
                     typeName = scopeEnv.get(item.rhs) ?? env.get(FILE_SCOPE)?.get(item.rhs);
@@ -580,6 +615,9 @@ function seedImportedBindings(env, importedBindings) {
     }
 }
 export const buildTypeEnv = (tree, language, options) => {
+    // Clear per-file memoization caches from the previous file.
+    enclosingClassNameCache.clear();
+    enclosingParentClassNameCache.clear();
     const symbolTable = options?.symbolTable;
     const parentMap = options?.parentMap;
     const env = new Map();
@@ -590,7 +628,8 @@ export const buildTypeEnv = (tree, language, options) => {
     const constructorTypeMap = new Map();
     const localClassNames = new Set();
     const classNames = createClassNameLookup(localClassNames, symbolTable);
-    const config = typeConfigs[language];
+    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.
@@ -599,7 +638,7 @@ export const buildTypeEnv = (tree, language, options) => {
         lookupReturnType(callee) {
             // SymbolTable is authoritative when it has an unambiguous match
             if (symbolTable) {
-                if (isBuiltInOrNoise(callee))
+                if (provider.isBuiltInName(callee))
                     return undefined;
                 const callables = symbolTable.lookupFuzzyCallable(callee);
                 if (callables.length === 1) {
@@ -616,7 +655,7 @@ export const buildTypeEnv = (tree, language, options) => {
         },
         lookupRawReturnType(callee) {
             if (symbolTable) {
-                if (isBuiltInOrNoise(callee))
+                if (provider.isBuiltInName(callee))
                     return undefined;
                 const callables = symbolTable.lookupFuzzyCallable(callee);
                 if (callables.length === 1)
@@ -760,6 +799,18 @@ export const buildTypeEnv = (tree, language, options) => {
                         }
                     }
                 }
+                // 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;
+                        }
+                    }
+                }
             }
             if (typeNode) {
                 const nameNode = node.childForFieldName('name')
@@ -982,9 +1033,10 @@ export const buildTypeEnv = (tree, language, options) => {
         }
     }
     return {
-        lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides),
+        lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides, options?.enclosingFunctionFinder),
         constructorBindings: bindings,
-        env,
+        fileScope: () => env.get(FILE_SCOPE) ?? EMPTY_FILE_SCOPE,
+        allScopes: () => env,
         constructorTypeMap,
     };
 };

package/dist/core/ingestion/type-extractors/c-cpp.d.ts

@@ -1,4 +1,4 @@
-import type { SyntaxNode } from '../utils.js';
+import type { SyntaxNode } from '../utils/ast-helpers.js';
 import type { LanguageTypeConfig } from './types.js';
 /** Extract the first type name from a template_argument_list child.
  *  Unwraps type_descriptor wrappers common in tree-sitter-cpp ASTs.

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

@@ -1,5 +1,5 @@
+import { findChild } from '../utils/ast-helpers.js';
 import { extractSimpleTypeName, extractVarName, unwrapAwait, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.js';
-import { findChild } from '../resolvers/utils.js';
 /** Known container property accessors that operate on the container itself (e.g., dict.Keys, dict.Values) */
 const KNOWN_CONTAINER_PROPS = new Set(['Keys', 'Values']);
 const DECLARATION_NODE_TYPES = new Set([

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

@@ -0,0 +1,15 @@
+/**
+ * Dart type extractor — full implementation following type-resolution-system.md.
+ *
+ * Tier 0: Explicit type annotations (User user = ...)
+ * Tier 0b: For-loop element types (for (var u in users))
+ * Tier 1: Constructor/initializer inference (var user = User())
+ * Tier 2: Assignment chain propagation (copy, fieldAccess, callResult, methodCallResult)
+ *
+ * Handles tree-sitter-dart's flat sibling AST structure:
+ * identifier + selector + selector (not nested call_expression).
+ *
+ * Credit: Type resolution approach adapted from @xFlaviews' PR #83.
+ */
+import type { LanguageTypeConfig } from './types.js';
+export declare const typeConfig: LanguageTypeConfig;

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

@@ -0,0 +1,371 @@
+/**
+ * Dart type extractor — full implementation following type-resolution-system.md.
+ *
+ * Tier 0: Explicit type annotations (User user = ...)
+ * Tier 0b: For-loop element types (for (var u in users))
+ * Tier 1: Constructor/initializer inference (var user = User())
+ * Tier 2: Assignment chain propagation (copy, fieldAccess, callResult, methodCallResult)
+ *
+ * Handles tree-sitter-dart's flat sibling AST structure:
+ * identifier + selector + selector (not nested call_expression).
+ *
+ * Credit: Type resolution approach adapted from @xFlaviews' PR #83.
+ */
+import { extractSimpleTypeName, extractVarName, extractElementTypeFromString, resolveIterableElementType } from './shared.js';
+import { findChild } from '../utils/ast-helpers.js';
+// ── Node types ──────────────────────────────────────────────────────────
+const DART_DECLARATION_NODE_TYPES = new Set([
+    'initialized_variable_definition',
+    'initialized_identifier',
+]);
+const DART_FOR_LOOP_NODE_TYPES = new Set([
+    'for_statement',
+]);
+function parseDartRHSChildren(children) {
+    let callee;
+    let member;
+    let hasCall = false;
+    for (const child of children) {
+        if (child.type === 'identifier' && !callee) {
+            callee = child.text;
+            continue;
+        }
+        if (child.type === 'selector') {
+            const uas = findChild(child, 'unconditional_assignable_selector')
+                ?? findChild(child, 'conditional_assignable_selector');
+            if (uas) {
+                const id = findChild(uas, 'identifier');
+                if (id && !member)
+                    member = id.text;
+                continue;
+            }
+            if (findChild(child, 'argument_part')) {
+                hasCall = true;
+                continue;
+            }
+        }
+    }
+    return { callee, member, hasCall };
+}
+function parseDartRHS(node) {
+    const rhsChildren = [];
+    let foundEquals = false;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        if (!child.isNamed && child.text === '=') {
+            foundEquals = true;
+            continue;
+        }
+        if (foundEquals)
+            rhsChildren.push(child);
+    }
+    if (rhsChildren.length === 0)
+        return { hasCall: false, isAwait: false };
+    const first = rhsChildren[0];
+    if (first.type === 'unary_expression') {
+        const awaitExpr = findChild(first, 'await_expression');
+        if (awaitExpr) {
+            const innerChildren = [];
+            for (let i = 0; i < awaitExpr.namedChildCount; i++) {
+                const c = awaitExpr.namedChild(i);
+                if (c && c.type !== 'await')
+                    innerChildren.push(c);
+            }
+            return { ...parseDartRHSChildren(innerChildren), isAwait: true };
+        }
+    }
+    return { ...parseDartRHSChildren(rhsChildren), isAwait: false };
+}
+function hasDartTypeAnnotation(node) {
+    return !!(findChild(node, 'type_identifier') || findChild(node, 'nullable_type'));
+}
+// ── Tier 0: Explicit Type Annotations ───────────────────────────────────
+const extractDartDeclaration = (node, env) => {
+    // initialized_identifier: comma-separated variable (String a, b, c) — type is on parent
+    if (node.type === 'initialized_identifier') {
+        const parent = node.parent;
+        if (!parent)
+            return;
+        let typeNode = findChild(parent, 'type_identifier');
+        if (!typeNode) {
+            const nullable = findChild(parent, 'nullable_type');
+            if (nullable)
+                typeNode = findChild(nullable, 'type_identifier');
+        }
+        if (!typeNode)
+            return;
+        const typeName = extractSimpleTypeName(typeNode);
+        if (!typeName || typeName === 'dynamic')
+            return;
+        const nameNode = findChild(node, 'identifier');
+        if (!nameNode)
+            return;
+        const varName = extractVarName(nameNode);
+        if (varName)
+            env.set(varName, typeName);
+        return;
+    }
+    let typeNode = findChild(node, 'type_identifier');
+    if (!typeNode) {
+        const nullable = findChild(node, 'nullable_type');
+        if (nullable)
+            typeNode = findChild(nullable, 'type_identifier');
+    }
+    if (!typeNode)
+        return;
+    const typeName = extractSimpleTypeName(typeNode);
+    if (!typeName || typeName === 'dynamic')
+        return;
+    const nameNode = node.childForFieldName('name');
+    if (!nameNode)
+        return;
+    const varName = extractVarName(nameNode);
+    if (varName)
+        env.set(varName, typeName);
+};
+const extractDartParameter = (node, env) => {
+    let typeNode = findChild(node, 'type_identifier');
+    if (!typeNode) {
+        const nullable = findChild(node, 'nullable_type');
+        if (nullable)
+            typeNode = findChild(nullable, 'type_identifier');
+    }
+    if (!typeNode)
+        return;
+    const typeName = extractSimpleTypeName(typeNode);
+    if (!typeName || typeName === 'dynamic')
+        return;
+    const nameNode = node.childForFieldName('name');
+    if (!nameNode)
+        return;
+    const varName = extractVarName(nameNode);
+    if (varName)
+        env.set(varName, typeName);
+};
+// ── Tier 1: Constructor / Initializer Inference ─────────────────────────
+const extractDartInitializer = (node, env, classNames) => {
+    if (node.type !== 'initialized_variable_definition')
+        return;
+    if (hasDartTypeAnnotation(node))
+        return;
+    const nameNode = node.childForFieldName('name');
+    if (!nameNode)
+        return;
+    const varName = extractVarName(nameNode);
+    if (!varName || env.has(varName))
+        return;
+    const rhs = parseDartRHS(node);
+    if (!rhs.callee || !rhs.hasCall)
+        return;
+    if (!rhs.member && classNames.has(rhs.callee)) {
+        env.set(varName, rhs.callee);
+        return;
+    }
+    if (rhs.member && classNames.has(rhs.callee)) {
+        env.set(varName, rhs.callee);
+    }
+};
+// ── Constructor Binding Scan ────────────────────────────────────────────
+const scanDartConstructorBinding = (node) => {
+    if (node.type !== 'initialized_variable_definition')
+        return undefined;
+    if (hasDartTypeAnnotation(node))
+        return undefined;
+    const nameNode = node.childForFieldName('name');
+    if (!nameNode)
+        return undefined;
+    const varName = nameNode.text;
+    if (!varName)
+        return undefined;
+    const rhs = parseDartRHS(node);
+    if (!rhs.callee)
+        return undefined;
+    if (rhs.hasCall && !rhs.member)
+        return { varName, calleeName: rhs.callee };
+    if (rhs.hasCall && rhs.member)
+        return { varName, calleeName: rhs.member };
+    return undefined;
+};
+// ── Virtual Dispatch ────────────────────────────────────────────────────
+const detectDartConstructorType = (node, classNames) => {
+    if (node.type !== 'initialized_variable_definition')
+        return undefined;
+    const rhs = parseDartRHS(node);
+    if (!rhs.callee || !rhs.hasCall)
+        return undefined;
+    if (!rhs.member && classNames.has(rhs.callee))
+        return rhs.callee;
+    if (rhs.member && classNames.has(rhs.callee))
+        return rhs.callee;
+    return undefined;
+};
+// ── Literal Type Inference ──────────────────────────────────────────────
+const inferDartLiteralType = (node) => {
+    switch (node.type) {
+        case 'decimal_integer_literal':
+        case 'hex_integer_literal':
+            return 'int';
+        case 'decimal_floating_point_literal':
+            return 'double';
+        case 'string_literal':
+            return 'String';
+        case 'true':
+        case 'false':
+            return 'bool';
+        case 'null_literal':
+            return 'null';
+        default:
+            return undefined;
+    }
+};
+// ── Tier 2: Assignment Chain Propagation ─────────────────────────────────
+const extractDartPendingAssignment = (node, scopeEnv) => {
+    if (node.type !== 'initialized_variable_definition')
+        return undefined;
+    if (hasDartTypeAnnotation(node))
+        return undefined;
+    const nameNode = node.childForFieldName('name');
+    if (!nameNode)
+        return undefined;
+    const lhs = nameNode.text;
+    if (!lhs || scopeEnv.has(lhs))
+        return undefined;
+    const rhs = parseDartRHS(node);
+    if (!rhs.callee)
+        return undefined;
+    if (!rhs.hasCall && !rhs.member)
+        return { kind: 'copy', lhs, rhs: rhs.callee };
+    if (!rhs.hasCall && rhs.member)
+        return { kind: 'fieldAccess', lhs, receiver: rhs.callee, field: rhs.member };
+    if (rhs.hasCall && !rhs.member)
+        return { kind: 'callResult', lhs, callee: rhs.callee };
+    if (rhs.hasCall && rhs.member)
+        return { kind: 'methodCallResult', lhs, receiver: rhs.callee, method: rhs.member };
+    return undefined;
+};
+// ── For-Loop Element Type Resolution ────────────────────────────────────
+function extractDartElementTypeFromTypeNode(typeNode) {
+    if (typeNode.type === 'type_identifier') {
+        const parent = typeNode.parent;
+        if (parent) {
+            const args = findChild(parent, 'type_arguments');
+            if (args && args.namedChildCount >= 1) {
+                const lastArg = args.namedChild(args.namedChildCount - 1);
+                if (lastArg)
+                    return extractSimpleTypeName(lastArg);
+            }
+        }
+    }
+    return undefined;
+}
+const extractDartForLoopBinding = (node, ctx) => {
+    if (node.type !== 'for_statement')
+        return;
+    const { scopeEnv, declarationTypeNodes, scope, returnTypeLookup } = ctx;
+    const loopParts = findChild(node, 'for_loop_parts');
+    if (!loopParts)
+        return;
+    const nameNode = loopParts.childForFieldName('name');
+    if (!nameNode)
+        return;
+    const loopVarName = nameNode.text;
+    if (!loopVarName)
+        return;
+    const typeNode = findChild(loopParts, 'type_identifier');
+    if (typeNode) {
+        const typeName = extractSimpleTypeName(typeNode);
+        if (typeName && !scopeEnv.has(loopVarName)) {
+            scopeEnv.set(loopVarName, typeName);
+        }
+        return;
+    }
+    const iterableNode = loopParts.childForFieldName('value');
+    if (!iterableNode)
+        return;
+    let iterableName;
+    let callExprElementType;
+    if (iterableNode.type === 'identifier') {
+        iterableName = iterableNode.text;
+    }
+    else if (iterableNode.type === 'unary_expression') {
+        const awaitExpr = findChild(iterableNode, 'await_expression');
+        if (awaitExpr) {
+            const innerIdent = findChild(awaitExpr, 'identifier');
+            if (innerIdent)
+                iterableName = innerIdent.text;
+        }
+        if (!iterableName)
+            return;
+    }
+    if (iterableName) {
+        let hasCallSelector = false;
+        let memberName;
+        const selectorParent = iterableNode.type === 'unary_expression'
+            ? findChild(iterableNode, 'await_expression')
+            : loopParts;
+        if (!selectorParent)
+            return;
+        let foundIterable = false;
+        for (let i = 0; i < selectorParent.childCount; i++) {
+            const child = selectorParent.child(i);
+            if (!child)
+                continue;
+            if (child.type === 'identifier' && child.text === iterableName) {
+                foundIterable = true;
+                continue;
+            }
+            if (child === iterableNode) {
+                foundIterable = true;
+                continue;
+            }
+            if (!foundIterable)
+                continue;
+            if (child.type === 'selector') {
+                const uas = findChild(child, 'unconditional_assignable_selector')
+                    ?? findChild(child, 'conditional_assignable_selector');
+                if (uas) {
+                    const id = findChild(uas, 'identifier');
+                    if (id)
+                        memberName = id.text;
+                    continue;
+                }
+                if (findChild(child, 'argument_part')) {
+                    hasCallSelector = true;
+                }
+            }
+        }
+        if (hasCallSelector) {
+            const callee = memberName ?? iterableName;
+            const rawReturn = returnTypeLookup.lookupRawReturnType(callee);
+            if (rawReturn)
+                callExprElementType = extractElementTypeFromString(rawReturn);
+        }
+    }
+    if (!iterableName && !callExprElementType)
+        return;
+    let elementType;
+    if (callExprElementType) {
+        elementType = callExprElementType;
+    }
+    else if (iterableName) {
+        elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractDartElementTypeFromTypeNode);
+    }
+    if (elementType && !scopeEnv.has(loopVarName)) {
+        scopeEnv.set(loopVarName, elementType);
+    }
+};
+// ── Export ───────────────────────────────────────────────────────────────
+export const typeConfig = {
+    declarationNodeTypes: DART_DECLARATION_NODE_TYPES,
+    forLoopNodeTypes: DART_FOR_LOOP_NODE_TYPES,
+    extractDeclaration: extractDartDeclaration,
+    extractParameter: extractDartParameter,
+    extractInitializer: extractDartInitializer,
+    scanConstructorBinding: scanDartConstructorBinding,
+    extractForLoopBinding: extractDartForLoopBinding,
+    extractPendingAssignment: extractDartPendingAssignment,
+    inferLiteralType: inferDartLiteralType,
+    detectConstructorType: detectDartConstructorType,
+};

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 { findChild } from '../resolvers/utils.js';
 // ── Java ──────────────────────────────────────────────────────────────────
 const JAVA_DECLARATION_NODE_TYPES = new Set([
     'local_variable_declaration',

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

@@ -1,4 +1,4 @@
-import type { SyntaxNode } from '../utils.js';
+import type { SyntaxNode } from '../utils/ast-helpers.js';
 /** Which type argument to extract from a multi-arg generic container.
  *  - 'first': key type (e.g., K from Map<K,V>) — used for .keys(), .keySet()
  *  - 'last':  value type (e.g., V from Map<K,V>) — used for .values(), .items(), .iter() */
@@ -128,16 +128,4 @@ export declare const extractCalleeName: (callNode: SyntaxNode) => string | undef
  */
 export declare function extractElementTypeFromString(typeStr: string, pos?: TypeArgPosition): string | undefined;
 export declare const extractReturnTypeName: (raw: string, depth?: number) => string | undefined;
-/**
- * Extract the declared type of a property/field from its AST definition node.
- * Handles cross-language patterns:
- * - TypeScript: `name: Type` → type_annotation child
- * - Java: `Type name` → type child on field_declaration
- * - C#: `Type Name { get; set; }` → type child on property_declaration
- * - Go: `Name Type` → type child on field_declaration
- * - Kotlin: `var name: Type` → variable_declaration child with type field
- *
- * Returns the normalized type name, or undefined if no type can be extracted.
- */
-export declare const extractPropertyDeclaredType: (definitionNode: SyntaxNode | null) => string | undefined;
 export {};