gitnexus 1.5.2 → 1.6.0

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

@@ -3,6 +3,10 @@ import type { SyntaxNode } from '../utils/ast-helpers.js';
 export type TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>) => void;
 /** Extracts type bindings from a parameter node into the env map */
 export type ParameterExtractor = (node: SyntaxNode, env: Map<string, string>) => void;
+/** Optionally locates the type-annotation AST node for a declaration node.
+ * Used by buildTypeEnv to populate declarationTypeNodes and constructorTypeMap.
+ * If absent, buildTypeEnv falls back to generic heuristics (childForFieldName('type'), etc). */
+export type DeclarationTypeNodeLocator = (node: SyntaxNode) => SyntaxNode | null;
 /** Minimal interface for checking whether a name is a known class/struct.
  *  Narrower than ReadonlySet — only `.has()` is used by extractors. */
 export type ClassNameLookup = {
@@ -19,10 +23,6 @@ export type ConstructorBindingScanner = (node: SyntaxNode) => {
     calleeName: string;
     receiverClassName?: string;
 } | undefined;
-/** Extracts a return type string from a method/function definition node.
- *  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
@@ -38,7 +38,7 @@ export type ConstructorTypeDetector = (node: SyntaxNode, classNames: ClassNameLo
  *  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.
+ *  Backed by SymbolTable.lookupCallableByName; passed via ForLoopExtractorContext.
  *  Conservative: returns undefined when the callee is ambiguous (0 or 2+ matches). */
 export interface ReturnTypeLookup {
     /** Processed type name after stripping wrappers (e.g., 'User' from 'Promise<User>').
@@ -130,6 +130,9 @@ export interface LanguageTypeConfig {
     readonly allowPatternBindingOverwrite?: boolean;
     /** Node types that represent typed declarations for this language */
     declarationNodeTypes: ReadonlySet<string>;
+    /** Optional: language-specific way to find a declaration's type-annotation node.
+     * Prefer providing this for grammars where the type is wrapped (e.g., C#, Kotlin, Swift). */
+    getDeclarationTypeNode?: DeclarationTypeNodeLocator;
     /** AST node types for for-each/for-in statements with explicit element types. */
     forLoopNodeTypes?: ReadonlySet<string>;
     /** Optional allowlist of AST node types on which extractPatternBinding should run.
@@ -150,9 +153,6 @@ export interface LanguageTypeConfig {
      *  Called on every AST node during buildTypeEnv walk; returns undefined for non-matches.
      *  The callee binding is unverified — the caller must confirm against the SymbolTable. */
     scanConstructorBinding?: ConstructorBindingScanner;
-    /** Extract return type from comment-based annotations (e.g. YARD @return [Type]).
-     *  Called as fallback when extractMethodSignature finds no AST-based return type. */
-    extractReturnType?: ReturnTypeExtractor;
     /** Extract loop variable → type binding from a for-each AST node. */
     extractForLoopBinding?: ForLoopExtractor;
     /** Extract pending assignment for Tier 2 propagation.

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

@@ -179,48 +179,6 @@ const scanConstructorBinding = (node) => {
         return undefined;
     return { varName: nameNode.text, calleeName };
 };
-/** Regex to extract @returns or @return from JSDoc comments: `@returns {Type}` */
-const JSDOC_RETURN_RE = /@returns?\s*\{([^}]+)\}/;
-/**
- * Minimal sanitization for JSDoc return types — preserves generic wrappers
- * (e.g. `Promise<User>`) so that extractReturnTypeName in call-processor
- * can apply WRAPPER_GENERICS unwrapping. Unlike normalizeJsDocType (which
- * strips generics), this only strips JSDoc-specific syntax markers.
- */
-const sanitizeReturnType = (raw) => {
-    let type = raw.trim();
-    // Strip JSDoc nullable/non-nullable prefixes: ?User → User, !User → User
-    if (type.startsWith('?') || type.startsWith('!'))
-        type = type.slice(1);
-    // Strip module: prefix — module:models.User → models.User
-    if (type.startsWith('module:'))
-        type = type.slice(7);
-    // Reject unions (ambiguous)
-    if (type.includes('|'))
-        return undefined;
-    if (!type)
-        return undefined;
-    return type;
-};
-/**
- * Extract return type from JSDoc `@returns {Type}` or `@return {Type}` annotation
- * preceding a function/method definition. Walks backwards through preceding siblings
- * looking for comment nodes containing the annotation.
- */
-const extractReturnType = (node) => {
-    let sibling = node.previousSibling;
-    while (sibling) {
-        if (sibling.type === 'comment') {
-            const match = JSDOC_RETURN_RE.exec(sibling.text);
-            if (match)
-                return sanitizeReturnType(match[1]);
-        }
-        else if (sibling.isNamed && sibling.type !== 'decorator')
-            break;
-        sibling = sibling.previousSibling;
-    }
-    return undefined;
-};
 const FOR_LOOP_NODE_TYPES = new Set(['for_in_statement']);
 /** TS function/method node types that carry a parameters list. */
 const TS_FUNCTION_NODE_TYPES = new Set([
@@ -448,8 +406,37 @@ const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, re
     if (loopVarName)
         scopeEnv.set(loopVarName, elementType);
 };
+/** Collect fieldAccess items from an object_pattern's destructured properties. */
+const collectDestructuredFields = (nameNode, receiver, scopeEnv) => {
+    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 } = obj` → 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 } = obj` → 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 });
+                }
+            }
+        }
+    }
+    return items;
+};
 /** TS/JS: const alias = u → variable_declarator with name/value fields.
- *  Also handles destructuring: `const { a, b } = obj` → N fieldAccess items. */
+ *  Also handles destructuring: `const { a, b } = obj` and `const { a } = fn()` → N fieldAccess items. */
 const extractPendingAssignment = (node, scopeEnv) => {
     for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
@@ -459,37 +446,48 @@ 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.
+        // Object destructuring from identifier: `const { address, name } = user`
         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 });
