codeprism_lang_rust/

types.rs

//! Types for Rust parser
//!
//! These types mirror the ones in codeprism_core::ast but are defined here to avoid
//! circular dependencies. The parser returns these types which are then
//! converted to codeprism types by the caller.

use blake3::Hasher;
use serde::{Deserialize, Serialize};
use std::path::{Path, PathBuf};

/// Unique identifier for AST nodes
#[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct NodeId([u8; 16]);

impl NodeId {
    /// Create a new NodeId from components
    pub fn new(repo_id: &str, file_path: &Path, span: &Span, kind: &NodeKind) -> Self {
        let mut hasher = Hasher::new();
        hasher.update(repo_id.as_bytes());
        hasher.update(file_path.to_string_lossy().as_bytes());
        hasher.update(&span.start_byte.to_le_bytes());
        hasher.update(&span.end_byte.to_le_bytes());
        hasher.update(format!("{:?}", kind).as_bytes());

        let hash = hasher.finalize();
        let mut id = [0u8; 16];
        id.copy_from_slice(&hash.as_bytes()[..16]);
        Self(id)
    }

    /// Get the ID as a hex string
    pub fn to_hex(&self) -> String {
        hex::encode(self.0)
    }
}

impl std::fmt::Debug for NodeId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "NodeId({})", &self.to_hex()[..8])
    }
}

/// Types of nodes in the Universal AST for Rust
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum NodeKind {
    /// A module or file
    Module,
    /// A class definition (for compatibility)
    Class,
    /// A function definition
    Function,
    /// A method definition
    Method,
    /// A function/method parameter
    Parameter,
    /// A variable declaration
    Variable,
    /// A function/method call
    Call,
    /// An import statement
    Import,
    /// A literal value
    Literal,
    /// An HTTP route definition
    Route,
    /// A SQL query
    SqlQuery,
    /// An event emission
    Event,

    // Rust-specific node types
    /// A trait definition
    Trait,
    /// An implementation block (impl)
    Impl,
    /// A struct definition
    Struct,
    /// An enum definition
    Enum,
    /// A module definition (mod)
    Mod,
    /// A macro definition or invocation
    Macro,
    /// A lifetime parameter
    Lifetime,
    /// A use statement (import)
    Use,
    /// A pub modifier (visibility)
    Pub,
    /// A const declaration
    Const,
    /// A static declaration
    Static,
    /// A type alias
    TypeAlias,
    /// A union definition
    Union,
    /// An associated type
    AssociatedType,
    /// An associated const
    AssociatedConst,
    /// A field in a struct/enum
    Field,
    /// An enum variant
    Variant,
    /// An attribute
    Attribute,

    /// Unknown node type
    Unknown,
}

/// Types of edges between nodes for Rust
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum EdgeKind {
    /// Function/method call
    Calls,
    /// Variable/field read
    Reads,
    /// Variable/field write
    Writes,
    /// Module import
    Imports,
    /// Event emission
    Emits,
    /// HTTP route mapping
    RoutesTo,
    /// Exception raising
    Raises,
    /// Type inheritance
    Extends,
    /// Interface implementation (generic)
    Implements,

    // Rust-specific edge types
    /// Trait implementation (for a type)
    ImplementsTrait,
    /// Use statement relationship
    Uses,
    /// Derive attribute relationship
    Derives,
    /// Generic constraint relationship
    Constrains,
    /// Ownership transfer
    Owns,
    /// Borrowing relationship
    Borrows,
    /// Mutable borrowing
    BorrowsMut,
    /// Lifetime constraint
    Outlives,
    /// Type parameter bound
    Bounds,
    /// Associated type binding
    Binds,
    /// Macro expansion
    Expands,
    /// Module containment
    Contains,
}

/// Source code location
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct Span {
    /// Starting byte offset
    pub start_byte: usize,
    /// Ending byte offset (exclusive)
    pub end_byte: usize,
    /// Starting line (1-indexed)
    pub start_line: usize,
    /// Ending line (1-indexed)
    pub end_line: usize,
    /// Starting column (1-indexed)
    pub start_column: usize,
    /// Ending column (1-indexed)
    pub end_column: usize,
}

impl Span {
    /// Create a new span
    pub fn new(
        start_byte: usize,
        end_byte: usize,
        start_line: usize,
        end_line: usize,
        start_column: usize,
        end_column: usize,
    ) -> Self {
        Self {
            start_byte,
            end_byte,
            start_line,
            end_line,
            start_column,
            end_column,
        }
    }

    /// Create a span from tree-sitter node
    pub fn from_node(node: &tree_sitter::Node) -> Self {
        let start_pos = node.start_position();
        let end_pos = node.end_position();

        Self {
            start_byte: node.start_byte(),
            end_byte: node.end_byte(),
            start_line: start_pos.row + 1, // tree-sitter uses 0-indexed
            end_line: end_pos.row + 1,
            start_column: start_pos.column + 1,
            end_column: end_pos.column + 1,
        }
    }
}

/// Programming language
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Language {
    /// Rust
    Rust,
    /// Python (for compatibility)
    Python,
}

/// A node in the Universal AST
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Node {
    /// Unique identifier
    pub id: NodeId,
    /// Node type
    pub kind: NodeKind,
    /// Node name (e.g., function name)
    pub name: String,
    /// Programming language
    pub lang: Language,
    /// Source file path
    pub file: PathBuf,
    /// Source location
    pub span: Span,
    /// Optional type signature
    pub signature: Option<String>,
    /// Additional metadata (Rust-specific info like visibility, mutability, etc.)
    pub metadata: serde_json::Value,
}

impl Node {
    /// Create a new node
    pub fn new(
        repo_id: &str,
        kind: NodeKind,
        name: String,
        lang: Language,
        file: PathBuf,
        span: Span,
    ) -> Self {
        let id = NodeId::new(repo_id, &file, &span, &kind);
        Self {
            id,
            kind,
            name,
            lang,
            file,
            span,
            signature: None,
            metadata: serde_json::Value::Null,
        }
    }

    /// Set metadata for the node
    pub fn with_metadata(mut self, metadata: serde_json::Value) -> Self {
        self.metadata = metadata;
        self
    }

    /// Set signature for the node
    pub fn with_signature(mut self, signature: String) -> Self {
        self.signature = Some(signature);
        self
    }
}

/// An edge between nodes
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct Edge {
    /// Source node ID
    pub source: NodeId,
    /// Target node ID
    pub target: NodeId,
    /// Edge type
    pub kind: EdgeKind,
}

impl Edge {
    /// Create a new edge
    pub fn new(source: NodeId, target: NodeId, kind: EdgeKind) -> Self {
        Self {
            source,
            target,
            kind,
        }
    }
}