torsh-jit 0.1.3

//! Configuration and result types for the Abstract Interpretation Framework.
//!
//! This module contains all configuration structs, result types, analysis
//! data structures, and supporting enums used by the core [`super::AbstractInterpreter`]
//! engine. Extracted here to keep file sizes under policy limits.

use super::super::domains::{AbstractDomainType, AbstractValue};
use crate::NodeId;
use std::collections::HashMap;
use std::time::Duration;

/// Abstract interpretation configuration
#[derive(Debug, Clone)]
pub struct AbstractInterpretationConfig {
    /// Type of abstract domain to use
    pub domain_type: AbstractDomainType,
    /// Maximum number of fixpoint iterations
    pub max_iterations: usize,
    /// Number of iterations before applying widening
    pub widening_delay: usize,
    /// Enable narrowing after widening
    pub enable_narrowing: bool,
    /// Enable backward analysis in addition to forward analysis
    pub enable_backward_analysis: bool,
    /// Properties to check during analysis
    pub properties: Vec<Property>,
    /// Minimum precision threshold for analysis quality
    pub precision_threshold: f64,
}

impl Default for AbstractInterpretationConfig {
    fn default() -> Self {
        Self {
            domain_type: AbstractDomainType::Intervals,
            max_iterations: 100,
            widening_delay: 3,
            enable_narrowing: true,
            enable_backward_analysis: false,
            properties: Vec::new(),
            precision_threshold: 0.8,
        }
    }
}

/// Properties to verify during abstract interpretation
#[derive(Debug, Clone)]
pub enum Property {
    /// Value is always non-negative
    NonNegative(NodeId),
    /// Value is always positive
    Positive(NodeId),
    /// Value is within specified bounds
    BoundedValue(NodeId, f64, f64),
    /// No division by zero
    NoDivisionByZero(NodeId),
    /// No overflow
    NoOverflow(NodeId),
    /// Custom safety property
    SafetyProperty(String, NodeId),
}

/// Safety check types for verification
#[derive(Debug, Clone)]
pub enum SafetyCheck {
    /// Bounds checking
    BoundsCheck,
    /// Null pointer check
    NullCheck,
    /// Division by zero check
    DivisionByZeroCheck,
    /// Overflow check
    OverflowCheck,
    /// Array access bounds
    ArrayBoundsCheck,
}

/// Result of a safety check
#[derive(Debug, Clone)]
pub enum SafetyCheckResult {
    /// Property definitely holds
    Safe,
    /// Property definitely violated
    Unsafe,
    /// Property may or may not hold (imprecise analysis)
    Unknown,
}

/// Invariant detected during analysis
#[derive(Debug, Clone)]
pub struct Invariant {
    /// Type of invariant
    pub invariant_type: InvariantType,
    /// Human-readable description
    pub description: String,
    /// Confidence level (0.0 to 1.0)
    pub confidence: f64,
    /// Location where invariant holds
    pub location: String,
}

/// Types of invariants that can be detected
#[derive(Debug, Clone)]
pub enum InvariantType {
    /// Value range invariant
    ValueRange,
    /// Loop invariant
    LoopInvariant,
    /// Conditional invariant
    ConditionalInvariant,
    /// Memory safety invariant
    MemorySafety,
    /// Numerical property
    NumericalProperty,
}

/// Function-level invariant
#[derive(Debug, Clone)]
pub struct FunctionInvariant {
    pub invariant_type: InvariantType,
    pub description: String,
    pub confidence: f64,
    pub location: String,
}

/// Module-level invariant
#[derive(Debug, Clone)]
pub struct ModuleInvariant {
    pub invariant_type: InvariantType,
    pub description: String,
    pub confidence: f64,
    pub scope: String,
}

