vj-sim 0.3.0

//! The declaration side of the model: what the SystemVerilog source says,
//! before any instance exists (IEEE 1800-2023 19.3, 19.5).
//!
//! A [`CoverpointDecl`] is produced once per `covergroup` and instantiated once
//! per `new`, with that instance's constructor arguments (see
//! [`super::coverpoint::Coverpoint::new`]).

use super::value::{Expr, TypeInfo};

/// `bins`, `ignore_bins` or `illegal_bins` (19.5, 19.5.5, 19.5.6).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BinKind {
    Normal,
    Ignore,
    Illegal,
}

/// The bracket after the bin name.
#[derive(Clone, Debug, PartialEq)]
pub enum ArrayKind {
    /// `bins b`: one bin.
    None,
    /// `bins b[]`: one bin per value (per interval for reals).
    Open,
    /// `bins b[N]`: `N` bins, `N` evaluated at construction.
    Fixed(Expr),
}

/// One end of a `[lo:hi]` range; `$` is the type minimum/maximum.
#[derive(Clone, Debug, PartialEq)]
pub enum Bound {
    Expr(Expr),
    Dollar,
}

/// One element of a `covergroup_range_list` (Syntax 19-2).
#[derive(Clone, Debug, PartialEq)]
pub enum RangeItem {
    /// A single value (or, for a set expression's elements, one element).
    Single(Expr),
    /// `[lo:hi]`, `[$:hi]`, `[lo:$]`.
    Range(Bound, Bound),
    /// `[center +/- tol]` (`relative = false`) or `[center +%- tol]`
    /// (`relative = true`), 11.4.13.
    Tolerance {
        center: Expr,
        tol: Expr,
        relative: bool,
    },
}

/// `repeat_range`: `n` or `lo : hi` (Syntax 19-3).
#[derive(Clone, Debug, PartialEq)]
pub struct RepeatRange {
    pub lo: Expr,
    pub hi: Option<Expr>,
}

impl RepeatRange {
    pub fn exactly(n: i128) -> RepeatRange {
        RepeatRange {
            lo: Expr::int(n),
            hi: None,
        }
    }

    pub fn between(lo: i128, hi: i128) -> RepeatRange {
        RepeatRange {
            lo: Expr::int(lo),
            hi: Some(Expr::int(hi)),
        }
    }
}

/// The repetition suffix of a `trans_item`.
#[derive(Clone, Debug, PartialEq)]
pub enum TransRep {
    Once,
    /// `[* repeat_range ]`
    Consecutive(RepeatRange),
    /// `[-> repeat_range ]`
    Goto(RepeatRange),
    /// `[= repeat_range ]`
    NonConsecutive(RepeatRange),
}

/// A `trans_range_list`: a value range list with its repetition.
#[derive(Clone, Debug, PartialEq)]
pub struct TransItem {
    pub values: Vec<RangeItem>,
    pub rep: TransRep,
}

impl TransItem {
    pub fn new(values: Vec<RangeItem>) -> TransItem {
        TransItem {
            values,
            rep: TransRep::Once,
        }
    }

    pub fn rep(mut self, rep: TransRep) -> TransItem {
        self.rep = rep;
        self
    }
}

/// A `trans_set`: items joined by `=>`.
pub type TransSet = Vec<TransItem>;

/// What a bin matches.
#[derive(Clone, Debug, PartialEq)]
pub enum BinBody {
    /// `( trans_set ) { , ( trans_set ) }` (19.5.2).
    Trans(Vec<TransSet>),
    /// `default sequence` (19.5.2).
    DefaultSeq,
    /// `{ range list } [with (expr)]`. A `with` kernel receives the
    /// constructor arguments followed by `item`. The coverpoint-name form
    /// `cp with (expr)` is `[$:$]` plus the clause.
    Ranges {
        items: Vec<RangeItem>,
        with: Option<Expr>,
    },
    /// A `set_covergroup_expression`: evaluates to a [`super::value::Val::List`].
    Set(Expr),
    /// `default` (19.5): the values of no other bin.
    Default,
}

#[derive(Clone, Debug, PartialEq)]
pub struct BinDecl {
    pub name: String,
    pub kind: BinKind,
    pub array: ArrayKind,
    pub wildcard: bool,
    /// Per-bin `iff` (sample-time kernel).
    pub iff: Option<Expr>,
    pub body: BinBody,
}

