ryo-analysis 0.1.0

#![warn(missing_docs)]
//! # ryo-analysis: Code Graph and Discovery Engine
//!
//! This crate provides code exploration, relationship analysis, and pattern-based
//! symbol discovery for the RYO project.
//!
//! # Key Design: AST-first approach
//!
//! Symbols are identified by their AST hierarchy (`SymbolPath`), and physical files
//! are derived as a View layer. This enables file-independent symbol identification.
//!
//! # Core Concepts
//!
//! - **SymbolPath**: External representation for persistence and display. Unique across
//!   the entire Rust ecosystem (e.g., `tokio::sync::Mutex::lock`).
//! - **SymbolId**: Internal representation for fast processing. O(1) access via SlotMap
//!   with generation counter for dangling detection.
//! - **SymbolRegistry**: Central registry managing Symbol lifecycle and metadata.
//! - **CodeGraphV2**: Symbol relationship graph for fast traversal.
//! - **WorkspaceFilePath**: Self-contained file path (from ryo-symbol).
//!
//! # Usage
//!
//! ```rust,ignore
//! use ryo_analysis::{SymbolPath, SymbolRegistry, SymbolKind};
//!
//! // Create a SymbolPath
//! let path = SymbolPath::builder("tokio")
//!     .push("sync")
//!     .push("Mutex")
//!     .build()?;
//!
//! // Register in the registry
//! let mut registry = SymbolRegistry::new();
//! let id = registry.register(path, SymbolKind::Struct)?;
//!
//! // Fast lookup
//! let resolved = registry.resolve(id);
//! ```

pub mod ast;
pub mod cascade;
pub mod check;
pub mod context;
pub mod detail_store;
pub mod discovery;
pub mod import_map_builder;
pub mod literal;
pub mod pattern;
pub mod query;
pub mod summary;
pub mod symbol;
#[cfg(feature = "testing")]
pub mod testing;
pub mod uuid_persistence;

// === Symbol ===
pub use symbol::{
    // Core types
    CrateName,
    // File types
    FileId,
    FileRegistry,
    FileSpan,
    InvalidFileId,
    // Registry
    InvalidSymbolId,
    ParseError,
    ReExportInfo,
    RegistrationError,
    // Registry Updates (for parallel execution)
    RegistryUpdate,
    RegistryUpdateBatch,
    RenameError,
    Segment,
    SymbolId,
    SymbolKind,
    SymbolPath,
    SymbolPathBuilder,
    SymbolRef,
    SymbolRegistry,
    // Persistent ID
    Uuid,
    Visibility,
    WorkspaceFilePath,
};

// === Pattern ===
pub use pattern::{CaseOptions, Pattern};

// === Query Module ===
pub use query::{
    // Lock V2 (VarId-based)
    AccessKind,
    // Borrow V2 (VarId-based)
    ActiveBorrowV2,
    BorrowAnalysis,
    BorrowConflict,
    BorrowKind,
    BorrowStateV2,
    BorrowTrackerV2,
    ChainDirection,
    // Graph types (V2: DoD-based, petgraph-free)
    ChainNode,
    ChainResult,
    CodeEdgeV2,
    CodeGraphV2,
    // SpecFlow shared types
    CommentDirective,
    // SpecFlow V2 (DoD-based, SymbolId-based)
    ConstraintData,
    ConstraintKind,
    CriticalSectionV2,
    // DataFlow V2 (DoD-based, String-free)
    DataFlowBuilderWorkspace,
    DataFlowGraphV2,
    DataFlowStats,
    // TypeFlow V2 (DoD-based, String-free)
    DefinitionData,
    DeriveIndex,
    DeriveIndexStats,
    EdgeData,
    EdgeId,
    FieldAccessV2,
    FlowChain,
    FlowData,
    FlowEdge,
    FlowEdgeData,
    FlowId,
    FlowKind,
    FlowStep,
    GenericArgData,
    GraphBuilderV2,
    GroupData,
    IntentData,
    IntentKind,
    LockAcquisitionV2,
    LockGranularityAnalyzerV2,
    LockStatsV2,
    LockSuggestion,
    LockTrackerV2,
    LockType,
    LookupTable,
    MatchExprDataV2,
    MatchExprId,
    MoveError,
    NodeKind,
    QueryBuilder,
    RefKind,
    // Reference integrity analysis
    ReferenceIntegrityChecker,
    ReferenceIntegrityIssue,
    ReferenceIntegrityResult,
    SpecAliasData,
    // Type alias registry (shared layer)
    SpecAliasInfo,
    SpecFlowBuilderV2,
    SpecFlowGraphV2,
    SpecLookupTable,
    SpecNodeId,
    SpecNodeKind,
    SpecSource,
    StdImplCache,
    TraitBoundData,
    TypeAliasEntry,
    TypeAliasRegistry,
    TypeAliasRegistryBuilder,
    TypeDefKind,
    TypeFlowBuilderV2,
    TypeFlowGraphV2,
    // Type impact analysis
    TypeImpactChecker,
    TypeImpactIssue,
    TypeImpactResult,
    TypeImpactV2,
    TypeNodeId,
    // Unused symbol analysis
    UnusedSymbol,
    UnusedSymbolChecker,
    UnusedSymbolResult,
    UsageContext,
    UsageData,
    VarData,
    // VarId (internal variable identifier for DataFlowGraph)
    VarId,
    VarKind,
    VarNode,
    VarSymbolMapping,
};

// Re-export ryo-metadata types when workspace feature is enabled
#[cfg(feature = "workspace")]
pub use ryo_metadata::{ResolvedCrateName, ResolvedFile, ResolvedModulePath, WorkspaceResolver};

// === Discovery Module ===
pub use discovery::{
    DiscoveredSymbol, DiscoveryEngine, DiscoveryQuery, DiscoveryResult, RelationGraph,
    RelationKind, SortOrder, TypeFilter,
};

// === Context Module ===
pub use context::{AnalysisConfig, AnalysisContext, ContextError, ExecutionContext, ImHashMap};

// === Detail Store ===
pub use detail_store::{
    DetailStore, EnumDetail, FieldInfo, FunctionDetail, GenericInfo, ImplDetail, ParamInfo,
    StructDetail, StructKind, TraitDetail, VariantInfo,
};

// === Summary (AI-readable output) ===
pub use summary::{SummaryOptions, ToSummary};

// === Check Module (LightGraphCheck) ===
pub use check::{
    cascade_add_derive, CascadeMutation, CascadeResult, CascadeStatus, CascadeStrategy, CheckError,
    CheckResult, CheckWarning, GraphChecker, LightCheck,
};

// === Cascade Module (Generalized Cascade Engine) ===
pub use cascade::{
    CascadeAnalyzer, CascadeSpec, CascadeStrategy as NewCascadeStrategy, ImpactLevel, ImpactSet,
    Visibility as CascadeVisibility,
};

// === Literal Module ===
pub use literal::{LiteralCollector, LiteralInfo, LiteralKind};

#[cfg(feature = "literal-search")]
pub use literal::{LiteralIndex, LiteralMatch, LiteralQuery, LiteralSearchError};

// === AST Module (Complete AST storage for v2 mutation engine) ===
pub use ast::ASTRegistry;

// === UUID Persistence ===
pub use uuid_persistence::{NoOpUuidPersistence, UuidPersistence, UuidPersistenceError};