Enum SimplifiedType

pub enum SimplifiedType<DefId> {
    Bool,
    Char,
    Int(IntTy),
    Uint(UintTy),
    Float(FloatTy),
    Adt(DefId),
    Foreign(DefId),
    Str,
    Array,
    Slice,
    Ref(Mutability),
    Ptr(Mutability),
    Never,
    Tuple(usize),
    MarkerTraitObject,
    Trait(DefId),
    Closure(DefId),
    Coroutine(DefId),
    CoroutineWitness(DefId),
    Function(usize),
    Placeholder,
    Error,
}

See simplify_type.

Variants

Bool

Char

Int(IntTy)

Uint(UintTy)

Float(FloatTy)

Adt(DefId)

Foreign(DefId)

Str

Array

Slice

Ref(Mutability)

Ptr(Mutability)

Never

Tuple(usize)

MarkerTraitObject

A trait object, all of whose components are markers (e.g., dyn Send + Sync).

Trait(DefId)

Closure(DefId)

Coroutine(DefId)

CoroutineWitness(DefId)

Function(usize)

Placeholder

Error

Implementations

impl<DefId> SimplifiedType<DefId>

pub fn def(self) -> Option<DefId>

Trait Implementations

impl<DefId: Clone> Clone for SimplifiedType<DefId>

fn clone(&self) -> SimplifiedType<DefId>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<DefId: Debug> Debug for SimplifiedType<DefId>

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

Formats the value using the given formatter.

impl<DefId, __D: TyDecoder> Decodable<__D> for SimplifiedType<DefId>

where DefId: Decodable<__D>,

fn decode(__decoder: &mut __D) -> Self

impl<DefId, __E: TyEncoder> Encodable<__E> for SimplifiedType<DefId>

where DefId: Encodable<__E>,

fn encode(&self, __encoder: &mut __E)

impl<DefId: Hash> Hash for SimplifiedType<DefId>

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<DefId, __CTX> HashStable<__CTX> for SimplifiedType<DefId>

where DefId: HashStable<__CTX>,

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl<DefId: PartialEq> PartialEq for SimplifiedType<DefId>

fn eq(&self, other: &SimplifiedType<DefId>) -> 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<HCX: Clone, DefId: HashStable<HCX>> ToStableHashKey<HCX> for SimplifiedType<DefId>

type KeyType = Fingerprint

fn to_stable_hash_key(&self, hcx: &HCX) -> Fingerprint

impl<DefId: Copy> Copy for SimplifiedType<DefId>

impl<DefId: Eq> Eq for SimplifiedType<DefId>

impl<DefId> StructuralPartialEq for SimplifiedType<DefId>

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.