Struct Const 

pub struct Const<I: Interner>(pub I::InternedConstKind);

Tuple Fields

0: I::InternedConstKind

Implementations

impl<I: Interner> Const<I>

pub fn kind(self) -> ConstKind<I>

pub fn new(interner: I, kind: ConstKind<I>) -> Self

pub fn new_var(interner: I, infer: ConstVid) -> Self

pub fn new_infer(interner: I, infer: InferConst) -> Self

pub fn new_bound( interner: I, debruijn: DebruijnIndex, bound_const: BoundConst<I>, ) -> Self

pub fn new_anon_bound( interner: I, debruijn: DebruijnIndex, var: BoundVar, ) -> Self

pub fn new_canonical_bound(interner: I, var: BoundVar) -> Self

pub fn new_placeholder(interner: I, placeholder: PlaceholderConst<I>) -> Self

pub fn new_alias( interner: I, is_rigid: IsRigid, alias_const: AliasConst<I>, ) -> Self

pub fn new_expr(interner: I, expr: I::ExprConst) -> Self

pub fn new_error(interner: I, e: I::ErrorGuaranteed) -> Self

pub fn is_ct_var(self) -> bool

pub fn is_ct_error(self) -> bool

pub fn new_param(interner: I, param: I::ParamConst) -> Self

pub fn new_fresh(interner: I, fresh: u32) -> Self

pub fn new_misc_error(interner: I) -> Self

pub fn new_error_with_message( interner: I, span: I::Span, msg: impl ToString, ) -> Self

pub fn is_trivially_wf(self) -> bool

pub fn is_ct_infer(self) -> bool

pub fn ct_vid(self) -> Option<ConstVid>

pub fn new_value(interner: I, valtree: I::ValTree, ty: I::Ty) -> Self

pub fn zero_sized(interner: I, ty: I::Ty) -> Self

Creates an interned zst constant.

pub fn to_value(self) -> I::ValueConst

Panics if self.kind != ty::ConstKind::Value.

pub fn try_to_value(self) -> Option<I::ValueConst>

Attempts to convert to a value.

Note that this does not normalize the constant.

pub fn to_leaf(self) -> I::ScalarInt

Converts to a ValTreeKind::Leaf value, panic’ing if this constant is some other kind.

Note that this does not normalize the constant.

pub fn to_branch(self) -> I::Consts

Converts to a ValTreeKind::Branch value, panic’ing if this constant is some other kind.

Note that this does not normalize the constant.

pub fn try_to_leaf(self) -> Option<I::ScalarInt>

Attempts to convert to a ValTreeKind::Leaf value.

Note that this does not normalize the constant.

pub fn try_to_branch(self) -> Option<I::Consts>

Attempts to convert to a ValTreeKind::Branch value.

Note that this does not normalize the constant.

pub fn try_to_scalar(self) -> Option<I::Scalar>

Attempts to convert to a ValTreeKind::Leaf value.

Note that this does not normalize the constant.

pub fn from_bits( interner: I, bits: u128, typing_env: I::TypingEnv, ty: I::Ty, ) -> Self

Creates a constant with the given integer value and interns it.

pub fn from_bool(interner: I, v: bool) -> Self

Creates an interned bool constant.

pub fn from_target_usize(interner: I, n: u64) -> Self

Creates an interned usize constant.

pub fn try_to_target_usize(self, interner: I) -> Option<u64>

Convenience method to extract the value of a usize constant, useful to get the length of an array type.

Note that this does not evaluate the constant.

pub fn walk(self) -> TypeWalker<I>

Iterator that walks self and any types reachable from self, in depth-first order. Note that just walks the types that appear in self, it does not descend into the fields of structs or variants. For example:

isize => { isize }
Foo<Bar<isize>> => { Foo<Bar<isize>>, Bar<isize>, isize }
[isize] => { [isize], isize }

Trait Implementations

impl<I> Clone for Const<I>

where I: Interner,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Copy for Const<I>

where I: Interner,

impl<I: Interner> Debug for Const<I>

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

Formats the value using the given formatter.

impl<I: Interner, D: InternerDecoder<Interner = I>> Decodable<D> for Const<I>

where ConstKind<I>: Decodable<D>,

fn decode(decoder: &mut D) -> Self

impl<I> Display for Const<I>

where I: IrPrint<Const<I>> + Interner,

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

Formats the value using the given formatter.

impl<I: Interner, E: Encoder> Encodable<E> for Const<I>

where ConstKind<I>: Encodable<E>,

fn encode(&self, e: &mut E)

impl<I> Eq for Const<I>

where I: Interner,

impl<I: Interner> Flags for Const<I>

fn flags(&self) -> TypeFlags

fn outer_exclusive_binder(&self) -> DebruijnIndex

impl<I: Interner, __V> GenericTypeVisitable<__V> for Const<I>

where I::InternedConstKind: GenericTypeVisitable<__V>,

fn generic_visit_with(&self, __visitor: &mut __V)

impl<I> Hash for Const<I>

where I: Interner,

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<I: Interner> IntoKind for Const<I>

type Kind = ConstKind<I>

fn kind(self) -> Self::Kind

impl<I, J> Lift<J> for Const<I>

where J: Interner, I: LiftInto<J> + Interner,

type Lifted = Const<J>

fn lift_to_interner(self, interner: J) -> Self::Lifted

impl<I> PartialEq for Const<I>

where I: Interner,

fn eq(&self, __other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<I: Interner> Relate<I> for Const<I>

fn relate<R: TypeRelation<I>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<I, Self>

impl<I: Interner> StableHash for Const<I>

where I::InternedConstKind: StableHash,

fn stable_hash<__Hcx: StableHashCtxt>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher, )

impl<I: Interner> TypeFoldable<I> for Const<I>

fn try_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<I: Interner> TypeSuperFoldable<I> for Const<I>

fn try_super_fold_with<F: FallibleTypeFolder<I>>( self, folder: &mut F, ) -> Result<Self, F::Error>

Provides a default fold for a recursive type of interest. This should only be called within TypeFolder methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyFolder::try_fold_ty(ty), it is valid to call ty.try_super_fold_with(self), but any other folding should be done with xyz.try_fold_with(self).

fn super_fold_with<F: TypeFolder<I>>(self, folder: &mut F) -> Self

A convenient alternative to try_super_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_super_fold_with.

impl<I: Interner> TypeSuperVisitable<I> for Const<I>

fn super_visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> V::Result

Provides a default visit for a recursive type of interest. This should only be called within TypeVisitor methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyVisitor::visit_ty(ty), it is valid to call ty.super_visit_with(self), but any other visiting should be done with xyz.visit_with(self).

impl<I: Interner> TypeVisitable<I> for Const<I>

fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> V::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.