Enum OpClass 

pub enum OpClass {
    OverflowFree,
    NeedsWiderScratch,
    Unbounded,
}

Classification of an operation’s worst-case i64 intermediate.

OverflowFree means EVERY i64 intermediate across the WHOLE op body provably fits i64 — the smart-constructor guard (fromInt / fromX) is STILL REQUIRED. The verdict is the join over the final tail interval, every intermediate subexpression interval, and every earlier binding’s interval (see classify_op): a single out-of-i64 intermediate anywhere — even one whose value never reaches the tail — pulls the class out of OverflowFree. It does NOT mean “the result is in range without the guard”: the result of e.g. IntRange.add([0,100], [0,100]) = [0,200] fits i64 but exceeds the type’s [0,100] bound, so fromInt must still run to re-validate the invariant. A future codegen recognizer that lowers the arithmetic to raw i64 on the strength of this class must keep the fromInt call. Dropping it reintroduces the model-vs-runtime gap this whole mechanism exists to close.

Variants

OverflowFree

The arithmetic intermediate provably fits i64, so it can run on raw i64 without wrapping before the guard re-validates.

NeedsWiderScratch

The intermediate exceeds i64 but is a proven-finite range, so a future codegen could compute it in a wider scratch type (i128 or bignum) and then narrow through the guard. None of the current example types reach this band; it exists so the classifier is honest about the middle case rather than collapsing it into Unbounded.

Unbounded

The intermediate has no derivable finite bound — typically because an operand is a one-sided refinement ([0, +inf]) or a plain Int (unbounded by construction). The honest decline: the analysis cannot certify the operation as native-i64-safe.

Implementations

impl OpClass

pub fn of_interval(i: Interval) -> OpClass

Classify an arithmetic intermediate interval. Conservative: only a fully-i64-fitting interval earns OverflowFree.

pub fn label(self) -> &'static str

Stable lowercase label for diagnostics / JSON.

Trait Implementations

impl Clone for OpClass

fn clone(&self) -> OpClass

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for OpClass

impl Debug for OpClass

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for OpClass

impl PartialEq for OpClass

fn eq(&self, other: &OpClass) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for OpClass