Struct rustc::infer::resolve::OpportunisticTypeResolver

pub struct OpportunisticTypeResolver<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
    // some fields omitted
}

Unstable (rustc_private)

The opportunistic type resolver can be used at any time. It simply replaces type variables that have been unified with the things they have been unified with (similar to shallow_resolve, but deep). This is useful for printing messages etc but also required at various points for correctness.

Methods

impl<'a, 'gcx, 'tcx> OpportunisticTypeResolver<'a, 'gcx, 'tcx>

fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>) -> Self

Trait Implementations

impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for OpportunisticTypeResolver<'a, 'gcx, 'tcx>

fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx>

fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx>

fn fold_binder<T>(&mut self, t: &Binder<T>) -> Binder<T> where T: TypeFoldable<'tcx>

fn fold_mt(&mut self, t: &TypeAndMut<'tcx>) -> TypeAndMut<'tcx>

fn fold_trait_ref(&mut self, t: &TraitRef<'tcx>) -> TraitRef<'tcx>

fn fold_impl_header(&mut self, imp: &ImplHeader<'tcx>) -> ImplHeader<'tcx>

fn fold_substs(&mut self, substs: &'tcx Substs<'tcx>) -> &'tcx Substs<'tcx>

fn fold_fn_sig(&mut self, sig: &FnSig<'tcx>) -> FnSig<'tcx>

fn fold_output(&mut self, output: &FnOutput<'tcx>) -> FnOutput<'tcx>

fn fold_bare_fn_ty(&mut self, fty: &'tcx BareFnTy<'tcx>) -> &'tcx BareFnTy<'tcx>

fn fold_closure_ty(&mut self, fty: &ClosureTy<'tcx>) -> ClosureTy<'tcx>

fn fold_region(&mut self, r: Region) -> Region

fn fold_existential_bounds(&mut self, s: &ExistentialBounds<'tcx>) -> ExistentialBounds<'tcx>

fn fold_autoref(&mut self, ar: &AutoRef<'tcx>) -> AutoRef<'tcx>