/// Analysis statistics tracking
#[derive(Debug, Clone)]
pub struct AnalysisStatistics {
    /// Total analysis time
    pub analysis_time: Duration,
    /// Number of fixpoint iterations
    pub fixpoint_iterations: usize,
    /// Number of abstract states computed
    pub abstract_states_computed: usize,
    /// Cache hit count
    pub cache_hits: usize,
    /// Cache miss count
    pub cache_misses: usize,
}

/// Forward analysis result
#[derive(Debug, Clone)]
pub struct ForwardAnalysisResult {
    /// Pre-states for each node
    pub pre_states: HashMap<NodeId, AbstractValue>,
    /// Post-states for each node
    pub post_states: HashMap<NodeId, AbstractValue>,
    /// Number of iterations until convergence
    pub iterations: usize,
    /// Whether analysis converged
    pub converged: bool,
}

impl ForwardAnalysisResult {
    pub fn new() -> Self {
        Self {
            pre_states: HashMap::new(),
            post_states: HashMap::new(),
            iterations: 0,
            converged: false,
        }
    }
}

impl Default for ForwardAnalysisResult {
    fn default() -> Self {
        Self::new()
    }
}

/// Backward analysis result
#[derive(Debug, Clone)]
pub struct BackwardAnalysisResult {
    /// Pre-states for each node (computed backwards)
    pub pre_states: HashMap<NodeId, AbstractValue>,
    /// Post-states for each node (computed backwards)
    pub post_states: HashMap<NodeId, AbstractValue>,
    /// Number of iterations until convergence
    pub iterations: usize,
    /// Whether analysis converged
    pub converged: bool,
}

impl BackwardAnalysisResult {
    pub fn new() -> Self {
        Self {
            pre_states: HashMap::new(),
            post_states: HashMap::new(),
            iterations: 0,
            converged: false,
        }
    }
}

impl Default for BackwardAnalysisResult {
    fn default() -> Self {
        Self::new()
    }
}

/// Function-specific analysis results
#[derive(Debug, Clone)]
pub struct AbstractFunctionResult {
    /// Forward analysis result
    pub forward_result: FunctionForwardResult,
    /// Backward analysis result (if enabled)
    pub backward_result: Option<FunctionBackwardResult>,
    /// Function-level invariants
    pub invariants: Vec<FunctionInvariant>,
}

/// Forward analysis result for a function
#[derive(Debug, Clone)]
pub struct FunctionForwardResult {
    /// Whether analysis converged
    pub converged: bool,
    /// Number of iterations
    pub iterations: usize,
    /// Function entry state
    pub entry_state: Option<AbstractValue>,
    /// Function exit state
    pub exit_state: Option<AbstractValue>,
}

impl FunctionForwardResult {
    pub fn new() -> Self {
        Self {
            converged: false,
            iterations: 0,
            entry_state: None,
            exit_state: None,
        }
    }
}

impl Default for FunctionForwardResult {
    fn default() -> Self {
        Self::new()
    }
}

/// Backward analysis result for a function
#[derive(Debug, Clone)]
pub struct FunctionBackwardResult {
    /// Whether analysis converged
    pub converged: bool,
    /// Number of iterations
    pub iterations: usize,
    /// Function entry state (computed backwards)
    pub entry_state: Option<AbstractValue>,
    /// Function exit state (computed backwards)
    pub exit_state: Option<AbstractValue>,
}

impl FunctionBackwardResult {
    pub fn new() -> Self {
        Self {
            converged: false,
            iterations: 0,
            entry_state: None,
            exit_state: None,
        }
    }
}

impl Default for FunctionBackwardResult {
    fn default() -> Self {
        Self::new()
    }
}

/// Interprocedural analysis result
#[derive(Debug, Clone)]
pub struct InterproceduralAnalysisResult {
    /// Call graph representation
    pub call_graph: HashMap<String, Vec<String>>,
    /// Global invariants across functions
    pub global_invariants: Vec<Invariant>,
}

