gitnexus 1.4.7 → 1.4.8

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

@@ -1,4 +1,5 @@
-import { extractSimpleTypeName, extractVarName, findChildByType, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString } from './shared.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',
@@ -78,7 +79,7 @@ const scanJavaConstructorBinding = (node) => {
         return undefined;
     if (typeNode.text !== 'var')
         return undefined;
-    const declarator = findChildByType(node, 'variable_declarator');
+    const declarator = findChild(node, 'variable_declarator');
     if (!declarator)
         return undefined;
     const nameNode = declarator.childForFieldName('name');
@@ -293,6 +294,39 @@ const extractJavaPatternBinding = (node) => {
         return undefined;
     return { varName, typeName };
 };
+/** Infer the type of a literal AST node for Java/Kotlin overload disambiguation. */
+const inferJvmLiteralType = (node) => {
+    switch (node.type) {
+        case 'decimal_integer_literal':
+        case 'integer_literal':
+        case 'hex_integer_literal':
+        case 'octal_integer_literal':
+        case 'binary_integer_literal':
+            // Check for long suffix
+            if (node.text.endsWith('L') || node.text.endsWith('l'))
+                return 'long';
+            return 'int';
+        case 'decimal_floating_point_literal':
+        case 'real_literal':
+            if (node.text.endsWith('f') || node.text.endsWith('F'))
+                return 'float';
+            return 'double';
+        case 'string_literal':
+        case 'line_string_literal':
+        case 'multi_line_string_literal':
+            return 'String';
+        case 'character_literal':
+            return 'char';
+        case 'true':
+        case 'false':
+        case 'boolean_literal':
+            return 'boolean';
+        case 'null_literal':
+            return 'null';
+        default:
+            return undefined;
+    }
+};
 export const javaTypeConfig = {
     declarationNodeTypes: JAVA_DECLARATION_NODE_TYPES,
     forLoopNodeTypes: JAVA_FOR_LOOP_NODE_TYPES,
@@ -304,6 +338,7 @@ export const javaTypeConfig = {
     extractForLoopBinding: extractJavaForLoopBinding,
     extractPendingAssignment: extractJavaPendingAssignment,
     extractPatternBinding: extractJavaPatternBinding,
+    inferLiteralType: inferJvmLiteralType,
 };
 // ── Kotlin ────────────────────────────────────────────────────────────────
 const KOTLIN_DECLARATION_NODE_TYPES = new Set([
@@ -314,10 +349,11 @@ const KOTLIN_DECLARATION_NODE_TYPES = new Set([
 const extractKotlinDeclaration = (node, env) => {
     if (node.type === 'property_declaration') {
         // Kotlin property_declaration: name/type are inside a variable_declaration child
-        const varDecl = findChildByType(node, 'variable_declaration');
+        const varDecl = findChild(node, 'variable_declaration');
         if (varDecl) {
-            const nameNode = findChildByType(varDecl, 'simple_identifier');
-            const typeNode = findChildByType(varDecl, 'user_type');
+            const nameNode = findChild(varDecl, 'simple_identifier');
+            const typeNode = findChild(varDecl, 'user_type')
+                ?? findChild(varDecl, 'nullable_type');
             if (!nameNode || !typeNode)
                 return;
             const varName = extractVarName(nameNode);
@@ -328,9 +364,9 @@ const extractKotlinDeclaration = (node, env) => {
         }
         // Fallback: try direct fields
         const nameNode = node.childForFieldName('name')
-            ?? findChildByType(node, 'simple_identifier');
+            ?? findChild(node, 'simple_identifier');
         const typeNode = node.childForFieldName('type')
-            ?? findChildByType(node, 'user_type');
+            ?? findChild(node, 'user_type');
         if (!nameNode || !typeNode)
             return;
         const varName = extractVarName(nameNode);
@@ -340,8 +376,8 @@ const extractKotlinDeclaration = (node, env) => {
     }
     else if (node.type === 'variable_declaration') {
         // variable_declaration directly inside functions
-        const nameNode = findChildByType(node, 'simple_identifier');
-        const typeNode = findChildByType(node, 'user_type');
+        const nameNode = findChild(node, 'simple_identifier');
+        const typeNode = findChild(node, 'user_type');
         if (nameNode && typeNode) {
             const varName = extractVarName(nameNode);
             const typeName = extractSimpleTypeName(typeNode);
@@ -353,7 +389,7 @@ const extractKotlinDeclaration = (node, env) => {
 /** Kotlin: parameter / formal_parameter → type name.
  *  Kotlin's tree-sitter grammar uses positional children (simple_identifier, user_type)
  *  rather than named fields (name, type) on `parameter` nodes, so we fall back to
- *  findChildByType when childForFieldName returns null. */
+ *  findChild when childForFieldName returns null. */
 const extractKotlinParameter = (node, env) => {
     let nameNode = null;
     let typeNode = null;
@@ -367,9 +403,10 @@ const extractKotlinParameter = (node, env) => {
     }
     // Fallback: Kotlin `parameter` nodes use positional children, not named fields
     if (!nameNode)
-        nameNode = findChildByType(node, 'simple_identifier');
+        nameNode = findChild(node, 'simple_identifier');
     if (!typeNode)
-        typeNode = findChildByType(node, 'user_type');
+        typeNode = findChild(node, 'user_type')
+            ?? findChild(node, 'nullable_type');
     if (!nameNode || !typeNode)
         return;
     const varName = extractVarName(nameNode);
@@ -377,48 +414,61 @@ const extractKotlinParameter = (node, env) => {
     if (varName && typeName)
         env.set(varName, typeName);
 };
-/** Kotlin: val user = User() — infer type from call_expression when callee is a known class.
- *  Kotlin constructors are syntactically identical to function calls, so we verify
- *  against classNames (which may include cross-file SymbolTable lookups). */
-const extractKotlinInitializer = (node, env, classNames) => {
+/** Find the constructor callee name in a Kotlin property_declaration's initializer.
+ *  Returns the class name if the callee is a verified class constructor, undefined otherwise. */
+const findKotlinConstructorCallee = (node, classNames) => {
     if (node.type !== 'property_declaration')
-        return;
-    // Skip if there's an explicit type annotation — Tier 0 already handled it
-    const varDecl = findChildByType(node, 'variable_declaration');
-    if (varDecl && findChildByType(varDecl, 'user_type'))
-        return;
-    // Get the initializer value — the call_expression after '='
+        return undefined;
     const value = node.childForFieldName('value')
-        ?? findChildByType(node, 'call_expression');
+        ?? findChild(node, 'call_expression');
     if (!value || value.type !== 'call_expression')
-        return;
-    // The callee is the first child of call_expression (simple_identifier for direct calls)
+        return undefined;
     const callee = value.firstNamedChild;
     if (!callee || callee.type !== 'simple_identifier')
-        return;
+        return undefined;
     const calleeName = callee.text;
     if (!calleeName || !classNames.has(calleeName))
+        return undefined;
+    return calleeName;
+};
+/** Kotlin: val user = User() — infer type from call_expression when callee is a known class.
+ *  Kotlin constructors are syntactically identical to function calls, so we verify
+ *  against classNames (which may include cross-file SymbolTable lookups). */
+const extractKotlinInitializer = (node, env, classNames) => {
+    // Skip if there's an explicit type annotation — Tier 0 already handled it
+    const varDecl = findChild(node, 'variable_declaration');
+    if (varDecl && findChild(varDecl, 'user_type'))
+        return;
+    const calleeName = findKotlinConstructorCallee(node, classNames);
+    if (!calleeName)
         return;
     // Extract the variable name from the variable_declaration inside property_declaration
     const nameNode = varDecl
-        ? findChildByType(varDecl, 'simple_identifier')
-        : findChildByType(node, 'simple_identifier');
+        ? findChild(varDecl, 'simple_identifier')
+        : findChild(node, 'simple_identifier');
     if (!nameNode)
         return;
     const varName = extractVarName(nameNode);
     if (varName)
         env.set(varName, calleeName);
 };
+/** Kotlin: detect constructor type from call_expression in typed declarations.
+ *  Unlike extractKotlinInitializer (which SKIPS typed declarations), this detects
+ *  the constructor type EVEN when a type annotation exists, enabling virtual dispatch
+ *  for patterns like `val a: Animal = Dog()`. */
+const detectKotlinConstructorType = (node, classNames) => {
+    return findKotlinConstructorCallee(node, classNames);
+};
 /** Kotlin: val x = User(...) — constructor binding for property_declaration with call_expression */
 const scanKotlinConstructorBinding = (node) => {
     if (node.type !== 'property_declaration')
         return undefined;
-    const varDecl = findChildByType(node, 'variable_declaration');
+    const varDecl = findChild(node, 'variable_declaration');
     if (!varDecl)
         return undefined;
-    if (findChildByType(varDecl, 'user_type'))
+    if (findChild(varDecl, 'user_type'))
         return undefined;
-    const callExpr = findChildByType(node, 'call_expression');
+    const callExpr = findChild(node, 'call_expression');
     if (!callExpr)
         return undefined;
     const callee = callExpr.firstNamedChild;
@@ -440,7 +490,7 @@ const scanKotlinConstructorBinding = (node) => {
     }
     if (!calleeName)
         return undefined;
-    const nameNode = findChildByType(varDecl, 'simple_identifier');
+    const nameNode = findChild(varDecl, 'simple_identifier');
     if (!nameNode)
         return undefined;
     return { varName: nameNode.text, calleeName };
@@ -453,7 +503,7 @@ const KOTLIN_FOR_LOOP_NODE_TYPES = new Set([
  *  Handles the type_projection wrapper that Kotlin uses for generic type arguments. */
 const extractKotlinElementTypeFromTypeNode = (typeNode, pos = 'last') => {
     if (typeNode.type === 'user_type') {
-        const argsNode = findChildByType(typeNode, 'type_arguments');
+        const argsNode = findChild(typeNode, 'type_arguments');
         if (argsNode && argsNode.namedChildCount >= 1) {
             const targetArg = pos === 'first'
                 ? argsNode.namedChild(0)
@@ -476,16 +526,16 @@ const findKotlinParamElementType = (iterableName, startNode, pos = 'last') => {
     let current = startNode.parent;
     while (current) {
         if (current.type === 'function_declaration') {
-            const paramsNode = findChildByType(current, 'function_value_parameters');
+            const paramsNode = findChild(current, 'function_value_parameters');
             if (paramsNode) {
                 for (let i = 0; i < paramsNode.namedChildCount; i++) {
                     const param = paramsNode.namedChild(i);
                     if (!param || param.type !== 'parameter')
                         continue;
-                    const nameNode = findChildByType(param, 'simple_identifier');
+                    const nameNode = findChild(param, 'simple_identifier');
                     if (nameNode?.text !== iterableName)
                         continue;
-                    const typeNode = findChildByType(param, 'user_type');
+                    const typeNode = findChild(param, 'user_type');
                     if (typeNode)
                         return extractKotlinElementTypeFromTypeNode(typeNode, pos);
                 }
@@ -500,17 +550,17 @@ const findKotlinParamElementType = (iterableName, startNode, pos = 'last') => {
  *  Tier 1c: for `for (user in users)` without annotation, resolves from iterable. */
 const extractKotlinForLoopBinding = (node, ctx) => {
     const { scopeEnv, declarationTypeNodes, scope, returnTypeLookup } = ctx;
-    const varDecl = findChildByType(node, 'variable_declaration');
+    const varDecl = findChild(node, 'variable_declaration');
     if (!varDecl)
         return;
-    const nameNode = findChildByType(varDecl, 'simple_identifier');
+    const nameNode = findChild(varDecl, 'simple_identifier');
     if (!nameNode)
         return;
     const varName = extractVarName(nameNode);
     if (!varName)
         return;
     // Explicit type annotation (existing behavior): for (user: User in users)
-    const typeNode = findChildByType(varDecl, 'user_type');
+    const typeNode = findChild(varDecl, 'user_type');
     if (typeNode) {
         const typeName = extractSimpleTypeName(typeNode);
         if (typeName)
@@ -540,9 +590,9 @@ const extractKotlinForLoopBinding = (node, ctx) => {
         if (child.type === 'navigation_expression') {
             // data.keys → navigation_expression > simple_identifier(data) + navigation_suffix > simple_identifier(keys)
             const obj = child.firstNamedChild;
-            const suffix = findChildByType(child, 'navigation_suffix');
-            const prop = suffix ? findChildByType(suffix, 'simple_identifier') : null;
-            const hasCallSuffix = suffix ? findChildByType(suffix, 'call_suffix') !== null : false;
+            const suffix = findChild(child, 'navigation_suffix');
+            const prop = suffix ? findChild(suffix, 'simple_identifier') : null;
+            const hasCallSuffix = suffix ? findChild(suffix, 'call_suffix') !== null : false;
             // Always try object as iterable + property as method first (handles data.values, data.keys).
             // For bare property access without call_suffix, also save property as fallback
             // (handles this.users, repo.items where the property IS the iterable).
@@ -562,9 +612,9 @@ const extractKotlinForLoopBinding = (node, ctx) => {
                 const obj = callee.firstNamedChild;
                 if (obj?.type === 'simple_identifier')
                     iterableName = obj.text;
-                const suffix = findChildByType(callee, 'navigation_suffix');
+                const suffix = findChild(callee, 'navigation_suffix');
                 if (suffix) {
-                    const prop = findChildByType(suffix, 'simple_identifier');
+                    const prop = findChild(suffix, 'simple_identifier');
                     if (prop)
                         methodName = prop.text;
                 }
@@ -606,7 +656,7 @@ const extractKotlinForLoopBinding = (node, ctx) => {
 const extractKotlinPendingAssignment = (node, scopeEnv) => {
     if (node.type === 'property_declaration') {
         // Find the variable name from variable_declaration child
-        const varDecl = findChildByType(node, 'variable_declaration');
+        const varDecl = findChild(node, 'variable_declaration');
         if (!varDecl)
             return undefined;
         const nameNode = varDecl.firstNamedChild;
@@ -658,7 +708,7 @@ const extractKotlinPendingAssignment = (node, scopeEnv) => {
     }
     if (node.type === 'variable_declaration') {
         // variable_declaration directly inside functions: simple_identifier children
-        const nameNode = findChildByType(node, 'simple_identifier');
+        const nameNode = findChild(node, 'simple_identifier');
         if (!nameNode)
             return undefined;
         const lhs = nameNode.text;
@@ -717,32 +767,83 @@ const findAncestorByType = (node, type) => {
     }
     return undefined;
 };
-const extractKotlinPatternBinding = (node) => {
-    if (node.type !== 'type_test')
-        return undefined;
-    const typeNode = node.lastNamedChild;
-    if (!typeNode)
-        return undefined;
-    const typeName = extractSimpleTypeName(typeNode);
-    if (!typeName)
-        return undefined;
-    const whenExpr = findAncestorByType(node, 'when_expression');
-    if (!whenExpr)
-        return undefined;
-    const whenSubject = whenExpr.namedChild(0);
-    const subject = whenSubject?.firstNamedChild ?? whenSubject;
-    if (!subject)
-        return undefined;
-    const varName = extractVarName(subject);
-    if (!varName)
+const extractKotlinPatternBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+    // Kotlin when/is smart casts (existing behavior)
+    if (node.type === 'type_test') {
+        const typeNode = node.lastNamedChild;
+        if (!typeNode)
+            return undefined;
+        const typeName = extractSimpleTypeName(typeNode);
+        if (!typeName)
+            return undefined;
+        const whenExpr = findAncestorByType(node, 'when_expression');
+        if (!whenExpr)
+            return undefined;
+        const whenSubject = whenExpr.namedChild(0);
+        const subject = whenSubject?.firstNamedChild ?? whenSubject;
+        if (!subject)
+            return undefined;
+        const varName = extractVarName(subject);
+        if (!varName)
+            return undefined;
+        return { varName, typeName };
+    }
+    // Null-check narrowing: if (x != null) { ... }
+    // Kotlin AST: equality_expression > simple_identifier, "!=" [anon], "null" [anon]
+    // Note: `null` is an anonymous node in tree-sitter-kotlin, not `null_literal`.
+    if (node.type === 'equality_expression') {
+        const op = node.children.find(c => !c.isNamed && c.text === '!=');
+        if (!op)
+            return undefined;
+        // `null` is anonymous in Kotlin grammar — use positional child scan
+        let varNode;
+        let hasNull = false;
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (!c)
+                continue;
+            if (c.type === 'simple_identifier')
+                varNode = c;
+            if (!c.isNamed && c.text === 'null')
+                hasNull = true;
+        }
+        if (!varNode || !hasNull)
+            return undefined;
+        const varName = varNode.text;
+        const resolvedType = scopeEnv.get(varName);
+        if (!resolvedType)
+            return undefined;
+        // Check if the original declaration type was nullable (ends with ?)
+        const declTypeNode = declarationTypeNodes.get(`${scope}\0${varName}`);
+        if (!declTypeNode)
+            return undefined;
+        const declText = declTypeNode.text;
+        if (!declText.includes('?') && !declText.includes('null'))
+            return undefined;
+        // Find the if-body: walk up to if_expression, then find control_structure_body
+        const ifExpr = findAncestorByType(node, 'if_expression');
+        if (!ifExpr)
+            return undefined;
+        // The consequence is the first control_structure_body child
+        for (let i = 0; i < ifExpr.childCount; i++) {
+            const child = ifExpr.child(i);
+            if (child?.type === 'control_structure_body') {
+                return {
+                    varName,
+                    typeName: resolvedType,
+                    narrowingRange: { startIndex: child.startIndex, endIndex: child.endIndex },
+                };
+            }
+        }
         return undefined;
-    return { varName, typeName };
+    }
+    return undefined;
 };
 export const kotlinTypeConfig = {
     allowPatternBindingOverwrite: true,
     declarationNodeTypes: KOTLIN_DECLARATION_NODE_TYPES,
     forLoopNodeTypes: KOTLIN_FOR_LOOP_NODE_TYPES,
-    patternBindingNodeTypes: new Set(['type_test']),
+    patternBindingNodeTypes: new Set(['type_test', 'equality_expression']),
     extractDeclaration: extractKotlinDeclaration,
     extractParameter: extractKotlinParameter,
     extractInitializer: extractKotlinInitializer,
@@ -750,4 +851,6 @@ export const kotlinTypeConfig = {
     extractForLoopBinding: extractKotlinForLoopBinding,
     extractPendingAssignment: extractKotlinPendingAssignment,
     extractPatternBinding: extractKotlinPatternBinding,
+    inferLiteralType: inferJvmLiteralType,
+    detectConstructorType: detectKotlinConstructorType,
 };

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

@@ -205,7 +205,8 @@ const scanConstructorBinding = (node) => {
         return undefined;
     return { varName: patternNode.text, calleeName };
 };
-/** Rust: let alias = u; → let_declaration with pattern + value fields */
+/** Rust: let alias = u; → let_declaration with pattern + value fields.
+ *  Also handles struct destructuring: `let Point { x, y } = p` → N fieldAccess items. */
 const extractPendingAssignment = (node, scopeEnv) => {
     if (node.type !== 'let_declaration')
         return undefined;
@@ -213,6 +214,39 @@ const extractPendingAssignment = (node, scopeEnv) => {
     const value = node.childForFieldName('value');
     if (!pattern || !value)
         return undefined;
+    // Struct pattern destructuring: `let Point { x, y } = receiver`
+    // struct_pattern has a type child (struct name) and field_pattern children
+    if (pattern.type === 'struct_pattern' && value.type === 'identifier') {
+        const receiver = value.text;
+        const items = [];
+        for (let j = 0; j < pattern.namedChildCount; j++) {
+            const field = pattern.namedChild(j);
+            if (!field)
+                continue;
+            if (field.type === 'field_pattern') {
+                // `Point { x: local_x }` → field_pattern with name + pattern children
+                const nameNode = field.childForFieldName('name');
+                const patNode = field.childForFieldName('pattern');
+                if (nameNode && patNode) {
+                    const fieldName = nameNode.text;
+                    const varName = extractVarName(patNode);
+                    if (varName && !scopeEnv.has(varName)) {
+                        items.push({ kind: 'fieldAccess', lhs: varName, receiver, field: fieldName });
+                    }
+                }
+                else if (nameNode) {
+                    // Shorthand: `Point { x }` → field_pattern with only name (varName = fieldName)
+                    const varName = nameNode.text;
+                    if (!scopeEnv.has(varName)) {
+                        items.push({ kind: 'fieldAccess', lhs: varName, receiver, field: varName });
+                    }
+                }
+            }
+        }
+        if (items.length > 0)
+            return items;
+        return undefined;
+    }
     const lhs = extractVarName(pattern);
     if (!lhs || scopeEnv.has(lhs))
         return undefined;

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

@@ -108,8 +108,6 @@ export declare const unwrapAwait: (node: SyntaxNode | null) => SyntaxNode | null
  * Navigates to the 'function' field (or first named child) and extracts a simple type name.
  */
 export declare const extractCalleeName: (callNode: SyntaxNode) => string | undefined;
-/** Find the first named child with the given node type */
-export declare const findChildByType: (node: SyntaxNode, type: string) => SyntaxNode | null;
 /**
  * Extract element type from a container type string.
  * Uses bracket-balanced parsing (no regex) for generic argument extraction.

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

@@ -237,7 +237,11 @@ export const extractSimpleTypeName = (typeNode, depth = 0) => {
     }
     // Primitive/predefined types: string, int, float, bool, number, unknown, any
     // PHP: primitive_type; TS/JS: predefined_type
-    if (typeNode.type === 'primitive_type' || typeNode.type === 'predefined_type') {
+    // Java: integral_type (int/long/short/byte), floating_point_type (float/double),
+    //       boolean_type (boolean), void_type (void)
+    if (typeNode.type === 'primitive_type' || typeNode.type === 'predefined_type'
+        || typeNode.type === 'integral_type' || typeNode.type === 'floating_point_type'
+        || typeNode.type === 'boolean_type' || typeNode.type === 'void_type') {
         return typeNode.text;
     }
     // PHP named_type / optional_type
@@ -454,15 +458,6 @@ export const extractCalleeName = (callNode) => {
         return undefined;
     return extractSimpleTypeName(func);
 };
-/** Find the first named child with the given node type */
-export const findChildByType = (node, type) => {
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child?.type === type)
-            return child;
-    }
-    return null;
-};
 // Internal helper: extract the first comma-separated argument from a string,
 // respecting nested angle-bracket and square-bracket depth.
 function extractFirstArg(args) {

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

@@ -1,4 +1,5 @@
-import { extractSimpleTypeName, extractVarName, findChildByType, hasTypeAnnotation } from './shared.js';
+import { extractSimpleTypeName, extractVarName, hasTypeAnnotation } from './shared.js';
+import { findChild } from '../resolvers/utils.js';
 const DECLARATION_NODE_TYPES = new Set([
     'property_declaration',
 ]);
@@ -6,9 +7,9 @@ const DECLARATION_NODE_TYPES = new Set([
 const extractDeclaration = (node, env) => {
     // Swift property_declaration has pattern and type_annotation
     const pattern = node.childForFieldName('pattern')
-        ?? findChildByType(node, 'pattern');
+        ?? findChild(node, 'pattern');
     const typeAnnotation = node.childForFieldName('type')
-        ?? findChildByType(node, 'type_annotation');
+        ?? findChild(node, 'type_annotation');
     if (!pattern || !typeAnnotation)
         return;
     const varName = extractVarName(pattern) ?? pattern.text;
@@ -43,17 +44,17 @@ const extractInitializer = (node, env, classNames) => {
     if (node.type !== 'property_declaration')
         return;
     // Skip if has type annotation — extractDeclaration handled it
-    if (node.childForFieldName('type') || findChildByType(node, 'type_annotation'))
+    if (node.childForFieldName('type') || findChild(node, 'type_annotation'))
         return;
     // Find pattern (variable name)
-    const pattern = node.childForFieldName('pattern') ?? findChildByType(node, 'pattern');
+    const pattern = node.childForFieldName('pattern') ?? findChild(node, 'pattern');
     if (!pattern)
         return;
     const varName = extractVarName(pattern) ?? pattern.text;
     if (!varName || env.has(varName))
         return;
     // Find call_expression in the value
-    const callExpr = findChildByType(node, 'call_expression');
+    const callExpr = findChild(node, 'call_expression');
     if (!callExpr)
         return;
     const callee = callExpr.firstNamedChild;

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

@@ -23,6 +23,20 @@ export type ConstructorBindingScanner = (node: SyntaxNode) => {
  *  Used for languages where return types are expressed in comments (e.g. YARD @return [Type])
  *  rather than in AST fields. Returns undefined if no return type can be determined. */
 export type ReturnTypeExtractor = (node: SyntaxNode) => string | 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
+ *  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.
+ *  Returns the constructor class name if the node's initializer is a constructor call,
+ *  or undefined otherwise. Used for virtual dispatch in languages like Kotlin
+ *  where constructors are syntactically identical to function calls, and C++
+ *  where smart pointer factory functions (make_shared/make_unique) wrap constructors. */
+export type ConstructorTypeDetector = (node: SyntaxNode, classNames: ClassNameLookup) => string | undefined;
+/** Unwrap a declared type name to its inner type for virtual dispatch comparison.
+ *  E.g., C++ shared_ptr<Animal> → Animal. Returns undefined if no unwrapping applies. */
+export type DeclaredTypeUnwrapper = (declaredType: string, typeNode: SyntaxNode) => string | undefined;
 /** Narrow lookup interface for resolving a callee name → return type name.
  *  Backed by SymbolTable.lookupFuzzyCallable; passed via ForLoopExtractorContext.
  *  Conservative: returns undefined when the callee is ambiguous (0 or 2+ matches). */
@@ -76,11 +90,27 @@ export type PendingAssignment = {
  *  Returns a PendingAssignment when the RHS is a bare identifier (`copy`), a
  *  call expression (`callResult`), a field access (`fieldAccess`), or a
  *  method call with receiver (`methodCallResult`) and the LHS has no resolved type yet.
+ *  May return an array of PendingAssignment items for destructuring patterns
+ *  (e.g., `const { a, b } = obj` emits N fieldAccess items).
  *  Returns undefined if the node is not a matching assignment. */
-export type PendingAssignmentExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMap<string, string>) => PendingAssignment | undefined;
+export type PendingAssignmentExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMap<string, string>) => PendingAssignment | PendingAssignment[] | undefined;
+/** Result of a pattern binding extraction. */
+export interface PatternBindingResult {
+    varName: string;
+    typeName: string;
+    /** Optional: AST node whose position range should be used for the patternOverride.
+     *  When present, the override uses this node's range instead of the auto-detected
+     *  branch scope. Used by null-check narrowing to target the if-body specifically. */
+    narrowingRange?: {
+        startIndex: number;
+        endIndex: number;
+    };
+}
 /** Extracts a typed variable binding from a pattern-matching construct.
- *  Returns { varName, typeName } for patterns that introduce NEW variables.
- *  Examples: `if let Some(user) = opt` (Rust), `x instanceof User user` (Java).
+ *  Returns { varName, typeName } for patterns that introduce NEW variables
+ *  or narrow existing variables (null-check narrowing).
+ *  Examples: `if let Some(user) = opt` (Rust), `x instanceof User user` (Java),
+ *  `if (x != null)` (null-check narrowing in TS/Kotlin/C#).
  *  Conservative: returns undefined when the source variable's type is unknown.
  *
  *  @param scopeEnv   Read-only view of already-resolved type bindings in the current scope.
@@ -88,10 +118,7 @@ export type PendingAssignmentExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMa
  *    annotation AST node. Allows extracting generic type arguments (e.g., T from Result<T,E>)
  *    that are stripped during normal TypeEnv extraction.
  *  @param scope  Current scope key (e.g. `"process@42"`) for declarationTypeNodes lookups. */
-export type PatternBindingExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMap<string, string>, declarationTypeNodes: ReadonlyMap<string, SyntaxNode>, scope: string) => {
-    varName: string;
-    typeName: string;
-} | undefined;
+export type PatternBindingExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMap<string, string>, declarationTypeNodes: ReadonlyMap<string, SyntaxNode>, scope: string) => PatternBindingResult | undefined;
 /** Per-language type extraction configuration */
 export interface LanguageTypeConfig {
     /** Allow pattern binding to overwrite existing scopeEnv entries.
@@ -137,4 +164,7 @@ export interface LanguageTypeConfig {
      *  The extractor receives the current scope's resolved bindings (read-only) to look up the
      *  source variable's type. Returns undefined for non-matching nodes or unknown source types. */
     extractPatternBinding?: PatternBindingExtractor;
+    inferLiteralType?: LiteralTypeInferrer;
+    detectConstructorType?: ConstructorTypeDetector;
+    unwrapDeclaredType?: DeclaredTypeUnwrapper;
 }