Struct TypingEnv

pub struct TypingEnv<'tcx> {
    pub typing_mode: TypingMode<'tcx>,
    pub param_env: ParamEnv<'tcx>,
}

The environment in which to do trait solving.

Most of the time you only need to care about the ParamEnv as the TypingMode is simply stored in the InferCtxt.

However, there are some places which rely on trait solving without using an InferCtxt themselves. For these to be able to use the trait system they have to be able to initialize such an InferCtxt with the right typing_mode, so they need to track both.

Fields

typing_mode: TypingMode<'tcx>

param_env: ParamEnv<'tcx>

Implementations

impl<'tcx> TypingEnv<'tcx>

pub fn fully_monomorphized() -> TypingEnv<'tcx>

Create a typing environment with no where-clauses in scope where all opaque types and default associated items are revealed.

This is only suitable for monomorphized, post-typeck environments. Do not use this for MIR optimizations, as even though they also use TypingMode::PostAnalysis, they may still have where-clauses in scope.

pub fn non_body_analysis( tcx: TyCtxt<'tcx>, def_id: impl IntoQueryParam<DefId>, ) -> TypingEnv<'tcx>

Create a typing environment for use during analysis outside of a body.

Using a typing environment inside of bodies is not supported as the body may define opaque types. In this case the used functions have to be converted to use proper canonical inputs instead.

pub fn post_analysis( tcx: TyCtxt<'tcx>, def_id: impl IntoQueryParam<DefId>, ) -> TypingEnv<'tcx>

pub fn with_post_analysis_normalized(self, tcx: TyCtxt<'tcx>) -> TypingEnv<'tcx>

Modify the typing_mode to PostAnalysis and eagerly reveal all opaque types in the param_env.

pub fn as_query_input<T>(self, value: T) -> PseudoCanonicalInput<'tcx, T>

where T: TypeVisitable<TyCtxt<'tcx>>,

Combine this typing environment with the given value to be used by not (yet) canonicalized queries. This only works if the value does not contain anything local to some InferCtxt, i.e. inference variables or placeholders.

Trait Implementations

impl<'tcx> Clone for TypingEnv<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for TypingEnv<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> Hash for TypingEnv<'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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

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

impl<'tcx> PartialEq for TypingEnv<'tcx>

fn eq(&self, other: &TypingEnv<'tcx>) -> 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 TypingEnv<'tcx>

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

where F: TypeFolder<I>,

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 TypingEnv<'tcx>

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &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).

impl<'tcx> Copy for TypingEnv<'tcx>

impl<'tcx> Eq for TypingEnv<'tcx>

impl<'tcx> StructuralPartialEq for TypingEnv<'tcx>

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: 24 bytes