gitnexus 1.4.7 → 1.4.8

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,
 };

package/dist/core/ingestion/utils.d.ts

@@ -1,24 +1,4 @@
-import type Parser from 'tree-sitter';
 import { SupportedLanguages } from '../../config/supported-languages.js';
-/** Tree-sitter AST node. Re-exported for use across ingestion modules. */
-export type SyntaxNode = Parser.SyntaxNode;
-/**
- * Ordered list of definition capture keys for tree-sitter query matches.
- * Used to extract the definition node from a capture map.
- */
-export declare const DEFINITION_CAPTURE_KEYS: readonly ["definition.function", "definition.class", "definition.interface", "definition.method", "definition.struct", "definition.enum", "definition.namespace", "definition.module", "definition.trait", "definition.impl", "definition.type", "definition.const", "definition.static", "definition.typedef", "definition.macro", "definition.union", "definition.property", "definition.record", "definition.delegate", "definition.annotation", "definition.constructor", "definition.template"];
-/** Extract the definition node from a tree-sitter query capture map. */
-export declare const getDefinitionNodeFromCaptures: (captureMap: Record<string, any>) => SyntaxNode | null;
-/**
- * Node types that represent function/method definitions across languages.
- * Used to find the enclosing function for a call site.
- */
-export declare const FUNCTION_NODE_TYPES: Set<string>;
-/**
- * Node types for standard function declarations that need C/C++ declarator handling.
- * Used by extractFunctionName to determine how to extract the function name.
- */
-export declare const FUNCTION_DECLARATION_TYPES: Set<string>;
 /**
  * Built-in function/method names that should not be tracked as call targets.
  * Covers JS/TS, Python, Kotlin, C/C++, PHP, Swift standard library functions.
@@ -26,113 +6,15 @@ export declare const FUNCTION_DECLARATION_TYPES: Set<string>;
 export declare const BUILT_IN_NAMES: Set<string>;
 /** Check if a name is a built-in function or common noise that should be filtered out */
 export declare const isBuiltInOrNoise: (name: string) => boolean;
-/** AST node types that represent a class-like container (for HAS_METHOD edge extraction) */
-export declare const CLASS_CONTAINER_TYPES: Set<string>;
-export declare const CONTAINER_TYPE_TO_LABEL: Record<string, string>;
-/** Walk up AST to find enclosing class/struct/interface/impl, return its generateId or null.
- *  For Go method_declaration nodes, extracts receiver type (e.g. `func (u *User) Save()` → User struct). */
-export declare const findEnclosingClassId: (node: any, filePath: string) => string | null;
-/**
- * Extract function name and label from a function_definition or similar AST node.
- * Handles C/C++ qualified_identifier (ClassName::MethodName) and other language patterns.
- */
-export declare const extractFunctionName: (node: SyntaxNode) => {
-    funcName: string | null;
-    label: string;
-};
 /**
  * Yield control to the event loop so spinners/progress can render.
  * Call periodically in hot loops to prevent UI freezes.
  */
 export declare const yieldToEventLoop: () => Promise<void>;
-/**
- * Find a child of `childType` within a sibling node of `siblingType`.
- * Used for Kotlin AST traversal where visibility_modifier lives inside a modifiers sibling.
- */
-export declare const findSiblingChild: (parent: any, siblingType: string, childType: string) => any | null;
 /**
  * Map file extension to SupportedLanguage enum
  */
 export declare const getLanguageFromFilename: (filename: string) => SupportedLanguages | null;
-export interface MethodSignature {
-    parameterCount: number | undefined;
-    returnType: string | undefined;
-}
-/**
- * Extract parameter count and return type text from an AST method/function node.
- * Works across languages by looking for common AST patterns.
- */
-export declare const extractMethodSignature: (node: SyntaxNode | null | undefined) => MethodSignature;
-/**
- * Count direct arguments for a call expression across common tree-sitter grammars.
- * Returns undefined when the argument container cannot be located cheaply.
- */
-export declare const countCallArguments: (callNode: SyntaxNode | null | undefined) => number | undefined;
-type CallForm = 'free' | 'member' | 'constructor';
-/**
- * Infer whether a captured call site is a free call, member call, or constructor.
- * Returns undefined if the form cannot be determined.
- *
- * Works by inspecting the AST structure between callNode (@call) and nameNode (@call.name).
- * No tree-sitter query changes needed — the distinction is in the node types.
- */
-export declare const inferCallForm: (callNode: SyntaxNode, nameNode: SyntaxNode) => CallForm | undefined;
-export declare const extractReceiverName: (nameNode: SyntaxNode) => string | undefined;
-/**
- * Extract the raw receiver AST node for a member call.
- * Unlike extractReceiverName, this returns the receiver node regardless of its type —
- * including call_expression / method_invocation nodes that appear in chained calls
- * like `svc.getUser().save()`.
- *
- * Returns undefined when the call is not a member call or when no receiver node
- * can be found (e.g. top-level free calls).
- */
-export declare const extractReceiverNode: (nameNode: SyntaxNode) => SyntaxNode | undefined;
 export declare const isVerboseIngestionEnabled: () => boolean;
-/** Node types representing call expressions across supported languages. */
-export declare const CALL_EXPRESSION_TYPES: Set<string>;
-/**
- * Hard limit on chain depth to prevent runaway recursion.
- * For `a.b().c().d()`, the chain has depth 2 (b and c before d).
- */
-export declare const MAX_CHAIN_DEPTH = 3;
-/**
- * Walk a receiver AST node that is itself a call expression, accumulating the
- * chain of intermediate method names up to MAX_CHAIN_DEPTH.
- *
- * For `svc.getUser().save()`, called with the receiver of `save` (getUser() call):
- *   returns { chain: ['getUser'], baseReceiverName: 'svc' }
- *
- * For `a.b().c().d()`, called with the receiver of `d` (c() call):
- *   returns { chain: ['b', 'c'], baseReceiverName: 'a' }
- */
-export declare function extractCallChain(receiverCallNode: SyntaxNode): {
-    chain: string[];
-    baseReceiverName: string | undefined;
-} | undefined;
-/** One step in a mixed receiver chain. */
-export type MixedChainStep = {
-    kind: 'field' | 'call';
-    name: string;
-};
-/**
- * Walk a receiver AST node that may interleave field accesses and method calls,
- * building a unified chain of steps up to MAX_CHAIN_DEPTH.
- *
- * For `svc.getUser().address.save()`, called with the receiver of `save`
- * (`svc.getUser().address`, a field access node):
- *   returns { chain: [{ kind:'call', name:'getUser' }, { kind:'field', name:'address' }],
- *             baseReceiverName: 'svc' }
- *
- * For `user.getAddress().city.getName()`, called with receiver of `getName`
- * (`user.getAddress().city`):
- *   returns { chain: [{ kind:'call', name:'getAddress' }, { kind:'field', name:'city' }],
- *             baseReceiverName: 'user' }
- *
- * Pure field chains and pure call chains are special cases (all steps same kind).
- */
-export declare function extractMixedChain(receiverNode: SyntaxNode): {
-    chain: MixedChainStep[];
-    baseReceiverName: string | undefined;
-} | undefined;
-export {};
+export * from './ast-helpers.js';
+export * from './call-analysis.js';