gitnexus 1.4.7 → 1.4.9

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

@@ -1,14 +1,35 @@
-import { extractSimpleTypeName, extractVarName, findChildByType, hasTypeAnnotation } from './shared.js';
+import { findChild } from '../utils/ast-helpers.js';
+import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, extractElementTypeFromString, resolveIterableElementType } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'property_declaration',
+    'if_statement',
+    'guard_statement',
 ]);
+const FOR_LOOP_NODE_TYPES = new Set([
+    'for_statement',
+]);
+/**
+ * Unwrap Swift `await_expression` and `try_expression` nodes to find the inner
+ * call_expression or other value node. `try` nodes contain a `try_operator` child
+ * that must be skipped.
+ */
+function unwrapSwiftExpression(node) {
+    if (node.type === 'await_expression' || node.type === 'try_expression') {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && child.type !== 'try_operator')
+                return unwrapSwiftExpression(child);
+        }
+    }
+    return node;
+}
 /** Swift: let x: Foo = ... */
 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 +64,30 @@ 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');
+    // Find call_expression in the value (unwrap await/try)
+    let callExpr = findChild(node, 'call_expression');
+    if (!callExpr) {
+        // Check for await_expression or try_expression wrapping a call_expression
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && (child.type === 'await_expression' || child.type === 'try_expression')) {
+                const unwrapped = unwrapSwiftExpression(child);
+                if (unwrapped.type === 'call_expression') {
+                    callExpr = unwrapped;
+                    break;
+                }
+            }
+        }
+    }
     if (!callExpr)
         return;
     const callee = callExpr.firstNamedChild;
@@ -98,6 +132,14 @@ const scanConstructorBinding = (node) => {
             callExpr = child;
             break;
         }
+        // Unwrap await/try to find inner call_expression
+        if (child && (child.type === 'await_expression' || child.type === 'try_expression')) {
+            const unwrapped = unwrapSwiftExpression(child);
+            if (unwrapped.type === 'call_expression') {
+                callExpr = unwrapped;
+                break;
+            }
+        }
     }
     if (!callExpr)
         return undefined;
@@ -128,10 +170,299 @@ const scanConstructorBinding = (node) => {
     }
     return undefined;
 };
