Enum rustc_middle::mir::interpret::ConstValue

pub enum ConstValue<'tcx> {
    Scalar(Scalar),
    Slice {
        data: &'tcx Allocation,
        start: usize,
        end: usize,
    },
    ByRef {
        alloc: &'tcx Allocation,
        offset: Size,
    },
}

Represents a constant value in Rust. Scalar and Slice are optimizations for array length computations, enum discriminants and the pattern matching logic.

Variants

Scalar(Scalar)

Used only for types with layout::abi::Scalar ABI and ZSTs.

Not using the enum Value to encode that this must not be Uninit.

Slice

Used only for &[u8] and &str

Fields of Slice

data: &'tcx Allocationstart: usizeend: usize

ByRef

A value not represented/representable by Scalar or Slice

Fields of ByRef

alloc: &'tcx Allocation

The backing memory of the value, may contain more memory than needed for just the value in order to share Allocations between values

offset: Size

Offset into alloc

Implementations

impl<'tcx> ConstValue<'tcx>

pub fn try_to_scalar(&self) -> Option<Scalar>

pub fn try_to_str_slice(&self) -> Option<&'tcx str>

pub fn try_to_bits(&self, size: Size) -> Option<u128>

pub fn try_to_bool(&self) -> Option<bool>

pub fn try_to_machine_usize(&self, tcx: TyCtxt<'tcx>) -> Option<u64>

pub fn try_to_bits_for_ty(
    &self,
    tcx: TyCtxt<'tcx>,
    param_env: ParamEnv<'tcx>,
    ty: Ty<'tcx>
) -> Option<u128>

pub fn from_bool(b: bool) -> Self

pub fn from_u64(i: u64) -> Self

pub fn from_machine_usize(i: u64, cx: &impl HasDataLayout) -> Self

Trait Implementations

impl<'tcx> Clone for ConstValue<'tcx>

fn clone(&self) -> ConstValue<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Copy for ConstValue<'tcx>

impl<'tcx> Debug for ConstValue<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> Decodable for ConstValue<'tcx>

fn decode<__D: Decoder>(d: &mut __D) -> Result<ConstValue<'tcx>, __D::Error>

impl<'tcx> Encodable for ConstValue<'tcx>

fn encode<__S: Encoder>(&self, s: &mut __S) -> Result<(), __S::Error>

impl<'tcx> Eq for ConstValue<'tcx>

impl<'tcx> Hash for ConstValue<'tcx>

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, 

Feeds a slice of this type into the given [Hasher].

impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for ConstValue<'tcx>

fn hash_stable(
    &self,
    __hcx: &mut StableHashingContext<'__ctx>,
    __hasher: &mut StableHasher
)

impl<'tcx> Ord for ConstValue<'tcx>

fn cmp(&self, other: &ConstValue<'tcx>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'tcx> PartialEq<ConstValue<'tcx>> for ConstValue<'tcx>

fn eq(&self, other: &ConstValue<'tcx>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ConstValue<'tcx>) -> bool

This method tests for !=.

impl<'tcx> PartialOrd<ConstValue<'tcx>> for ConstValue<'tcx>

fn partial_cmp(&self, other: &ConstValue<'tcx>) -> Option<Ordering>

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

fn lt(&self, other: &ConstValue<'tcx>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &ConstValue<'tcx>) -> bool

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

fn gt(&self, other: &ConstValue<'tcx>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &ConstValue<'tcx>) -> bool

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

impl<'tcx> StructuralEq for ConstValue<'tcx>

impl<'tcx> StructuralPartialEq for ConstValue<'tcx>