gitnexus 1.4.8 → 1.4.10

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

@@ -278,6 +278,12 @@ export const extractVarName = (node) => {
         if (inner)
             return extractVarName(inner);
     }
+    // Swift: pattern node wraps a simple_identifier
+    if (node.type === 'pattern') {
+        const inner = node.firstNamedChild;
+        if (inner)
+            return extractVarName(inner);
+    }
     return undefined;
 };
 /** Node types for function/method parameters with type annotations */
@@ -701,105 +707,6 @@ export const extractReturnTypeName = (raw, depth = 0) => {
         return undefined;
     return text;
 };
-// ── Property declared-type extraction ────────────────────────────────────
-// Shared between parse-worker (worker path) and parsing-processor (sequential path).
-/**
- * Extract the declared type of a property/field from its AST definition node.
- * Handles cross-language patterns:
- * - TypeScript: `name: Type` → type_annotation child
- * - Java: `Type name` → type child on field_declaration
- * - C#: `Type Name { get; set; }` → type child on property_declaration
- * - Go: `Name Type` → type child on field_declaration
- * - Kotlin: `var name: Type` → variable_declaration child with type field
- *
- * Returns the normalized type name, or undefined if no type can be extracted.
- */
-export const extractPropertyDeclaredType = (definitionNode) => {
-    if (!definitionNode)
-        return undefined;
-    // Strategy 1: Look for a `type` or `type_annotation` named field
-    const typeNode = definitionNode.childForFieldName?.('type');
-    if (typeNode) {
-        const typeName = extractSimpleTypeName(typeNode);
-        if (typeName)
-            return typeName;
-        // Fallback: use the raw text (for complex types like User[] or List<User>)
-        const text = typeNode.text?.trim();
-        if (text && text.length < 100)
-            return text;
-    }
-    // Strategy 2: Walk children looking for type_annotation (TypeScript pattern)
-    for (let i = 0; i < definitionNode.childCount; i++) {
-        const child = definitionNode.child(i);
-        if (!child)
-            continue;
-        if (child.type === 'type_annotation') {
-            // Type annotation has the actual type as a child
-            for (let j = 0; j < child.childCount; j++) {
-                const typeChild = child.child(j);
-                if (typeChild && typeChild.type !== ':') {
-                    const typeName = extractSimpleTypeName(typeChild);
-                    if (typeName)
-                        return typeName;
-                    const text = typeChild.text?.trim();
-                    if (text && text.length < 100)
-                        return text;
-                }
-            }
-        }
-    }
-    // Strategy 3: For Java field_declaration, the type is a sibling of variable_declarator
-    // AST: (field_declaration type: (type_identifier) declarator: (variable_declarator ...))
-    const parentDecl = definitionNode.parent;
-    if (parentDecl) {
-        const parentType = parentDecl.childForFieldName?.('type');
-        if (parentType) {
-            const typeName = extractSimpleTypeName(parentType);
-            if (typeName)
-                return typeName;
-        }
-    }
-    // Strategy 4: Kotlin property_declaration — type is nested inside variable_declaration child
-    // AST: (property_declaration (variable_declaration (simple_identifier) ":" (user_type (type_identifier))))
-    // Kotlin's variable_declaration has NO named 'type' field — children are all positional.
-    for (let i = 0; i < definitionNode.childCount; i++) {
-        const child = definitionNode.child(i);
-        if (child?.type === 'variable_declaration') {
-            // Try named field first (works for other languages sharing this strategy)
-            const varType = child.childForFieldName?.('type');
-            if (varType) {
-                const typeName = extractSimpleTypeName(varType);
-                if (typeName)
-                    return typeName;
-                const text = varType.text?.trim();
-                if (text && text.length < 100)
-                    return text;
-            }
-            // Fallback: walk unnamed children for user_type / type_identifier (Kotlin)
-            for (let j = 0; j < child.namedChildCount; j++) {
-                const varChild = child.namedChild(j);
-                if (varChild && (varChild.type === 'user_type' || varChild.type === 'type_identifier'
-                    || varChild.type === 'nullable_type' || varChild.type === 'generic_type')) {
-                    const typeName = extractSimpleTypeName(varChild);
-                    if (typeName)
-                        return typeName;
-                }
-            }
-        }
-    }
-    // Strategy 5: PHP @var PHPDoc — look for preceding comment with @var Type
-    // Handles pre-PHP-7.4 code: /** @var Address */ public $address;
-    const prevSibling = definitionNode.previousNamedSibling ?? definitionNode.parent?.previousNamedSibling;
-    if (prevSibling?.type === 'comment') {
-        const commentText = prevSibling.text;
-        const varMatch = commentText?.match(/@var\s+([A-Z][\w\\]*)/);
-        if (varMatch) {
-            // Strip namespace prefix: \App\Models\User → User
-            const raw = varMatch[1];
-            const base = raw.includes('\\') ? raw.split('\\').pop() : raw;
-            if (base && /^[A-Z]\w*$/.test(base))
-                return base;
-        }
-    }
-    return undefined;
-};
+// extractPropertyDeclaredType removed — all 14 languages register a FieldExtractor
+// via defineLanguage() which is the single source of truth for Property metadata
+// (declaredType, visibility, isStatic, isReadonly).

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

