Enum Opt 

#[repr(u8)]
pub enum Opt {
    Memo = 0,
    Tco = 1,
    Peephole = 2,
    Borrow = 3,
    Specialize = 4,
    Comptime = 5,
    Inline = 6,
    Unfold = 7,
    Defunctionalize = 8,
    LoopHoist = 9,
    Unroll = 10,
    LoopSplit = 11,
    ClosedForm = 12,
    Fuse = 13,
    LoopCse = 14,
    Cse = 15,
    DeadCode = 16,
    Scalarize = 17,
    Affine = 18,
    Interleave = 19,
    Unbox = 20,
    HoistBorrows = 21,
    Narrow = 22,
    NarrowVm = 23,
    NarrowMap = 24,
    DenseMap = 25,
    ElemType = 26,
    FastDiv = 27,
    FloatStrength = 28,
    Oracle = 29,
    OracleHints = 30,
    Unchecked = 31,
    Simd = 32,
    Cascade = 33,
    IndexString = 34,
    CapScale = 35,
    Symmetry = 36,
    Popcount = 37,
    Saturate = 38,
    Supercompile = 39,
}

Every optimization the compiler can toggle. The discriminant is the bit index used by OptimizationConfig, so the order here is stable and must not be reordered casually (it also defines conflict-resolution precedence: an earlier variant wins a conflict against a later one).

Variants

Memo = 0

Automatic memoization of pure functions.

Tco = 1

Tail-call optimization (self-tail-recursion → loop).

Peephole = 2

Peephole rewrites (swap, vec-fill, for-range, …).

Borrow = 3

Read-only / mutable borrow inference (&[T] / &mut [T] params).

Specialize = 4

Partial evaluation / polyvariant specialization.

Comptime = 5

Compile-time function evaluation (CTFE).

Inline = 6

Inlining of tiny and leaf helper functions.

Unfold = 7

Bounded unrolling of recursive functions.

Defunctionalize = 8

Defunctionalization (closures → first-order functions).

LoopHoist = 9

Loop-invariant code motion (LICM).

Unroll = 10

Loop unrolling of constant-trip loops.

LoopSplit = 11

Guard-based loop index-set splitting (for vectorization).

ClosedForm = 12

Accumulator-loop → closed-form recognition.

Fuse = 13

Deforestation (producer/consumer stream fusion).

LoopCse = 14

Loop-carried common-subexpression hoisting.

Cse = 15

Global value numbering / common-subexpression elimination.

DeadCode = 16

Dead-code elimination.

Scalarize = 17

Fixed-size sequence scalarization (SROA).

Affine = 18

Affine offset-array deletion → closed-form indexing.

Interleave = 19

Array-of-structs interleaving of co-indexed sequences.

Unbox = 20

De-Rc: unique-owned sequences become plain Vec.

HoistBorrows = 21

Hoisting borrow live-ranges out of loop nests.

Narrow = 22

i64→i32 sequence element narrowing (codegen).

NarrowVm = 23

i64→i32 sequence element narrowing (VM).

NarrowMap = 24

i64→i32 map-key narrowing.

DenseMap = 25

Sparse map → dense direct-addressed array.

ElemType = 26

Element-type narrowing via abstract interpretation.

FastDiv = 27

Constant-divisor magic-reciprocal division.

FloatStrength = 28

Float induction-variable strength reduction.

Oracle = 29

Abstract interpretation / oracle-fact production (interval analysis).

OracleHints = 30

Oracle-derived precise bounds-check guards.

Unchecked = 31

Oracle-proven unchecked indexing (get_unchecked).

Simd = 32

SIMD-vectorized search kernels.

Cascade = 33

Cascade folding of sequential comparisons.

IndexString = 34

Indexed string-search codegen.

CapScale = 35

Capacity-scaling buffer-fill simplification.

Symmetry = 36

Reflection symmetry breaking (bitmask search).

Popcount = 37

Popcount base-case collapse for bitmask search.

Saturate = 38

Equality-saturation rewriting (e-graph).

Supercompile = 39

Supercompilation (heavy residual specialization, AOT only).

Implementations

impl Opt

pub const fn bit(self) -> u64

The bit index this optimization occupies in an OptimizationConfig.

pub fn meta(self) -> &'static OptMeta

This optimization’s registry row.

pub fn cost(self) -> OptCost

How expensive this optimization is to run — the lever the tiered optimizer uses to decide which hotness tier pays for it.

Trait Implementations

impl Clone for Opt

fn clone(&self) -> Opt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Opt

impl Debug for Opt

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Opt

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Opt

impl Hash for Opt

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Opt

fn cmp(&self, other: &Opt) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Opt

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Opt

fn partial_cmp(&self, other: &Opt) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Opt

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Opt