@duytransipher/gitnexus 1.4.6-sipher.0

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

@@ -0,0 +1,2 @@
+import type { LanguageTypeConfig } from './types.js';
+export declare const typeConfig: LanguageTypeConfig;

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

@@ -0,0 +1,137 @@
+import { extractSimpleTypeName, extractVarName, findChildByType, hasTypeAnnotation } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set([
+    'property_declaration',
+]);
+/** Swift: let x: Foo = ... */
+const extractDeclaration = (node, env) => {
+    // Swift property_declaration has pattern and type_annotation
+    const pattern = node.childForFieldName('pattern')
+        ?? findChildByType(node, 'pattern');
+    const typeAnnotation = node.childForFieldName('type')
+        ?? findChildByType(node, 'type_annotation');
+    if (!pattern || !typeAnnotation)
+        return;
+    const varName = extractVarName(pattern) ?? pattern.text;
+    const typeName = extractSimpleTypeName(typeAnnotation);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+/** Swift: parameter → name: type */
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'parameter') {
+        nameNode = node.childForFieldName('name')
+            ?? node.childForFieldName('internal_name');
+        typeNode = node.childForFieldName('type');
+    }
+    else {
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+/** Swift: let user = User(name: "alice") — infer type from call when callee is a known class.
+ *  Swift initializers are syntactically identical to function calls, so we verify
+ *  against classNames (which may include cross-file SymbolTable lookups). */
+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'))
+        return;
+    // Find pattern (variable name)
+    const pattern = node.childForFieldName('pattern') ?? findChildByType(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');
+    if (!callExpr)
+        return;
+    const callee = callExpr.firstNamedChild;
+    if (!callee)
+        return;
+    // Direct call: User(name: "alice")
+    if (callee.type === 'simple_identifier') {
+        const calleeName = callee.text;
+        if (calleeName && classNames.has(calleeName)) {
+            env.set(varName, calleeName);
+        }
+        return;
+    }
+    // Explicit init: User.init(name: "alice") — navigation_expression with .init suffix
+    if (callee.type === 'navigation_expression') {
+        const receiver = callee.firstNamedChild;
+        const suffix = callee.lastNamedChild;
+        if (receiver?.type === 'simple_identifier' && suffix?.text === 'init') {
+            const calleeName = receiver.text;
+            if (calleeName && classNames.has(calleeName)) {
+                env.set(varName, calleeName);
+            }
+        }
+    }
+};
+/** Swift: let user = User(name: "alice") — scan property_declaration for constructor binding */
+const scanConstructorBinding = (node) => {
+    if (node.type !== 'property_declaration')
+        return undefined;
+    if (hasTypeAnnotation(node))
+        return undefined;
+    const pattern = node.childForFieldName('pattern');
+    if (!pattern)
+        return undefined;
+    const varName = pattern.text;
+    if (!varName)
+        return undefined;
+    let callExpr = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'call_expression') {
+            callExpr = child;
+            break;
+        }
+    }
+    if (!callExpr)
+        return undefined;
+    const callee = callExpr.firstNamedChild;
+    if (!callee)
+        return undefined;
+    if (callee.type === 'simple_identifier') {
+        return { varName, calleeName: callee.text };
+    }
+    if (callee.type === 'navigation_expression') {
+        const receiver = callee.firstNamedChild;
+        const suffix = callee.lastNamedChild;
+        if (receiver?.type === 'simple_identifier' && suffix?.text === 'init') {
+            return { varName, calleeName: receiver.text };
+        }
+        // General qualified call: service.getUser() → extract method name.
+        // tree-sitter-swift may wrap the identifier in navigation_suffix, so
+        // check both direct simple_identifier and navigation_suffix > simple_identifier.
+        if (suffix?.type === 'simple_identifier') {
+            return { varName, calleeName: suffix.text };
+        }
+        if (suffix?.type === 'navigation_suffix') {
+            const inner = suffix.lastNamedChild;
+            if (inner?.type === 'simple_identifier') {
+                return { varName, calleeName: inner.text };
+            }
+        }
+    }
+    return undefined;
+};
+export const typeConfig = {
+    declarationNodeTypes: DECLARATION_NODE_TYPES,
+    extractDeclaration,
+    extractParameter,
+    extractInitializer,
+    scanConstructorBinding,
+};

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

