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 for SimplifiedType<DefId>

where DefId: Clone,

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 for SimplifiedType<DefId>

where DefId: Debug,

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

Formats the value using the given formatter.

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

where __D: TyDecoder, DefId: Decodable<__D>,

fn decode(__decoder: &mut __D) -> SimplifiedType<DefId>

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

where __E: TyEncoder, DefId: Encodable<__E>,

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

impl EraseType for SimplifiedType<DefId>

type Result = [u8; 16]

impl<DefId> Hash for SimplifiedType<DefId>

where DefId: Hash,

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

where __H: Hasher,

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<SipHasher128>, )

impl Key for SimplifiedType<DefId>

type Cache<V> = DefaultCache<SimplifiedType<DefId>, V>

fn default_span(&self, _: TyCtxt<'_>) -> Span

In the event that a cycle occurs, if no explicit span has been given for a query with key self, what span should we use?

fn key_as_def_id(&self) -> Option<DefId>

If the key is a DefId or DefId–equivalent, return that DefId. Otherwise, return None.

fn ty_def_id(&self) -> Option<DefId>

impl ParameterizedOverTcx for SimplifiedType<DefId>

type Value<'tcx> = SimplifiedType<DefId>

impl<DefId> PartialEq for SimplifiedType<DefId>

where DefId: PartialEq,

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, DefId> ToStableHashKey<HCX> for SimplifiedType<DefId>

where HCX: Clone, DefId: HashStable<HCX>,

type KeyType = Fingerprint

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

impl<DefId> Copy for SimplifiedType<DefId>

where DefId: Copy,

impl<DefId> Eq for SimplifiedType<DefId>

where DefId: Eq,

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.