compiler/rustc_middle/src/ty/normalize_erasing_regions.rs

   1 //! Methods for normalizing when you don't care about regions (and
   2 //! aren't doing type inference). If either of those things don't
   3 //! apply to you, use `infcx.normalize(...)`.
   4 //!
   5 //! The methods in this file use a `TypeFolder` to recursively process
   6 //! contents, invoking the underlying
   7 //! `normalize_generic_arg_after_erasing_regions` query for each type
   8 //! or constant found within. (This underlying query is what is cached.)
   9
  10 use crate::mir;
  11 use crate::traits::query::NoSolution;
  12 use crate::ty::fold::{FallibleTypeFolder, TypeFoldable, TypeFolder};
  13 use crate::ty::subst::{Subst, SubstsRef};
  14 use crate::ty::{self, EarlyBinder, Ty, TyCtxt};
  15
  16 #[derive(Debug, Copy, Clone, HashStable, TyEncodable, TyDecodable)]
  17 pub enum NormalizationError<'tcx> {
  18     Type(Ty<'tcx>),
  19     Const(ty::Const<'tcx>),
  20     ConstantKind(mir::ConstantKind<'tcx>),
  21 }
  22
  23 impl<'tcx> NormalizationError<'tcx> {
  24     pub fn get_type_for_failure(&self) -> String {
  25         match self {
  26             NormalizationError::Type(t) => format!("{}", t),
  27             NormalizationError::Const(c) => format!("{}", c),
  28             NormalizationError::ConstantKind(ck) => format!("{}", ck),
  29         }
  30     }
  31 }
  32
  33 impl<'tcx> TyCtxt<'tcx> {
  34     /// Erase the regions in `value` and then fully normalize all the
  35     /// types found within. The result will also have regions erased.
  36     ///
  37     /// This should only be used outside of type inference. For example,
  38     /// it assumes that normalization will succeed.
  39     pub fn normalize_erasing_regions<T>(self, param_env: ty::ParamEnv<'tcx>, value: T) -> T
  40     where
  41         T: TypeFoldable<'tcx>,
  42     {
  43         debug!(
  44             "normalize_erasing_regions::<{}>(value={:?}, param_env={:?})",
  45             std::any::type_name::<T>(),
  46             value,
  47             param_env,
  48         );
  49
  50         // Erase first before we do the real query -- this keeps the
  51         // cache from being too polluted.
  52         let value = self.erase_regions(value);
  53         debug!(?value);
  54
  55         if !value.has_projections() {
  56             value
  57         } else {
  58             value.fold_with(&mut NormalizeAfterErasingRegionsFolder { tcx: self, param_env })
  59         }
  60     }
  61
  62     /// Tries to erase the regions in `value` and then fully normalize all the
  63     /// types found within. The result will also have regions erased.
  64     ///
  65     /// Contrary to `normalize_erasing_regions` this function does not assume that normalization
  66     /// succeeds.
  67     pub fn try_normalize_erasing_regions<T>(
  68         self,
  69         param_env: ty::ParamEnv<'tcx>,
  70         value: T,
  71     ) -> Result<T, NormalizationError<'tcx>>
  72     where
  73         T: TypeFoldable<'tcx>,
  74     {
  75         debug!(
  76             "try_normalize_erasing_regions::<{}>(value={:?}, param_env={:?})",
  77             std::any::type_name::<T>(),
  78             value,
  79             param_env,
  80         );
  81
  82         // Erase first before we do the real query -- this keeps the
  83         // cache from being too polluted.
  84         let value = self.erase_regions(value);
  85         debug!(?value);
  86
  87         if !value.has_projections() {
  88             Ok(value)
  89         } else {
  90             let mut folder = TryNormalizeAfterErasingRegionsFolder::new(self, param_env);
  91             value.try_fold_with(&mut folder)
  92         }
  93     }
  94
  95     /// If you have a `Binder<'tcx, T>`, you can do this to strip out the
  96     /// late-bound regions and then normalize the result, yielding up
  97     /// a `T` (with regions erased). This is appropriate when the
  98     /// binder is being instantiated at the call site.
  99     ///
 100     /// N.B., currently, higher-ranked type bounds inhibit
 101     /// normalization. Therefore, each time we erase them in
 102     /// codegen, we need to normalize the contents.
 103     pub fn normalize_erasing_late_bound_regions<T>(
 104         self,
 105         param_env: ty::ParamEnv<'tcx>,
 106         value: ty::Binder<'tcx, T>,
 107     ) -> T
 108     where
 109         T: TypeFoldable<'tcx>,
 110     {
 111         let value = self.erase_late_bound_regions(value);
 112         self.normalize_erasing_regions(param_env, value)
 113     }
 114
 115     /// If you have a `Binder<'tcx, T>`, you can do this to strip out the
 116     /// late-bound regions and then normalize the result, yielding up
 117     /// a `T` (with regions erased). This is appropriate when the
 118     /// binder is being instantiated at the call site.
 119     ///
 120     /// N.B., currently, higher-ranked type bounds inhibit
 121     /// normalization. Therefore, each time we erase them in
 122     /// codegen, we need to normalize the contents.
 123     pub fn try_normalize_erasing_late_bound_regions<T>(
 124         self,
 125         param_env: ty::ParamEnv<'tcx>,
 126         value: ty::Binder<'tcx, T>,
 127     ) -> Result<T, NormalizationError<'tcx>>
 128     where
 129         T: TypeFoldable<'tcx>,
 130     {
 131         let value = self.erase_late_bound_regions(value);
 132         self.try_normalize_erasing_regions(param_env, value)
 133     }
 134
 135     /// Monomorphizes a type from the AST by first applying the
 136     /// in-scope substitutions and then normalizing any associated
 137     /// types.
 138     /// Panics if normalization fails. In case normalization might fail
 139     /// use `try_subst_and_normalize_erasing_regions` instead.
 140     pub fn subst_and_normalize_erasing_regions<T>(
 141         self,
 142         param_substs: SubstsRef<'tcx>,
 143         param_env: ty::ParamEnv<'tcx>,
 144         value: T,
 145     ) -> T
 146     where
 147         T: TypeFoldable<'tcx>,
 148     {
 149         debug!(
 150             "subst_and_normalize_erasing_regions(\
 151              param_substs={:?}, \
 152              value={:?}, \
 153              param_env={:?})",
 154             param_substs, value, param_env,
 155         );
 156         let substituted = EarlyBinder(value).subst(self, param_substs);
 157         self.normalize_erasing_regions(param_env, substituted)
 158     }
 159
 160     /// Monomorphizes a type from the AST by first applying the
 161     /// in-scope substitutions and then trying to normalize any associated
 162     /// types. Contrary to `subst_and_normalize_erasing_regions` this does
 163     /// not assume that normalization succeeds.
 164     pub fn try_subst_and_normalize_erasing_regions<T>(
 165         self,
 166         param_substs: SubstsRef<'tcx>,
 167         param_env: ty::ParamEnv<'tcx>,
 168         value: T,
 169     ) -> Result<T, NormalizationError<'tcx>>
 170     where
 171         T: TypeFoldable<'tcx>,
 172     {
 173         debug!(
 174             "subst_and_normalize_erasing_regions(\
 175              param_substs={:?}, \
 176              value={:?}, \
 177              param_env={:?})",
 178             param_substs, value, param_env,
 179         );
 180         let substituted = EarlyBinder(value).subst(self, param_substs);
 181         self.try_normalize_erasing_regions(param_env, substituted)
 182     }
 183 }
 184
 185 struct NormalizeAfterErasingRegionsFolder<'tcx> {
 186     tcx: TyCtxt<'tcx>,
 187     param_env: ty::ParamEnv<'tcx>,
 188 }
 189
 190 impl<'tcx> NormalizeAfterErasingRegionsFolder<'tcx> {
 191     #[instrument(skip(self), level = "debug")]
 192     fn normalize_generic_arg_after_erasing_regions(
 193         &self,
 194         arg: ty::GenericArg<'tcx>,
 195     ) -> ty::GenericArg<'tcx> {
 196         let arg = self.param_env.and(arg);
 197         debug!(?arg);
 198
 199         self.tcx.try_normalize_generic_arg_after_erasing_regions(arg).unwrap_or_else(|_| bug!(
 200                 "Failed to normalize {:?}, maybe try to call `try_normalize_erasing_regions` instead",
 201                 arg.value
 202             ))
 203     }
 204 }
 205
 206 impl<'tcx> TypeFolder<'tcx> for NormalizeAfterErasingRegionsFolder<'tcx> {
 207     fn tcx(&self) -> TyCtxt<'tcx> {
 208         self.tcx
 209     }
 210
 211     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
 212         self.normalize_generic_arg_after_erasing_regions(ty.into()).expect_ty()
 213     }
 214
 215     fn fold_const(&mut self, c: ty::Const<'tcx>) -> ty::Const<'tcx> {
 216         self.normalize_generic_arg_after_erasing_regions(c.into()).expect_const()
 217     }
 218
 219     #[inline]
 220     fn fold_mir_const(&mut self, c: mir::ConstantKind<'tcx>) -> mir::ConstantKind<'tcx> {
 221         // FIXME: This *probably* needs canonicalization too!
 222         let arg = self.param_env.and(c);
 223         self.tcx
 224             .try_normalize_mir_const_after_erasing_regions(arg)
 225             .unwrap_or_else(|_| bug!("failed to normalize {:?}", c))
 226     }
 227 }
 228
 229 struct TryNormalizeAfterErasingRegionsFolder<'tcx> {
 230     tcx: TyCtxt<'tcx>,
 231     param_env: ty::ParamEnv<'tcx>,
 232 }
 233
 234 impl<'tcx> TryNormalizeAfterErasingRegionsFolder<'tcx> {
 235     fn new(tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> Self {
 236         TryNormalizeAfterErasingRegionsFolder { tcx, param_env }
 237     }
 238
 239     #[instrument(skip(self), level = "debug")]
 240     fn try_normalize_generic_arg_after_erasing_regions(
 241         &self,
 242         arg: ty::GenericArg<'tcx>,
 243     ) -> Result<ty::GenericArg<'tcx>, NoSolution> {
 244         let arg = self.param_env.and(arg);
 245         debug!(?arg);
 246
 247         self.tcx.try_normalize_generic_arg_after_erasing_regions(arg)
 248     }
 249 }
 250
 251 impl<'tcx> FallibleTypeFolder<'tcx> for TryNormalizeAfterErasingRegionsFolder<'tcx> {
 252     type Error = NormalizationError<'tcx>;
 253
 254     fn tcx(&self) -> TyCtxt<'tcx> {
 255         self.tcx
 256     }
 257
 258     fn try_fold_ty(&mut self, ty: Ty<'tcx>) -> Result<Ty<'tcx>, Self::Error> {
 259         match self.try_normalize_generic_arg_after_erasing_regions(ty.into()) {
 260             Ok(t) => Ok(t.expect_ty()),
 261             Err(_) => Err(NormalizationError::Type(ty)),
 262         }
 263     }
 264
 265     fn try_fold_const(&mut self, c: ty::Const<'tcx>) -> Result<ty::Const<'tcx>, Self::Error> {
 266         match self.try_normalize_generic_arg_after_erasing_regions(c.into()) {
 267             Ok(t) => Ok(t.expect_const()),
 268             Err(_) => Err(NormalizationError::Const(c)),
 269         }
 270     }
 271
 272     fn try_fold_mir_const(
 273         &mut self,
 274         c: mir::ConstantKind<'tcx>,
 275     ) -> Result<mir::ConstantKind<'tcx>, Self::Error> {
 276         // FIXME: This *probably* needs canonicalization too!
 277         let arg = self.param_env.and(c);
 278         match self.tcx.try_normalize_mir_const_after_erasing_regions(arg) {
 279             Ok(c) => Ok(c),
 280             Err(_) => Err(NormalizationError::ConstantKind(c)),
 281         }
 282     }
 283 }