Struct rustc_trans::middle::infer::resolve::OpportunisticTypeResolver [−] [src]

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

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, 'tcx> OpportunisticTypeResolver<'a, 'tcx>

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

Unstable

Trait Implementations

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

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

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

fn enter_region_binder(&mut self)

fn exit_region_binder(&mut self)

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

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

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

fn fold_substs(&mut self, substs: &Substs<'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: &BareFnTy<'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>

fn fold_item_substs(&mut self, i: ItemSubsts<'tcx>) -> ItemSubsts<'tcx>