@zuvia-software-solutions/code-mapper 1.4.0

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

@@ -0,0 +1,290 @@
+// code-mapper/src/core/ingestion/type-extractors/rust.ts
+/** @file rust.ts
+ *  @description Type extraction for Rust (let bindings, pattern matching, struct literals) */
+import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, unwrapAwait, extractGenericTypeArgs } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set([
+    'let_declaration',
+    'let_condition',
+]);
+// Walk up the AST to find the enclosing impl block and extract the implementing type name
+const findEnclosingImplType = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (current.type === 'impl_item') {
+            // The 'type' field holds the implementing type (e.g., `impl User { ... }`)
+            const typeNode = current.childForFieldName('type');
+            if (typeNode)
+                return extractSimpleTypeName(typeNode);
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+// Extract the type name from a struct_pattern's 'type' field
+// Handles both simple `User { .. }` and scoped `Message::Data { .. }`
+const extractStructPatternType = (structPattern) => {
+    const typeNode = structPattern.childForFieldName('type');
+    if (!typeNode)
+        return undefined;
+    return extractSimpleTypeName(typeNode);
+};
+// Recursively scan a pattern tree for captured_pattern nodes (x @ StructType { .. })
+// and extract variable -> type bindings from them
+const extractCapturedPatternBindings = (pattern, env) => {
+    if (pattern.type === 'captured_pattern') {
+        // captured_pattern: identifier @ inner_pattern
+        // The first named child is the identifier, followed by the inner pattern
+        const nameNode = pattern.firstNamedChild;
+        if (!nameNode || nameNode.type !== 'identifier')
+            return;
+        // Find the struct_pattern child -- that gives us the type
+        for (let i = 0; i < pattern.namedChildCount; i++) {
+            const child = pattern.namedChild(i);
+            if (child?.type === 'struct_pattern') {
+                const typeName = extractStructPatternType(child);
+                if (typeName)
+                    env.set(nameNode.text, typeName);
+                return;
+            }
+        }
+        return;
+    }
+    // Recurse into tuple_struct_pattern children to find nested captured_patterns
+    // e.g., Some(user @ User { .. })
+    if (pattern.type === 'tuple_struct_pattern') {
+        for (let i = 0; i < pattern.namedChildCount; i++) {
+            const child = pattern.namedChild(i);
+            if (child)
+                extractCapturedPatternBindings(child, env);
+        }
+    }
+};
+// Rust: let x: Foo = ... | if let / while let pattern bindings
+const extractDeclaration = (node, env) => {
+    if (node.type === 'let_condition') {
+        // if let / while let: extract type bindings from pattern matching
+        //
+        // Supported patterns:
+        // - captured_pattern: `if let user @ User { .. } = expr` -> user: User
+        // - tuple_struct_pattern with nested captured_pattern:
+        //   `if let Some(user @ User { .. }) = expr` -> user: User
+        //
+        // NOT supported (requires generic unwrapping):
+        // - `if let Some(x) = opt` where opt: Option<T> -> x: T
+        //
+        // struct_pattern without capture (`if let User { name } = expr`)
+        // destructures fields -- individual field types are unknown without
+        // field-type resolution, so no bindings are extracted
+        const pattern = node.childForFieldName('pattern');
+        if (!pattern)
+            return;
+        extractCapturedPatternBindings(pattern, env);
+        return;
+    }
+    // Standard let_declaration: let x: Foo = ...
+    const pattern = node.childForFieldName('pattern');
+    const typeNode = node.childForFieldName('type');
+    if (!pattern || !typeNode)
+        return;
+    const varName = extractVarName(pattern);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+// Rust: let x = User::new(), let x = User::default(), or let x = User { ... }
+const extractInitializer = (node, env, _classNames) => {
+    // Skip if there's an explicit type annotation -- Tier 0 already handled it
+    if (node.childForFieldName('type') !== null)
+        return;
+    const pattern = node.childForFieldName('pattern');
+    const value = node.childForFieldName('value');
+    if (!pattern || !value)
+        return;
+    // Rust struct literal: let user = User { name: "alice", age: 30 }
+    // tree-sitter-rust: struct_expression with 'name' field holding the type
+    if (value.type === 'struct_expression') {
+        const typeNode = value.childForFieldName('name');
+        if (!typeNode)
+            return;
+        const rawType = extractSimpleTypeName(typeNode);
+        if (!rawType)
+            return;
+        // Resolve Self to the actual struct/enum name from the enclosing impl block
+        const typeName = rawType === 'Self' ? findEnclosingImplType(node) : rawType;
+        const varName = extractVarName(pattern);
+        if (varName && typeName)
+            env.set(varName, typeName);
+        return;
+    }
+    if (value.type !== 'call_expression')
+        return;
+    const func = value.childForFieldName('function');
+    if (!func || func.type !== 'scoped_identifier')
+        return;
+    const nameField = func.childForFieldName('name');
+    // Only match ::new() and ::default() -- the two idiomatic Rust constructors
+    // Deliberately excludes ::from(), ::with_capacity(), etc. to avoid false positives
+    // (e.g. String::from("x") is not necessarily the "String" type we want for method resolution)
+    if (!nameField || (nameField.text !== 'new' && nameField.text !== 'default'))
+        return;
+    const pathField = func.childForFieldName('path');
+    if (!pathField)
+        return;
+    const rawType = extractSimpleTypeName(pathField);
+    if (!rawType)
+        return;
+    // Resolve Self to the actual struct/enum name from the enclosing impl block
+    const typeName = rawType === 'Self' ? findEnclosingImplType(node) : rawType;
+    const varName = extractVarName(pattern);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+// Rust: parameter -> pattern: type
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'parameter') {
+        nameNode = node.childForFieldName('pattern');
+        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);
+};
+// Rust: let user = get_user("alice") -- let_declaration with call_expression value, no type annotation
+// Skips annotated declarations (handled by extractDeclaration) and ::new()/ ::default()
+// (handled by extractInitializer). Unwraps mut_pattern for inner identifier
+const scanConstructorBinding = (node) => {
+    if (node.type !== 'let_declaration')
+        return undefined;
+    if (hasTypeAnnotation(node))
+        return undefined;
+    let patternNode = node.childForFieldName('pattern');
+    if (!patternNode)
+        return undefined;
+    if (patternNode.type === 'mut_pattern') {
+        patternNode = patternNode.firstNamedChild;
+        if (!patternNode)
+            return undefined;
+    }
+    if (patternNode.type !== 'identifier')
+        return undefined;
+    // Unwrap `.await`: `let user = get_user().await` -> await_expression wraps call_expression
+    const value = unwrapAwait(node.childForFieldName('value'));
+    if (!value || value.type !== 'call_expression')
+        return undefined;
+    const func = value.childForFieldName('function');
+    if (!func)
+        return undefined;
+    if (func.type === 'scoped_identifier') {
+        const methodName = func.lastNamedChild;
+        if (methodName?.text === 'new' || methodName?.text === 'default')
+            return undefined;
+    }
+    const calleeName = extractSimpleTypeName(func);
+    if (!calleeName)
+        return undefined;
+    return { varName: patternNode.text, calleeName };
+};
+// Rust: let alias = u; -> let_declaration with pattern + value fields
+const extractPendingAssignment = (node, scopeEnv) => {
+    if (node.type !== 'let_declaration')
+        return undefined;
+    const pattern = node.childForFieldName('pattern');
+    const value = node.childForFieldName('value');
+    if (!pattern || !value)
+        return undefined;
+    const lhs = extractVarName(pattern);
+    if (!lhs || scopeEnv.has(lhs))
+        return undefined;
+    if (value.type === 'identifier')
+        return { lhs, rhs: value.text };
+    return undefined;
+};
+// Rust pattern binding extractor for `if let` / `while let` constructs that unwrap
+// enum variants and introduce new typed variables
+//
+// Supported patterns:
+// - `if let Some(x) = opt`  -> x: T  (opt: Option<T>, T via NULLABLE_WRAPPER_TYPES)
+// - `if let Ok(x) = res`    -> x: T  (res: Result<T, E>, T from declarationTypeNodes)
+//
+// Complements captured_pattern support in extractDeclaration (which handles
+// `if let x @ Struct { .. } = expr` but NOT tuple struct unwrapping)
+//
+// Conservative: returns undefined when source variable's type is unknown, wrapper is
+// not a known single-unwrap variant, or value is not a simple identifier
+const extractPatternBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
+    if (node.type !== 'let_condition')
+        return undefined;
+    const patternNode = node.childForFieldName('pattern');
+    const valueNode = node.childForFieldName('value');
+    if (!patternNode || !valueNode)
+        return undefined;
+    // Only handle tuple_struct_pattern: Some(x) or Ok(x)
+    if (patternNode.type !== 'tuple_struct_pattern')
+        return undefined;
+    // Extract the wrapper type name: Some | Ok
+    const wrapperTypeNode = patternNode.childForFieldName('type');
+    if (!wrapperTypeNode)
+        return undefined;
+    const wrapperName = extractSimpleTypeName(wrapperTypeNode);
+    if (wrapperName !== 'Some' && wrapperName !== 'Ok' && wrapperName !== 'Err')
+        return undefined;
+    // Extract the inner variable name from the single child of the tuple_struct_pattern
+    // `Some(x)` -> the first named child after the type field is the identifier
+    // tree-sitter-rust: tuple_struct_pattern has 'type' field + unnamed children for args
+    let innerVar;
+    for (let i = 0; i < patternNode.namedChildCount; i++) {
+        const child = patternNode.namedChild(i);
+        if (!child)
+            continue;
+        // Skip the type node itself
+        if (child === wrapperTypeNode)
+            continue;
+        if (child.type === 'identifier') {
+            innerVar = child.text;
+            break;
+        }
+    }
+    if (!innerVar)
+        return undefined;
+    // The value must be a simple identifier so we can look it up in scopeEnv
+    const sourceVarName = valueNode.type === 'identifier' ? valueNode.text : undefined;
+    if (!sourceVarName)
+        return undefined;
+    // For `Some(x)`: Option<T> is already unwrapped to T in scopeEnv (via NULLABLE_WRAPPER_TYPES)
+    // For `Ok(x)`: Result<T, E> stores "Result" in scopeEnv -- must use declarationTypeNodes
+    if (wrapperName === 'Some') {
+        const innerType = scopeEnv.get(sourceVarName);
+        if (!innerType)
+            return undefined;
+        return { varName: innerVar, typeName: innerType };
+    }
+    // wrapperName === 'Ok' or 'Err': look up the Result<T, E> type AST node
+    // Ok(x) -> extract T (typeArgs[0]), Err(e) -> extract E (typeArgs[1])
+    const typeNodeKey = `${scope}\0${sourceVarName}`;
+    const typeAstNode = declarationTypeNodes.get(typeNodeKey);
+    if (!typeAstNode)
+        return undefined;
+    const typeArgs = extractGenericTypeArgs(typeAstNode);
+    const argIndex = wrapperName === 'Err' ? 1 : 0;
+    if (typeArgs.length < argIndex + 1)
+        return undefined;
+    return { varName: innerVar, typeName: typeArgs[argIndex] };
+};
+export const typeConfig = {
+    declarationNodeTypes: DECLARATION_NODE_TYPES,
+    extractDeclaration,
+    extractInitializer,
+    extractParameter,
+    scanConstructorBinding,
+    extractPendingAssignment,
+    extractPatternBinding,
+};

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

