Struct rustc_trait_selection::traits::query::type_op::Normalize

pub struct Normalize<T> {
    pub value: T,
}

Fields

value: T

Implementations

impl<'tcx, T> Normalize<T>

where T: Debug + TypeFoldable<TyCtxt<'tcx>>,

pub fn new(value: T) -> Normalize<T>

Trait Implementations

impl<T> Clone for Normalize<T>

where T: Clone,

fn clone(&self) -> Normalize<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Normalize<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Hash for Normalize<T>

where T: 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<'__ctx, T> HashStable<StableHashingContext<'__ctx>> for Normalize<T>

where T: HashStable<StableHashingContext<'__ctx>>,

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

impl<T> PartialEq for Normalize<T>

where T: PartialEq,

fn eq(&self, other: &Normalize<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx, T> QueryTypeOp<'tcx> for Normalize<T>

where T: Normalizable<'tcx> + 'tcx,

type QueryResponse = T

fn try_fast_path(_tcx: TyCtxt<'tcx>, key: &ParamEnvAnd<'tcx, Self>) -> Option<T>

Give query the option for a simple fast path that never actually hits the tcx cache lookup etc. Return Some(r) with a final result or None to do the full path.

fn perform_query( tcx: TyCtxt<'tcx>, canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Self>> ) -> Result<CanonicalQueryResponse<'tcx, Self::QueryResponse>, NoSolution>

Performs the actual query with the canonicalized key – the real work happens here. This method is not given an infcx because it shouldn’t need one – and if it had access to one, it might do things like invoke sub_regions, which would be bad, because it would create subregion relationships that are not captured in the return value.

fn perform_locally_with_next_solver( ocx: &ObligationCtxt<'_, 'tcx>, key: ParamEnvAnd<'tcx, Self> ) -> Result<Self::QueryResponse, NoSolution>

In the new trait solver, we already do caching in the solver itself, so there’s no need to canonicalize and cache via the query system. Additionally, even if we were to canonicalize, we’d still need to make sure to feed it predefined opaque types and the defining anchor and that would require duplicating all of the tcx queries. Instead, just perform these ops locally.

fn fully_perform_into( query_key: ParamEnvAnd<'tcx, Self>, infcx: &InferCtxt<'tcx>, output_query_region_constraints: &mut QueryRegionConstraints<'tcx>, span: Span ) -> Result<(Self::QueryResponse, Option<Canonical<'tcx, ParamEnvAnd<'tcx, Self>>>, PredicateObligations<'tcx>, Certainty), NoSolution>

impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for Normalize<T>

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

fn try_fold_with<__F>( self, __folder: &mut __F ) -> Result<Normalize<T>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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, T> TypeVisitable<TyCtxt<'tcx>> for Normalize<T>

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

fn visit_with<__V>( &self, __visitor: &mut __V ) -> <__V as TypeVisitor<TyCtxt<'tcx>>>::Result

where __V: TypeVisitor<TyCtxt<'tcx>>,

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

impl<T> Copy for Normalize<T>

where T: Copy,

impl<T> Eq for Normalize<T>

where T: Eq,

impl<T> StructuralPartialEq for Normalize<T>

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.