impl BinDecl {
    /// A plain `bins <name> = { items }`.
    pub fn ranges(name: &str, items: Vec<RangeItem>) -> BinDecl {
        BinDecl {
            name: name.to_string(),
            kind: BinKind::Normal,
            array: ArrayKind::None,
            wildcard: false,
            iff: None,
            body: BinBody::Ranges { items, with: None },
        }
    }

    pub fn kind(mut self, kind: BinKind) -> BinDecl {
        self.kind = kind;
        self
    }

    pub fn array(mut self, array: ArrayKind) -> BinDecl {
        self.array = array;
        self
    }

    pub fn wildcard(mut self) -> BinDecl {
        self.wildcard = true;
        self
    }

    pub fn iff(mut self, iff: Expr) -> BinDecl {
        self.iff = Some(iff);
        self
    }

    pub fn with(mut self, with: Expr) -> BinDecl {
        if let BinBody::Ranges { with: w, .. } = &mut self.body {
            *w = Some(with);
        }
        self
    }

    /// A transition bin `bins <name> = (set) , (set) ...`.
    pub fn trans(name: &str, sets: Vec<TransSet>) -> BinDecl {
        BinDecl {
            name: name.to_string(),
            kind: BinKind::Normal,
            array: ArrayKind::None,
            wildcard: false,
            iff: None,
            body: BinBody::Trans(sets),
        }
    }

    /// `bins <name> = default sequence`.
    pub fn default_seq(name: &str) -> BinDecl {
        BinDecl {
            name: name.to_string(),
            kind: BinKind::Normal,
            array: ArrayKind::None,
            wildcard: false,
            iff: None,
            body: BinBody::DefaultSeq,
        }
    }

    pub fn default_bin(name: &str) -> BinDecl {
        BinDecl {
            name: name.to_string(),
            kind: BinKind::Normal,
            array: ArrayKind::None,
            wildcard: false,
            iff: None,
            body: BinBody::Default,
        }
    }
}

/// The `matches` clause of a `with` select or a set select (19.6.1.2).
#[derive(Clone, Debug, PartialEq)]
pub enum Matches {
    /// `matches n`: at least `n` satisfying value tuples (a positive integer,
    /// evaluated at construction). Omitted means `Count(1)`.
    Count(Expr),
    /// `matches $`: every value tuple must satisfy.
    All,
}

impl Matches {
    /// The default policy of 19.6.1.2: a single value tuple selects.
    pub fn one() -> Matches {
        Matches::Count(Expr::int(1))
    }
}

/// A `select_expression` (Syntax 19-4).
#[derive(Clone, Debug, PartialEq)]
pub enum SelectExpr {
    /// `binsof(cp)` / `binsof(cp.bin)`, optionally `intersect { ranges }`.
    /// `bin` names one bin, or a whole `b[]` / `b[N]` array by its base name.
    Binsof {
        cp: String,
        bin: Option<String>,
        intersect: Option<Vec<RangeItem>>,
    },
    Not(Box<SelectExpr>),
    And(Box<SelectExpr>, Box<SelectExpr>),
    Or(Box<SelectExpr>, Box<SelectExpr>),
    /// `sel with (expr) [matches ...]`. The kernel receives the constructor
    /// arguments followed by one value per cross item, in item order.
    With {
        sel: Box<SelectExpr>,
        expr: Expr,
        matches: Matches,
    },
    /// The enclosing cross's own identifier: every bin tuple.
    All,
    /// `cross_set_expression [matches ...]`: evaluates to a
    /// [`super::value::Val::List`] of tuples (each a `Val::List` with one value
    /// per cross item), 19.6.1.4.
    Set {
        expr: Expr,
        matches: Matches,
    },
}

/// A `bins`, `ignore_bins` or `illegal_bins` selection of a cross (19.6.1,
/// 19.6.2, 19.6.3).
#[derive(Clone, Debug, PartialEq)]
pub struct CrossBinDecl {
    pub name: String,
    pub kind: BinKind,
    pub select: SelectExpr,
    /// Per-bin `iff` (sample-time kernel).
    pub iff: Option<Expr>,
}