/// Property verification result
#[derive(Debug, Clone)]
pub struct PropertyResult {
    /// The property that was checked
    pub property: Property,
    /// Result of the check
    pub result: SafetyCheckResult,
    /// Confidence in the result
    pub confidence: f64,
    /// Additional details about the check
    pub details: String,
}

/// Precision analysis result
#[derive(Debug, Clone)]
pub struct PrecisionAnalysis {
    /// Overall precision score
    pub overall_precision: f64,
    /// Per-node precision scores
    pub node_precision: HashMap<NodeId, f64>,
    /// Areas where precision could be improved
    pub improvement_suggestions: Vec<String>,
}

/// Performance analysis result
#[derive(Debug, Clone)]
pub struct PerformanceAnalysis {
    /// Overall complexity score
    pub complexity_score: f64,
    /// Detected performance bottlenecks
    pub bottlenecks: Vec<PerformanceBottleneck>,
    /// Optimization opportunities
    pub optimization_opportunities: Vec<OptimizationOpportunity>,
}

/// Performance bottleneck detection
#[derive(Debug, Clone)]
pub struct PerformanceBottleneck {
    /// Type of bottleneck
    pub bottleneck_type: BottleneckType,
    /// Location of the bottleneck
    pub location: NodeId,
    /// Severity score (0.0 to 1.0)
    pub severity: f64,
    /// Description of the issue
    pub description: String,
}

/// Types of performance bottlenecks
#[derive(Debug, Clone)]
pub enum BottleneckType {
    /// Expensive computation
    ComputationIntensive,
    /// Memory bandwidth limited
    MemoryBound,
    /// Loop with high iteration count
    LoopBottleneck,
    /// Frequent function calls
    CallOverhead,
    /// Cache misses
    CacheMisses,
}

/// Optimization opportunity
#[derive(Debug, Clone)]
pub struct OptimizationOpportunity {
    /// Type of optimization
    pub optimization_type: OptimizationType,
    /// Location where optimization applies
    pub location: NodeId,
    /// Expected benefit (0.0 to 1.0)
    pub benefit: f64,
    /// Description of the optimization
    pub description: String,
}

/// Types of optimizations
#[derive(Debug, Clone)]
pub enum OptimizationType {
    /// Loop unrolling
    LoopUnrolling,
    /// Constant folding
    ConstantFolding,
    /// Common subexpression elimination
    CommonSubexpressionElimination,
    /// Dead code elimination
    DeadCodeElimination,
    /// Vectorization
    Vectorization,
}

/// Complexity metrics
#[derive(Debug, Clone)]
pub struct ComplexityMetrics {
    /// Cyclomatic complexity
    pub cyclomatic_complexity: usize,
    /// Number of variables
    pub variable_count: usize,
    /// Nesting depth
    pub nesting_depth: usize,
}

/// Complete abstract analysis result
#[derive(Debug, Clone)]
pub struct AbstractAnalysisResult {
    /// Forward analysis result
    pub forward_result: ForwardAnalysisResult,
    /// Backward analysis result (if performed)
    pub backward_result: Option<BackwardAnalysisResult>,
    /// Detected invariants
    pub invariants: Vec<Invariant>,
    /// Property verification results
    pub property_results: Vec<PropertyResult>,
    /// Precision analysis
    pub precision_analysis: PrecisionAnalysis,
    /// Performance analysis
    pub performance_analysis: PerformanceAnalysis,
    /// Analysis statistics
    pub statistics: AnalysisStatistics,
    /// Abstract values for each node
    pub node_values: HashMap<NodeId, AbstractValue>,
}

/// IR module analysis result
#[derive(Debug, Clone)]
pub struct AbstractIrResult {
    /// Results for individual functions
    pub function_results: HashMap<String, AbstractFunctionResult>,
    /// Interprocedural analysis result
    pub interprocedural_result: InterproceduralAnalysisResult,
    /// Module-level invariants
    pub module_invariants: Vec<ModuleInvariant>,
}