@@ -0,0 +1,127 @@
+import type { SyntaxNode } from '../utils.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 */
+export type ParameterExtractor = (node: SyntaxNode, env: Map<string, string>) => void;
+/** Minimal interface for checking whether a name is a known class/struct.
+ *  Narrower than ReadonlySet — only `.has()` is used by extractors. */
+export type ClassNameLookup = {
+    has(name: string): boolean;
+};
+/** Extracts type bindings from a constructor-call initializer, with access to known class names */
+export type InitializerExtractor = (node: SyntaxNode, env: Map<string, string>, classNames: ClassNameLookup) => void;
+/** Scans an AST node for untyped `var = callee()` patterns for return-type inference.
+ *  Returns { varName, calleeName } if the node matches, undefined otherwise.
+ *  `receiverClassName` — optional hint for method calls on known receivers
+ *  (e.g. $this->getUser() in PHP provides the enclosing class name). */
+export type ConstructorBindingScanner = (node: SyntaxNode) => {
+    varName: string;
+    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;
+/** 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). */
+export interface ReturnTypeLookup {
+    /** Processed type name after stripping wrappers (e.g., 'User' from 'Promise<User>').
+     *  Use for call-result variable bindings (`const b = foo()`). */
+    lookupReturnType(callee: string): string | undefined;
+    /** Raw return type as declared in the symbol (e.g., '[]User', 'List<User>').
+     *  Use for iterable-element extraction (`for v := range foo()`). */
+    lookupRawReturnType(callee: string): string | undefined;
+}
+/** Context object passed to ForLoopExtractor.
+ *  Groups the four parameters that were previously positional. */
+export interface ForLoopExtractorContext {
+    /** Mutable type-env for the current scope — extractor writes bindings here */
+    scopeEnv: Map<string, string>;
+    /** Maps `scope\0varName` to the declaration's type annotation AST node */
+    declarationTypeNodes: ReadonlyMap<string, SyntaxNode>;
+    /** Current scope key, e.g. `"process@42"` */
+    scope: string;
+    /** Resolves a callee name to its declared return type (undefined = unknown/ambiguous) */
+    returnTypeLookup: ReturnTypeLookup;
+}
+/** Extracts loop variable type binding from a for-each statement. */
+export type ForLoopExtractor = (node: SyntaxNode, ctx: ForLoopExtractorContext) => void;
+/** Discriminated union for pending Tier-2 propagation items.
+ *  - `copy`       — `const b = a` (identifier alias, propagate a's type to b)
+ *  - `callResult` — `const b = foo()` (bind b to foo's declared return type) */
+export type PendingAssignment = {
+    kind: 'copy';
+    lhs: string;
+    rhs: string;
+} | {
+    kind: 'callResult';
+    lhs: string;
+    callee: string;
+};
+/** Extracts a pending assignment for Tier 2 propagation.
+ *  Returns a PendingAssignment when the RHS is a bare identifier (`copy`) or a
+ *  call expression (`callResult`) and the LHS has no resolved type yet.
+ *  Returns undefined if the node is not a matching assignment. */
+export type PendingAssignmentExtractor = (node: SyntaxNode, scopeEnv: ReadonlyMap<string, string>) => PendingAssignment | undefined;
+/** 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).
+ *  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.
+ *  @param declarationTypeNodes  Maps `scope\0varName` to the original declaration's type
+ *    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;
+/** Per-language type extraction configuration */
+export interface LanguageTypeConfig {
+    /** Allow pattern binding to overwrite existing scopeEnv entries.
+     *  WARNING: Enables function-scope type pollution. Only for languages with
+     *  smart-cast semantics (e.g., Kotlin `when/is`) where the subject variable
+     *  already exists in scopeEnv from its declaration. */
+    readonly allowPatternBindingOverwrite?: boolean;
+    /** Node types that represent typed declarations for this language */
+    declarationNodeTypes: ReadonlySet<string>;
+    /** 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.
+     *  When present, extractPatternBinding is only invoked for nodes whose type is in this set,
+     *  short-circuiting the call for all other node types. When absent, every node is passed to
+     *  extractPatternBinding (legacy behaviour). */
+    patternBindingNodeTypes?: ReadonlySet<string>;
+    /** Extract a (varName → typeName) binding from a declaration node */
+    extractDeclaration: TypeBindingExtractor;
+    /** Extract a (varName → typeName) binding from a parameter node */
+    extractParameter: ParameterExtractor;
+    /** Extract a (varName → typeName) binding from a constructor-call initializer.
+     *  Called as fallback when extractDeclaration produces no binding for a declaration node.
+     *  Only for languages with syntactic constructor markers (new, composite_literal, ::new).
+     *  Receives classNames — the set of class/struct names visible in the current file's AST. */
+    extractInitializer?: InitializerExtractor;
+    /** Scan for untyped `var = callee()` assignments for return-type inference.
+     *  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.
+     *  Called on declaration/assignment nodes; returns a PendingAssignment when the RHS
+     *  is a bare identifier (copy) or call expression (callResult) and the LHS has no
+     *  resolved type yet. Language-specific because AST shapes differ widely. */
+    extractPendingAssignment?: PendingAssignmentExtractor;
+    /** Extract a typed variable binding from a pattern-matching construct.
+     *  Called on every AST node; returns { varName, typeName } when the node introduces a new
+     *  typed variable via pattern matching (e.g. `if let Some(x) = opt`, `x instanceof T t`).
+     *  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;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+import type { LanguageTypeConfig } from './types.js';
+export declare const typeConfig: LanguageTypeConfig;