Struct Normalizer

struct Normalizer<'infcx, 'genv, 'tcx> {
    infcx: InferCtxt<'infcx, 'genv, 'tcx>,
    selcx: SelectionContext<'infcx, 'tcx>,
    param_env: List<Clause>,
}

Fields

infcx: InferCtxt<'infcx, 'genv, 'tcx>

selcx: SelectionContext<'infcx, 'tcx>

param_env: List<Clause>

Implementations

impl<'infcx, 'genv, 'tcx> Normalizer<'infcx, 'genv, 'tcx>

fn new(infcx: InferCtxt<'infcx, 'genv, 'tcx>) -> QueryResult<Self>

fn get_impl_id_of_alias_reft( &mut self, alias_reft: &AliasReft, ) -> QueryResult<Option<DefId>>

fn normalize_alias_reft( &mut self, alias_reft: &AliasReft, refine_args: &RefineArgs, ) -> QueryResult<Expr>

fn normalize_projection_ty( &mut self, obligation: &AliasTy, ) -> QueryResult<(bool, SubsetTyCtor)>

fn find_resolved_predicates( &self, subst: &mut TVarSubst, preds: Vec<EarlyBinder<ProjectionPredicate>>, ) -> (Vec<ProjectionPredicate>, Vec<EarlyBinder<ProjectionPredicate>>)

fn resolve_projection_predicates( &mut self, subst: &mut TVarSubst, impl_def_id: DefId, ) -> QueryResult

fn confirm_candidate( &mut self, candidate: Candidate, obligation: &AliasTy, ) -> QueryResult<SubsetTyCtor>

fn assemble_candidates_from_param_env( &self, obligation: &AliasTy, candidates: &mut Vec<Candidate>, )

fn assemble_candidates_from_trait_def( &self, obligation: &AliasTy, candidates: &mut Vec<Candidate>, ) -> QueryResult

fn assemble_candidates_from_impls( &mut self, obligation: &AliasTy, candidates: &mut Vec<Candidate>, ) -> QueryResult

fn def_id(&self) -> DefId

fn genv(&self) -> GlobalEnv<'genv, 'tcx>

fn tcx(&self) -> TyCtxt<'tcx>

fn rustc_param_env(&self) -> ParamEnv<'tcx>

Trait Implementations

impl FallibleTypeFolder for Normalizer<'_, '_, '_>

type Error = QueryErr

fn try_fold_sort(&mut self, sort: &Sort) -> Result<Sort, Self::Error>

fn try_fold_ty(&mut self, ty: &Ty) -> Result<Ty, Self::Error>

fn try_fold_subset_ty( &mut self, sty: &SubsetTy, ) -> Result<SubsetTy, Self::Error>

fn try_fold_expr(&mut self, expr: &Expr) -> Result<Expr, Self::Error>

fn try_fold_const(&mut self, c: &Const) -> Result<Const, Self::Error>

fn try_fold_binder<T>( &mut self, t: &Binder<T>, ) -> Result<Binder<T>, Self::Error>

where T: TypeFoldable,

fn try_fold_bty(&mut self, bty: &BaseTy) -> Result<BaseTy, Self::Error>

fn try_fold_region(&mut self, re: &Region) -> Result<Region, Self::Error>