Enum Reveal

pub enum Reveal {
    UserFacing,
    All,
}

Depending on the stage of compilation, we want projection to be more or less conservative.

Variants

UserFacing

At type-checking time, we refuse to project any associated type that is marked default. Non-default (“final”) types are always projected. This is necessary in general for soundness of specialization. However, we could allow projections in fully-monomorphic cases. We choose not to, because we prefer for default type to force the type definition to be treated abstractly by any consumers of the impl. Concretely, that means that the following example will fail to compile:

#![feature(specialization)]
trait Assoc {
    type Output;
}

impl<T> Assoc for T {
    default type Output = bool;
}

fn main() {
    let x: <() as Assoc>::Output = true;
}

We also do not reveal the hidden type of opaque types during type-checking.

All

At codegen time, all monomorphic projections will succeed. Also, impl Trait is normalized to the concrete type, which has to be already collected by type-checking.

NOTE: as impl Trait’s concrete type should never be observable directly by the user, Reveal::All should not be used by checks which may expose type equality or type contents to the user. There are some exceptions, e.g., around auto traits and transmute-checking, which expose some details, but not the whole concrete type of the impl Trait.

Trait Implementations

impl Clone for Reveal

fn clone(&self) -> Reveal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Reveal

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

Formats the value using the given formatter.

impl<__D> Decodable<__D> for Reveal

where __D: TyDecoder,

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

impl<__E> Encodable<__E> for Reveal

where __E: TyEncoder,

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

impl Hash for Reveal

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<__CTX> HashStable<__CTX> for Reveal

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

impl PartialEq for Reveal

fn eq(&self, other: &Reveal) -> 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<'tcx> TypeFoldable<TyCtxt<'tcx>> for Reveal

fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, _: &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<TyCtxt<'tcx>>>(self, _: &mut F) -> Self

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

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Reveal

fn visit_with<F: TypeVisitor<TyCtxt<'tcx>>>(&self, _: &mut F) -> F::Result

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

impl Copy for Reveal

impl Eq for Reveal

impl StructuralPartialEq for Reveal

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1 byte

Size for each variant:

• UserFacing: 0 bytes
• All: 0 bytes