+            const items = collectDestructuredFields(nameNode, valueNode.text, scopeEnv);
+            if (items.length > 0)
+                return items;
+            continue;
+        }
+        // Object destructuring from call/await: `const { x } = fn()` or `const { x } = await fn()`
+        // Emits a synthetic callResult + N fieldAccess items resolved via fixpoint iteration.
+        if (nameNode.type === 'object_pattern') {
+            const callNode = unwrapAwait(valueNode);
+            if (callNode?.type === 'call_expression') {
+                const funcNode = callNode.childForFieldName('function');
+                if (funcNode) {
+                    let syntheticVar;
+                    let leadItem;
+                    if (funcNode.type === 'identifier') {
+                        syntheticVar = `__destr_${funcNode.text}_${callNode.startIndex}`;
+                        leadItem = { kind: 'callResult', lhs: syntheticVar, callee: funcNode.text };
                     }
-                }
-                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 });
+                    else if (funcNode.type === 'member_expression') {
+                        const obj = funcNode.childForFieldName('object');
+                        const prop = funcNode.childForFieldName('property');
+                        if (obj &&
+                            prop?.type === 'property_identifier' &&
+                            (obj.type === 'identifier' || obj.type === 'this')) {
+                            syntheticVar = `__destr_${prop.text}_${callNode.startIndex}`;
+                            leadItem = {
+                                kind: 'methodCallResult',
+                                lhs: syntheticVar,
+                                receiver: obj.text,
+                                method: prop.text,
+                            };
                         }
                     }
+                    if (syntheticVar && leadItem) {
+                        const fieldItems = collectDestructuredFields(nameNode, syntheticVar, scopeEnv);
+                        if (fieldItems.length > 0)
+                            return [leadItem, ...fieldItems];
+                    }
                 }
             }
-            if (items.length > 0)
-                return items;
             continue;
         }
         const lhs = nameNode.text;
