compiler/rustc_middle/src/ty/erase_regions.rs

   1 use crate::mir;
   2 use crate::ty::fold::{TypeFoldable, TypeFolder};
   3 use crate::ty::{self, Ty, TyCtxt, TypeFlags};
   4
   5 pub(super) fn provide(providers: &mut ty::query::Providers) {
   6     *providers = ty::query::Providers { erase_regions_ty, ..*providers };
   7 }
   8
   9 fn erase_regions_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
  10     // N.B., use `super_fold_with` here. If we used `fold_with`, it
  11     // could invoke the `erase_regions_ty` query recursively.
  12     ty.super_fold_with(&mut RegionEraserVisitor { tcx })
  13 }
  14
  15 impl<'tcx> TyCtxt<'tcx> {
  16     /// Returns an equivalent value with all free regions removed (note
  17     /// that late-bound regions remain, because they are important for
  18     /// subtyping, but they are anonymized and normalized as well)..
  19     pub fn erase_regions<T>(self, value: T) -> T
  20     where
  21         T: TypeFoldable<'tcx>,
  22     {
  23         // If there's nothing to erase avoid performing the query at all
  24         if !value
  25             .has_type_flags(TypeFlags::HAS_RE_LATE_BOUND | TypeFlags::HAS_POTENTIAL_FREE_REGIONS)
  26         {
  27             return value;
  28         }
  29         debug!("erase_regions({:?})", value);
  30         let value1 = value.fold_with(&mut RegionEraserVisitor { tcx: self });
  31         debug!("erase_regions = {:?}", value1);
  32         value1
  33     }
  34 }
  35
  36 struct RegionEraserVisitor<'tcx> {
  37     tcx: TyCtxt<'tcx>,
  38 }
  39
  40 impl<'tcx> TypeFolder<'tcx> for RegionEraserVisitor<'tcx> {
  41     fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
  42         self.tcx
  43     }
  44
  45     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
  46         if ty.needs_infer() { ty.super_fold_with(self) } else { self.tcx.erase_regions_ty(ty) }
  47     }
  48
  49     fn fold_binder<T>(&mut self, t: ty::Binder<'tcx, T>) -> ty::Binder<'tcx, T>
  50     where
  51         T: TypeFoldable<'tcx>,
  52     {
  53         let u = self.tcx.anonymize_late_bound_regions(t);
  54         u.super_fold_with(self)
  55     }
  56
  57     fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
  58         // because late-bound regions affect subtyping, we can't
  59         // erase the bound/free distinction, but we can replace
  60         // all free regions with 'erased.
  61         //
  62         // Note that we *CAN* replace early-bound regions -- the
  63         // type system never "sees" those, they get substituted
  64         // away. In codegen, they will always be erased to 'erased
  65         // whenever a substitution occurs.
  66         match *r {
  67             ty::ReLateBound(..) => r,
  68             _ => self.tcx.lifetimes.re_erased,
  69         }
  70     }
  71
  72     fn fold_mir_const(&mut self, c: mir::ConstantKind<'tcx>) -> mir::ConstantKind<'tcx> {
  73         c.super_fold_with(self)
  74     }
  75 }