impl CrossBinDecl {
    pub fn new(name: &str, kind: BinKind, select: SelectExpr) -> CrossBinDecl {
        CrossBinDecl {
            name: name.to_string(),
            kind,
            select,
            iff: None,
        }
    }

    pub fn iff(mut self, iff: Expr) -> CrossBinDecl {
        self.iff = Some(iff);
        self
    }
}

/// A `cross` (19.6).
#[derive(Clone, Debug, PartialEq)]
pub struct CrossDecl {
    pub name: String,
    /// The crossed coverpoints, by name, in declaration order. A variable
    /// operand is represented by the implicit coverpoint the frontend adds.
    pub items: Vec<String>,
    /// Cross-level `iff` (sample-time kernel).
    pub iff: Option<Expr>,
    pub bins: Vec<CrossBinDecl>,
    pub options: Vec<(String, Expr)>,
    pub type_options: Vec<(String, Expr)>,
}

impl CrossDecl {
    pub fn new(name: &str, items: &[&str]) -> CrossDecl {
        CrossDecl {
            name: name.to_string(),
            items: items.iter().map(|s| s.to_string()).collect(),
            iff: None,
            bins: Vec::new(),
            options: Vec::new(),
            type_options: Vec::new(),
        }
    }

    pub fn bin(mut self, bin: CrossBinDecl) -> CrossDecl {
        self.bins.push(bin);
        self
    }
}

/// A `coverpoint` (explicit, or the implicit one of a cross operand).
#[derive(Clone, Debug, PartialEq)]
pub struct CoverpointDecl {
    pub name: String,
    pub ty: TypeInfo,
    /// Sample-time kernel yielding the coverpoint value.
    pub expr: Expr,
    /// Coverpoint-level `iff` (sample-time kernel).
    pub iff: Option<Expr>,
    pub bins: Vec<BinDecl>,
    /// For an enum-typed coverpoint: every enumerator `(name, value)` in
    /// declaration order (auto bins are named after them, 19.5.3).
    pub enum_values: Option<Vec<(String, i128)>>,
    /// `option.<name> = <expr>` assignments inside the coverpoint, in order.
    pub options: Vec<(String, Expr)>,
    /// `type_option.<name> = <expr>` assignments inside the coverpoint.
    pub type_options: Vec<(String, Expr)>,
}

/// A `covergroup` declaration (19.3): its options and its coverage items.
#[derive(Clone, Debug, PartialEq)]
pub struct CovGroupDecl {
    pub name: String,
    /// `option.<name> = <expr>` assignments of the covergroup, in order.
    /// Evaluated per instance with the constructor arguments (19.7).
    pub options: Vec<(String, Expr)>,
    /// `type_option.<name> = <expr>` assignments; constant expressions
    /// (19.7.1), evaluated once when the type is defined.
    pub type_options: Vec<(String, Expr)>,
    pub coverpoints: Vec<CoverpointDecl>,
    pub crosses: Vec<CrossDecl>,
}

impl CovGroupDecl {
    pub fn new(name: &str) -> CovGroupDecl {
        CovGroupDecl {
            name: name.to_string(),
            options: Vec::new(),
            type_options: Vec::new(),
            coverpoints: Vec::new(),
            crosses: Vec::new(),
        }
    }

    pub fn coverpoint(mut self, cp: CoverpointDecl) -> CovGroupDecl {
        self.coverpoints.push(cp);
        self
    }

    pub fn cross(mut self, x: CrossDecl) -> CovGroupDecl {
        self.crosses.push(x);
        self
    }

    pub fn option(mut self, name: &str, v: Expr) -> CovGroupDecl {
        self.options.push((name.to_string(), v));
        self
    }

    pub fn type_option(mut self, name: &str, v: Expr) -> CovGroupDecl {
        self.type_options.push((name.to_string(), v));
        self
    }
}

impl CoverpointDecl {
    pub fn new(name: &str, ty: TypeInfo, expr: Expr) -> CoverpointDecl {
        CoverpointDecl {
            name: name.to_string(),
            ty,
            expr,
            iff: None,
            bins: Vec::new(),
            enum_values: None,
            options: Vec::new(),
            type_options: Vec::new(),
        }
    }

    pub fn bin(mut self, bin: BinDecl) -> CoverpointDecl {
        self.bins.push(bin);
        self
    }
}