+/**
+ * Extract the variable name from an if_statement or guard_statement with optional binding.
+ * Pattern: `if let varName = expr` / `guard let varName = expr`
+ * AST: if_statement/guard_statement contains value_binding_pattern, then simple_identifier (varName),
+ * then call_expression/simple_identifier/navigation_expression (value).
+ */
+function extractIfGuardBinding(node, scopeEnv) {
+    // Find value_binding_pattern to confirm this is an optional binding
+    let hasValueBinding = false;
+    let varName;
+    let valueNode = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'value_binding_pattern') {
+            hasValueBinding = true;
+            continue;
+        }
+        if (hasValueBinding && !varName && child.type === 'simple_identifier') {
+            varName = child.text;
+            continue;
+        }
+        if (varName && !valueNode) {
+            // Skip type annotations and binding operators
+            if (child.type === 'type_annotation')
+                continue;
+            valueNode = child;
+            break;
+        }
+    }
+    if (!hasValueBinding || !varName || !valueNode || scopeEnv.has(varName))
+        return undefined;
+    // Unwrap await/try
+    valueNode = unwrapSwiftExpression(valueNode);
+    // simple_identifier → copy
+    if (valueNode.type === 'simple_identifier') {
+        return { kind: 'copy', lhs: varName, rhs: valueNode.text };
+    }
+    // navigation_expression → fieldAccess
+    if (valueNode.type === 'navigation_expression') {
+        const receiver = valueNode.firstNamedChild;
+        const suffix = valueNode.lastNamedChild;
+        if (receiver?.type === 'simple_identifier' && suffix?.type === 'navigation_suffix') {
+            const field = suffix.lastNamedChild;
+            if (field?.type === 'simple_identifier') {
+                return { kind: 'fieldAccess', lhs: varName, receiver: receiver.text, field: field.text };
+            }
+        }
+        return undefined;
+    }
+    // call_expression → callResult or methodCallResult
+    if (valueNode.type === 'call_expression') {
+        const callee = valueNode.firstNamedChild;
+        if (!callee)
+            return undefined;
+        if (callee.type === 'simple_identifier') {
+            return { kind: 'callResult', lhs: varName, callee: callee.text };
+        }
+        if (callee.type === 'navigation_expression') {
+            const receiver = callee.firstNamedChild;
+            const suffix = callee.lastNamedChild;
+            if (receiver?.type === 'simple_identifier' && suffix?.type === 'navigation_suffix') {
+                const method = suffix.lastNamedChild;
+                if (method?.type === 'simple_identifier') {
+                    return { kind: 'methodCallResult', lhs: varName, receiver: receiver.text, method: method.text };
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Swift: extract pending assignments for Tier 2 return-type propagation.
+ * Handles:
+ *   let user = getUser()           → callResult
+ *   let result = user.save()       → methodCallResult
+ *   let name = user.name           → fieldAccess
+ *   let copy = user                → copy
+ *   let user = await getUser()     → callResult (unwrapped)
+ *   let user = try getUser()       → callResult (unwrapped)
+ *   if let user = getUser()        → callResult (optional binding)
+ *   guard let user = getUser()     → callResult (optional binding)
+ */
+const extractPendingAssignment = (node, scopeEnv) => {
+    // Handle if_statement and guard_statement optional bindings
+    if (node.type === 'if_statement' || node.type === 'guard_statement') {
+        return extractIfGuardBinding(node, scopeEnv);
+    }
+    if (node.type !== 'property_declaration')
+        return undefined;
+    // Skip if type annotation exists — extractDeclaration handles it
+    if (hasTypeAnnotation(node))
+        return undefined;
+    // Find the variable name from the pattern child
+    let lhs;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'pattern') {
+            lhs = child.text;
+            break;
+        }
+    }
+    if (!lhs || scopeEnv.has(lhs))
+        return undefined;
+    // Find the value expression (last meaningful named child after pattern)
+    let valueNode = null;
+    for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'pattern' || child.type === 'value_binding_pattern' || child.type === 'type_annotation')
+            continue;
+        valueNode = child;
+        break;
+    }
+    if (!valueNode)
+        return undefined;
+    // Unwrap await/try expressions (Feature 2)
+    valueNode = unwrapSwiftExpression(valueNode);
+    // let copy = user → copy
+    if (valueNode.type === 'simple_identifier') {
+        return { kind: 'copy', lhs, rhs: valueNode.text };
+    }
+    // let name = user.name → fieldAccess
+    if (valueNode.type === 'navigation_expression') {
+        const receiver = valueNode.firstNamedChild;
+        const suffix = valueNode.lastNamedChild;
+        if (receiver?.type === 'simple_identifier' && suffix?.type === 'navigation_suffix') {
+            const field = suffix.lastNamedChild;
+            if (field?.type === 'simple_identifier') {
+                return { kind: 'fieldAccess', lhs, receiver: receiver.text, field: field.text };
+            }
+        }
+        return undefined;
+    }
+    // Call expressions
+    if (valueNode.type === 'call_expression') {
+        const callee = valueNode.firstNamedChild;
+        if (!callee)
+            return undefined;
+        // let user = getUser() → callResult
+        if (callee.type === 'simple_identifier') {
+            return { kind: 'callResult', lhs, callee: callee.text };
+        }
+        // let result = user.save() → methodCallResult
+        if (callee.type === 'navigation_expression') {
+            const receiver = callee.firstNamedChild;
+            const suffix = callee.lastNamedChild;
+            if (receiver?.type === 'simple_identifier' && suffix?.type === 'navigation_suffix') {
+                const method = suffix.lastNamedChild;
+                if (method?.type === 'simple_identifier') {
+                    return { kind: 'methodCallResult', lhs, receiver: receiver.text, method: method.text };
+                }
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * Swift: extract loop variable type binding from `for item in collection`.
+ * AST: for_statement with pattern > simple_identifier (loop var) and
+ * a simple_identifier/call_expression (collection).
+ */
+const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, returnTypeLookup }) => {
+    if (node.type !== 'for_statement')
+        return;
+    // Find the loop variable from the pattern child
+    let loopVarName;
+    let iterableNode = null;
+    // for_statement children: pattern (loop var), then the iterable expression, then the body
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'pattern' || child.type === 'simple_identifier') {
+            if (!loopVarName) {
+                // Extract a simple identifier from the pattern. Skip non-trivial patterns
+                // (e.g. tuple destructuring `for (a, b) in ...`) to avoid polluting scopeEnv.
+                const varName = extractVarName(child) ?? (child.type === 'simple_identifier' ? child.text : undefined);
+                if (!varName)
+                    return; // Non-simple pattern — bail out
+                loopVarName = varName;
+                continue;
+            }
+        }
+        // After we found the loop var, the next expression-like node is the iterable
+        if (loopVarName && !iterableNode) {
+            if (child.type === 'simple_identifier' || child.type === 'call_expression' ||
+                child.type === 'navigation_expression') {
+                iterableNode = child;
+                break;
+            }
+        }
+    }
+    if (!loopVarName || !iterableNode)
+        return;
+    let iterableName;
+    let callExprElementType;
+    if (iterableNode.type === 'simple_identifier') {
+        iterableName = iterableNode.text;
+    }
+    else if (iterableNode.type === 'navigation_expression') {
+        // collection.property
+        const suffix = iterableNode.lastNamedChild;
+        if (suffix?.type === 'navigation_suffix') {
+            const prop = suffix.lastNamedChild;
+            if (prop?.type === 'simple_identifier')
+                iterableName = prop.text;
+        }
+        else if (suffix?.type === 'simple_identifier') {
+            iterableName = suffix.text;
+        }
+    }
+    else if (iterableNode.type === 'call_expression') {
+        // getItems() or collection.values()
+        const fn = iterableNode.firstNamedChild;
+        let callee;
+        if (fn?.type === 'simple_identifier') {
+            callee = fn.text;
+        }
+        else if (fn?.type === 'navigation_expression') {
+            const obj = fn.firstNamedChild;
+            const suffix = fn.lastNamedChild;
+            if (obj?.type === 'simple_identifier')
+                iterableName = obj.text;
+            if (suffix?.type === 'navigation_suffix') {
+                const m = suffix.lastNamedChild;
+                if (m?.type === 'simple_identifier')
+                    callee = m.text;
+            }
+            else if (suffix?.type === 'simple_identifier') {
+                callee = suffix.text;
+            }
+        }
+        if (callee) {
+            const rawReturn = returnTypeLookup.lookupRawReturnType(callee);
+            if (rawReturn)
+                callExprElementType = extractElementTypeFromString(rawReturn);
+        }
+    }
+    if (!iterableName && !callExprElementType)
+        return;
+    let elementType;
+    if (callExprElementType) {
+        elementType = callExprElementType;
+    }
+    else if (iterableName) {
+        // Try to resolve element type from the iterable's declared type
+        elementType = resolveIterableElementType(iterableName, node, scopeEnv, declarationTypeNodes, scope, extractSwiftElementTypeFromTypeNode);
+    }
+    if (elementType && !scopeEnv.has(loopVarName)) {
+        scopeEnv.set(loopVarName, elementType);
+    }
+};
+/**
+ * Extract element type from a Swift type annotation AST node.
+ * Handles: [User] (array sugar), Array<User>, Set<User>, etc.
+ */
+function extractSwiftElementTypeFromTypeNode(typeNode) {
+    // Swift array sugar: [User] — parsed as array_type > user_type > type_identifier
+    if (typeNode.type === 'array_type') {
+        const inner = typeNode.firstNamedChild;
+        if (inner)
+            return extractSimpleTypeName(inner);
+    }
+    // Generic type: Array<User>, Set<User>
+    if (typeNode.type === 'user_type') {
+        // Check for generic args: user_type > type_identifier + type_arguments
+        for (let i = 0; i < typeNode.namedChildCount; i++) {
+            const child = typeNode.namedChild(i);
+            if (child?.type === 'type_arguments') {
+                const lastArg = child.lastNamedChild;
+                if (lastArg)
+                    return extractSimpleTypeName(lastArg);
+            }
+        }
+    }
+    // type_annotation wrapping
+    if (typeNode.type === 'type_annotation') {
+        const inner = typeNode.firstNamedChild;
+        if (inner)
+            return extractSwiftElementTypeFromTypeNode(inner);
+    }
+    return undefined;
+}
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
+    forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
     extractDeclaration,
     extractParameter,
     extractInitializer,
     scanConstructorBinding,
