Struct rustc_typeck::check::writeback::Resolver

pub(in check::writeback) struct Resolver<'cx, 'tcx> {
    tcx: TyCtxt<'tcx>,
    infcx: &'cx InferCtxt<'cx, 'tcx>,
    span: &'cx dyn Locatable,
    body: &'tcx Body<'tcx>,
    replaced_with_error: bool,
}

The Resolver. This is the type folding engine that detects unresolved types and so forth.

Fields

tcx: TyCtxt<'tcx>

infcx: &'cx InferCtxt<'cx, 'tcx>

span: &'cx dyn Locatable

body: &'tcx Body<'tcx>

replaced_with_error: bool

Set to true if any Ty or ty::Const had to be replaced with an Error.

Implementations

impl<'cx, 'tcx> Resolver<'cx, 'tcx>

pub(in check::writeback) fn new(
    fcx: &'cx FnCtxt<'cx, 'tcx>,
    span: &'cx dyn Locatable,
    body: &'tcx Body<'tcx>
) -> Resolver<'cx, 'tcx>

pub(in check::writeback) fn report_type_error(
    &self,
    t: Ty<'tcx>
)

pub(in check::writeback) fn report_const_error(
    &self,
    c: &'tcx Const<'tcx>
)

Trait Implementations

impl<'cx, 'tcx> TypeFolder<'tcx> for Resolver<'cx, 'tcx>

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

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

pub fn fold_region(&mut self, r: Region<'tcx>) -> Region<'tcx>

pub fn fold_const(&mut self, ct: &'tcx Const<'tcx>) -> &'tcx Const<'tcx>

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