@@ -1,8 +1,28 @@
-import { extractSimpleTypeName, extractVarName, hasTypeAnnotation } from './shared.js';
-import { findChild } from '../resolvers/utils.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
@@ -53,8 +73,21 @@ const extractInitializer = (node, env, classNames) => {
     const varName = extractVarName(pattern) ?? pattern.text;
     if (!varName || env.has(varName))
         return;
-    // Find call_expression in the value
-    const callExpr = findChild(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;
@@ -99,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;
@@ -129,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 */
@@ -75,6 +75,8 @@ export type PendingAssignment = {
     kind: 'callResult';
     lhs: string;
     callee: string;
+    calleeFqn?: string;
+    line?: number;
 } | {
     kind: 'fieldAccess';
     lhs: string;

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

@@ -1,6 +1,6 @@
 import type Parser from 'tree-sitter';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-import type { NodeLabel } from '../graph/types.js';
+import type { NodeLabel } from '../../graph/types.js';
+import type { LanguageProvider } from '../language-provider.js';
 /** Tree-sitter AST node. Re-exported for use across ingestion modules. */
 export type SyntaxNode = Parser.SyntaxNode;
 /**
@@ -29,20 +29,13 @@ export declare const CONTAINER_TYPE_TO_LABEL: Record<string, string>;
 export declare function isKotlinClassMethod(captureNode: {
     parent?: any;
 } | null | undefined): boolean;
-/**
- * C/C++: check if a Function capture is inside a class/struct body.
- * If true, the function is already captured by @definition.method and should be skipped
- * to prevent double-indexing in globalIndex.
- */
-export declare function isCppDuplicateClassFunction(functionNode: {
-    parent?: any;
-} | null | undefined, nodeLabel: string, language: SupportedLanguages): boolean;
 /**
  * Determine the graph node label from a tree-sitter capture map.
- * Handles language-specific reclassification (C/C++ duplicate skipping, Kotlin Method promotion).
+ * Handles language-specific reclassification via the provider's labelOverride hook
+ * (e.g. C/C++ duplicate skipping, Kotlin Method promotion).
  * Returns null if the capture should be skipped (import, call, C/C++ duplicate, missing name).
  */
-export declare function getLabelFromCaptures(captureMap: Record<string, any>, language: SupportedLanguages): NodeLabel | null;
+export declare function getLabelFromCaptures(captureMap: Record<string, any>, provider: LanguageProvider): NodeLabel | null;
 /** 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;
@@ -57,7 +50,7 @@ export declare const findSiblingChild: (parent: any, siblingType: string, childT
  */
 export declare const extractFunctionName: (node: SyntaxNode) => {
     funcName: string | null;
-    label: string;
+    label: NodeLabel;
 };
 export interface MethodSignature {
     parameterCount: number | undefined;
@@ -78,3 +71,13 @@ export declare const CALL_ARGUMENT_LIST_TYPES: Set<string>;
  * 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: any, type: string): any;
+/** Extract the text content from a string or encapsed_string AST node. */
+export declare function extractStringContent(node: any): 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;