@@ -656,7 +654,6 @@ export const typeConfig = {
     extractParameter,
     extractInitializer,
     scanConstructorBinding,
-    extractReturnType,
     extractForLoopBinding,
     extractPendingAssignment,
     extractPatternBinding,

package/dist/core/ingestion/utils/ast-helpers.d.ts

@@ -12,23 +12,25 @@ export declare const DEFINITION_CAPTURE_KEYS: readonly ["definition.function", "
 export declare const getDefinitionNodeFromCaptures: (captureMap: Record<string, SyntaxNode>) => SyntaxNode | null;
 /**
  * Node types that represent function/method definitions across languages.
- * Used to find the enclosing function for a call site.
+ * Used by parent-walk in call-processor, parse-worker, and type-env to detect
+ * enclosing function scope boundaries.
+ *
+ * INVARIANT: This set MUST be a superset of every language's
+ * MethodExtractionConfig.methodNodeTypes. When adding a new node type to a
+ * MethodExtractor config, add it here too — otherwise enclosing-function
+ * resolution will silently miss that node type during parent-walks.
  */
 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.
+ * AST node types that represent a class-like container (for HAS_METHOD edge extraction).
+ *
+ * INVARIANT: When a language config adds a new node type to `typeDeclarationNodes`,
+ * that type must also be added here AND to `CONTAINER_TYPE_TO_LABEL` below,
+ * otherwise `findEnclosingClassNode` won't recognize it and methods may get
+ * orphaned HAS_METHOD edges or incorrect labels.
  */
-export declare const FUNCTION_DECLARATION_TYPES: Set<string>;
-/** 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>;
-/** Check if a Kotlin function_declaration capture is inside a class_body (i.e., a method).
- *  Kotlin grammar uses function_declaration for both top-level functions and class methods.
- *  Returns true when the captured definition node has a class_body ancestor. */
-export declare function isKotlinClassMethod(captureNode: {
-    parent?: SyntaxNode | null;
-} | null | undefined): boolean;
 /**
  * Determine the graph node label from a tree-sitter capture map.
  * Handles language-specific reclassification via the provider's labelOverride hook
@@ -36,48 +38,36 @@ export declare function isKotlinClassMethod(captureNode: {
  * Returns null if the capture should be skipped (import, call, C/C++ duplicate, missing name).
  */
 export declare function getLabelFromCaptures(captureMap: Record<string, SyntaxNode>, provider: LanguageProvider): NodeLabel | null;
-/** Walk up AST to find enclosing class/struct/interface/impl, return its generateId or null.
+/** Enclosing class info: both the generated node ID and the bare class name. */
+export interface EnclosingClassInfo {
+    classId: string;
+    className: string;
+}
+/** Walk up AST to find enclosing class/struct/interface/impl, return its ID and name.
  *  For Go method_declaration nodes, extracts receiver type (e.g. `func (u *User) Save()` → User struct). */
+export declare const findEnclosingClassInfo: (node: SyntaxNode, filePath: string) => EnclosingClassInfo | null;
+/** Convenience wrapper: returns just the class ID string (backward compat). */
 export declare const findEnclosingClassId: (node: SyntaxNode, filePath: string) => string | null;
 /**
  * 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: SyntaxNode, siblingType: string, childType: string) => SyntaxNode | 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: NodeLabel;
-};
-export interface MethodSignature {
-    parameterCount: number | undefined;
-    /** Number of required (non-optional, non-default) parameters.
-     *  Only set when fewer than parameterCount — enables range-based arity filtering.
-     *  undefined means all parameters are required (or metadata unavailable). */
-    requiredParameterCount: number | undefined;
-    /** Per-parameter type names extracted via extractSimpleTypeName.
-     *  Only populated for languages with method overloading (Java, Kotlin, C#, C++).
-     *  undefined (not []) when no types are extractable — avoids empty array allocations. */
-    parameterTypes: string[] | undefined;
-    returnType: string | undefined;
-}
-/** Argument list node types shared between extractMethodSignature and countCallArguments. */
+/** Generic name extraction from a function-like AST node.
+ *  Tries `node.childForFieldName('name')?.text`, then scans children for
+ *  `identifier` / `property_identifier` / `simple_identifier`. */
+export declare const genericFuncName: (node: SyntaxNode) => string | null;
+/** AST node types that represent a method definition (for `inferFunctionLabel`). */
+export declare const METHOD_LABEL_NODE_TYPES: Set<string>;
+/** AST node types that represent a constructor definition (for `inferFunctionLabel`). */
+export declare const CONSTRUCTOR_LABEL_NODE_TYPES: Set<string>;
+/** Infer node label from AST node type for function-like nodes without a provider hook. */
+export declare const inferFunctionLabel: (nodeType: string) => NodeLabel;
+/** Argument list node types shared between countCallArguments and call-resolution helpers. */
 export declare const CALL_ARGUMENT_LIST_TYPES: Set<string>;
-/**
- * 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;
 /** Walk an AST node depth-first, returning the first descendant with the given type. */
-export declare function findDescendant(node: SyntaxNode, type: string): SyntaxNode | null;
+export declare function findDescendant(root: SyntaxNode, type: string): SyntaxNode | null;
 /** Extract the text content from a string or encapsed_string AST node. */
 export declare function extractStringContent(node: SyntaxNode | null | undefined): string | null;
-/** Check if a C/C++ function_definition is inside a class or struct body.
- *  Used by the C/C++ labelOverride to skip duplicate function captures
- *  that are already covered by definition.method queries. */
-export declare function isCppInsideClassOrStruct(functionNode: SyntaxNode): boolean;
 /** Find the first direct named child of a tree-sitter node matching the given type. */
 export declare function findChild(node: SyntaxNode, type: string): SyntaxNode | null;