+    extractPendingAssignment,
+    extractForLoopBinding,
 };

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

@@ -1,4 +1,4 @@
-import type { SyntaxNode } from '../utils.js';
+import type { SyntaxNode } from '../utils/ast-helpers.js';
 /** Extracts type bindings from a declaration node into the env map */
 export type TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>) => void;
 /** Extracts type bindings from a parameter node into the env map */
@@ -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). */
@@ -61,6 +75,8 @@ export type PendingAssignment = {
     kind: 'callResult';
     lhs: string;
     callee: string;
+    calleeFqn?: string;
+    line?: number;
 } | {
     kind: 'fieldAccess';
     lhs: string;
@@ -76,11 +92,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 +120,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 +166,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;
 }

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

@@ -444,7 +444,8 @@ const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, re
     if (loopVarName)
         scopeEnv.set(loopVarName, elementType);
 };
-/** TS/JS: const alias = u → variable_declarator with name/value fields */
+/** TS/JS: const alias = u → variable_declarator with name/value fields.
+ *  Also handles destructuring: `const { a, b } = obj` → N fieldAccess items. */
 const extractPendingAssignment = (node, scopeEnv) => {
     for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
@@ -454,6 +455,39 @@ const extractPendingAssignment = (node, scopeEnv) => {
         const valueNode = child.childForFieldName('value');
         if (!nameNode || !valueNode)
             continue;
+        // Object destructuring: `const { address, name } = user`
+        // Emits N fieldAccess items — one per destructured binding.
+        if (nameNode.type === 'object_pattern' && valueNode.type === 'identifier') {
+            const receiver = valueNode.text;
+            const items = [];
+            for (let j = 0; j < nameNode.namedChildCount; j++) {
+                const prop = nameNode.namedChild(j);
+                if (!prop)
+                    continue;
+                if (prop.type === 'shorthand_property_identifier_pattern') {
+                    // `const { name } = user` → shorthand: varName = fieldName
+                    const varName = prop.text;
+                    if (!scopeEnv.has(varName)) {
+                        items.push({ kind: 'fieldAccess', lhs: varName, receiver, field: varName });
+                    }
+                }
+                else if (prop.type === 'pair_pattern') {
+                    // `const { address: addr } = user` → pair_pattern: key=field, value=varName
+                    const keyNode = prop.childForFieldName('key');
+                    const valNode = prop.childForFieldName('value');
+                    if (keyNode && valNode) {
+                        const fieldName = keyNode.text;
+                        const varName = valNode.text;
+                        if (!scopeEnv.has(varName)) {
+                            items.push({ kind: 'fieldAccess', lhs: varName, receiver, field: fieldName });
+                        }
+                    }
+                }
+            }
+            if (items.length > 0)
+                return items;
+            continue;
+        }
         const lhs = nameNode.text;
         if (scopeEnv.has(lhs))
             continue;
@@ -492,22 +526,119 @@ const extractPendingAssignment = (node, scopeEnv) => {
     }
     return undefined;
 };
+/** Null-check keywords that indicate a null-comparison in binary expressions. */
+const NULL_CHECK_KEYWORDS = new Set(['null', 'undefined']);
+/**
+ * Find the if-body (consequence) block for a null-check binary_expression.
+ * Walks up from the binary_expression through parenthesized_expression to if_statement,
+ * then returns the consequence block (statement_block).
+ *
+ * AST structure: if_statement > parenthesized_expression > binary_expression
+ *                if_statement > statement_block (consequence)
+ */
+const findIfConsequenceBlock = (binaryExpr) => {
+    // Walk up to find the if_statement (typically: binary_expression > parenthesized_expression > if_statement)
+    let current = binaryExpr.parent;
+    while (current) {
+        if (current.type === 'if_statement') {
+            // The consequence is the first statement_block child of if_statement
+            for (let i = 0; i < current.childCount; i++) {
+                const child = current.child(i);
+                if (child?.type === 'statement_block')
+                    return child;
+            }
+            return undefined;
+        }
+        // Stop climbing at function/block boundaries — don't cross scope
+        if (current.type === 'function_declaration' || current.type === 'function_expression'
+            || current.type === 'arrow_function' || current.type === 'method_definition')
+            return undefined;
+        current = current.parent;
+    }
+    return undefined;
+};
 /** TS instanceof narrowing: `x instanceof User` → bind x to User.
- *  Only works when x has no prior type binding (e.g. x: unknown, untyped params).
- *  Typed params (x: Animal) are blocked by the !scopeEnv.has() guard in buildTypeEnv.
- *  Uses first-writer-wins, same as Rust match arm bindings. */
-const extractPatternBinding = (node) => {
+ *  Also handles null-check narrowing: `x !== null`, `x != undefined` etc.
+ *  instanceof: first-writer-wins (no prior type binding).
+ *  null-check: position-indexed narrowing via narrowingRange. */
+const extractPatternBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     if (node.type !== 'binary_expression')
         return undefined;
-    const op = node.children.find(c => !c.isNamed && c.text === 'instanceof');
+    // Check for instanceof first (existing behavior)
+    const instanceofOp = node.children.find(c => !c.isNamed && c.text === 'instanceof');
+    if (instanceofOp) {
+        const left = node.namedChild(0);
+        const right = node.namedChild(1);
+        if (left?.type !== 'identifier' || right?.type !== 'identifier')
+            return undefined;
+        return { varName: left.text, typeName: right.text };
+    }
+    // Null-check narrowing: x !== null, x != null, x !== undefined, x != undefined
+    const op = node.children.find(c => !c.isNamed && (c.text === '!==' || c.text === '!='));
     if (!op)
         return undefined;
-    // binary_expression children are positional — no left/right fields
     const left = node.namedChild(0);
     const right = node.namedChild(1);
-    if (left?.type !== 'identifier' || right?.type !== 'identifier')
+    if (!left || !right)
+        return undefined;
+    // Determine which side is the variable and which is null/undefined
+    let varNode;
+    let isNullCheck = false;
+    if (left.type === 'identifier' && NULL_CHECK_KEYWORDS.has(right.text)) {
+        varNode = left;
+        isNullCheck = true;
+    }
+    else if (right.type === 'identifier' && NULL_CHECK_KEYWORDS.has(left.text)) {
+        varNode = right;
+        isNullCheck = true;
+    }
+    if (!isNullCheck || !varNode)
         return undefined;
-    return { varName: left.text, typeName: right.text };
+    const varName = varNode.text;
+    // Look up the variable's resolved type (already stripped of nullable by extractSimpleTypeName)
+    const resolvedType = scopeEnv.get(varName);
+    if (!resolvedType)
+        return undefined;
+    // Check if the original declaration type was nullable by looking at the raw AST type node.
+    // extractSimpleTypeName already strips nullable markers, so we need the original to know
+    // if narrowing is meaningful (i.e., the variable was declared as nullable).
+    const declTypeNode = declarationTypeNodes.get(`${scope}\0${varName}`);
+    if (!declTypeNode)
+        return undefined;
+    const declText = declTypeNode.text;
+    // Only narrow if the original declaration was nullable
+    if (!declText.includes('null') && !declText.includes('undefined'))
+        return undefined;
+    // Find the if-body block to scope the narrowing
+    const ifBody = findIfConsequenceBlock(node);
+    if (!ifBody)
+        return undefined;
+    return {
+        varName,
+        typeName: resolvedType,
+        narrowingRange: { startIndex: ifBody.startIndex, endIndex: ifBody.endIndex },
+    };
+};
+/** Infer the type of a literal AST node for TypeScript overload disambiguation. */
+const inferTsLiteralType = (node) => {
+    switch (node.type) {
+        case 'number':
+            return 'number';
+        case 'string':
+        case 'template_string':
+            return 'string';
+        case 'true':
+        case 'false':
+            return 'boolean';
+        case 'null':
+            return 'null';
+        case 'undefined':
+            return 'undefined';
+        case 'regex':
+            return 'RegExp';
+        default:
+            return undefined;
+    }
 };
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
@@ -521,4 +652,5 @@ export const typeConfig = {
     extractForLoopBinding,
     extractPendingAssignment,
     extractPatternBinding,
+    inferLiteralType: inferTsLiteralType,
 };