@@ -0,0 +1,81 @@
+/** @file shared.ts
+ *  @description Shared utilities for type extraction across all languages */
+import type { SyntaxNode } from '../utils.js';
+/**
+ * Extract the simple type name from a type AST node
+ *
+ * Handles generic types (List<User> -> List), qualified names (models.User -> User),
+ * and nullable types (User? -> User). Returns undefined for complex types
+ */
+export declare const extractSimpleTypeName: (typeNode: SyntaxNode) => string | undefined;
+/**
+ * Extract variable name from a declarator or pattern node
+ *
+ * Returns the simple identifier text, or undefined for destructuring/complex patterns
+ */
+export declare const extractVarName: (node: SyntaxNode) => string | undefined;
+/** Node types for function/method parameters with type annotations */
+export declare const TYPED_PARAMETER_TYPES: Set<string>;
+/**
+ * Extract type arguments from a generic type node
+ *
+ * e.g. List<User, String> -> ['User', 'String'], Vec<User> -> ['User']
+ * Used by extractSimpleTypeName to unwrap nullable wrappers (Optional<User> -> User)
+ *
+ * Handles language-specific AST structures:
+ * - TS/Java/Rust/Go: generic_type > type_arguments > type nodes
+ * - C#: generic_type > type_argument_list > type nodes
+ * - Kotlin: generic_type > type_arguments > type_projection > type nodes
+ *
+ * Note: Go slices/maps use slice_type/map_type, not generic_type -- those are
+ * NOT handled here; use language-specific extractors for Go container types
+ *
+ * @param typeNode A generic_type or parameterized_type AST node (returns [] for non-generic types)
+ * @returns Array of resolved type argument names (unresolvable arguments are omitted)
+ */
+export declare const extractGenericTypeArgs: (typeNode: SyntaxNode) => string[];
+/**
+ * Match Ruby constructor assignment: `user = User.new` or `service = Models::User.new`
+ *
+ * Handles both simple constants and scope_resolution (namespaced) receivers
+ * @returns `{ varName, calleeName }` or undefined if not a Ruby constructor assignment
+ */
+export declare const extractRubyConstructorAssignment: (node: SyntaxNode) => {
+    varName: string;
+    calleeName: string;
+} | undefined;
+/**
+ * Check if an AST node has an explicit type annotation
+ *
+ * Checks both named fields ('type') and child nodes ('type_annotation')
+ * Used by constructor binding scanners to skip annotated declarations
+ */
+export declare const hasTypeAnnotation: (node: SyntaxNode) => boolean;
+/**
+ * Strip nullable wrappers from a type name string
+ *
+ * Used by both lookupInEnv (TypeEnv annotations) and extractReturnTypeName
+ * (return-type text) to normalize types before receiver lookup
+ *
+ *   "User | null"              -> "User"
+ *   "User | undefined"         -> "User"
+ *   "User | null | undefined"  -> "User"
+ *   "User?"                    -> "User"
+ *   "User | Repo"              -> undefined  (genuine union -- refuse)
+ *   "null"                     -> undefined
+ */
+export declare const stripNullable: (typeName: string) => string | undefined;
+/**
+ * Unwrap an await_expression to get the inner value
+ *
+ * Returns the node itself if not an await_expression, or null if input is null
+ */
+export declare const unwrapAwait: (node: SyntaxNode | null) => SyntaxNode | null;
+/**
+ * Extract the callee name from a call_expression node
+ *
+ * Navigates to the 'function' field (or first named child) and extracts a simple type name
+ */
+export declare const extractCalleeName: (callNode: SyntaxNode) => string | undefined;
+/** Find the first named child with the given node type */
+export declare const findChildByType: (node: SyntaxNode, type: string) => SyntaxNode | null;