compiler/rustc_trait_selection/src/autoderef.rs

   1 use crate::errors::AutoDerefReachedRecursionLimit;
   2 use crate::traits::query::evaluate_obligation::InferCtxtExt;
   3 use crate::traits::{self, TraitEngine, TraitEngineExt};
   4 use rustc_hir as hir;
   5 use rustc_infer::infer::InferCtxt;
   6 use rustc_middle::ty::TypeVisitable;
   7 use rustc_middle::ty::{self, TraitRef, Ty, TyCtxt};
   8 use rustc_session::Limit;
   9 use rustc_span::def_id::LOCAL_CRATE;
  10 use rustc_span::Span;
  11
  12 #[derive(Copy, Clone, Debug)]
  13 pub enum AutoderefKind {
  14     Builtin,
  15     Overloaded,
  16 }
  17
  18 struct AutoderefSnapshot<'tcx> {
  19     at_start: bool,
  20     reached_recursion_limit: bool,
  21     steps: Vec<(Ty<'tcx>, AutoderefKind)>,
  22     cur_ty: Ty<'tcx>,
  23     obligations: Vec<traits::PredicateObligation<'tcx>>,
  24 }
  25
  26 pub struct Autoderef<'a, 'tcx> {
  27     // Meta infos:
  28     infcx: &'a InferCtxt<'tcx>,
  29     span: Span,
  30     body_id: hir::HirId,
  31     param_env: ty::ParamEnv<'tcx>,
  32
  33     // Current state:
  34     state: AutoderefSnapshot<'tcx>,
  35
  36     // Configurations:
  37     include_raw_pointers: bool,
  38     silence_errors: bool,
  39 }
  40
  41 impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
  42     type Item = (Ty<'tcx>, usize);
  43
  44     fn next(&mut self) -> Option<Self::Item> {
  45         let tcx = self.infcx.tcx;
  46
  47         debug!("autoderef: steps={:?}, cur_ty={:?}", self.state.steps, self.state.cur_ty);
  48         if self.state.at_start {
  49             self.state.at_start = false;
  50             debug!("autoderef stage #0 is {:?}", self.state.cur_ty);
  51             return Some((self.state.cur_ty, 0));
  52         }
  53
  54         // If we have reached the recursion limit, error gracefully.
  55         if !tcx.recursion_limit().value_within_limit(self.state.steps.len()) {
  56             if !self.silence_errors {
  57                 report_autoderef_recursion_limit_error(tcx, self.span, self.state.cur_ty);
  58             }
  59             self.state.reached_recursion_limit = true;
  60             return None;
  61         }
  62
  63         if self.state.cur_ty.is_ty_var() {
  64             return None;
  65         }
  66
  67         // Otherwise, deref if type is derefable:
  68         let (kind, new_ty) =
  69             if let Some(mt) = self.state.cur_ty.builtin_deref(self.include_raw_pointers) {
  70                 (AutoderefKind::Builtin, mt.ty)
  71             } else if let Some(ty) = self.overloaded_deref_ty(self.state.cur_ty) {
  72                 (AutoderefKind::Overloaded, ty)
  73             } else {
  74                 return None;
  75             };
  76
  77         if new_ty.references_error() {
  78             return None;
  79         }
  80
  81         self.state.steps.push((self.state.cur_ty, kind));
  82         debug!(
  83             "autoderef stage #{:?} is {:?} from {:?}",
  84             self.step_count(),
  85             new_ty,
  86             (self.state.cur_ty, kind)
  87         );
  88         self.state.cur_ty = new_ty;
  89
  90         Some((self.state.cur_ty, self.step_count()))
  91     }
  92 }
  93
  94 impl<'a, 'tcx> Autoderef<'a, 'tcx> {
  95     pub fn new(
  96         infcx: &'a InferCtxt<'tcx>,
  97         param_env: ty::ParamEnv<'tcx>,
  98         body_id: hir::HirId,
  99         span: Span,
 100         base_ty: Ty<'tcx>,
 101     ) -> Autoderef<'a, 'tcx> {
 102         Autoderef {
 103             infcx,
 104             span,
 105             body_id,
 106             param_env,
 107             state: AutoderefSnapshot {
 108                 steps: vec![],
 109                 cur_ty: infcx.resolve_vars_if_possible(base_ty),
 110                 obligations: vec![],
 111                 at_start: true,
 112                 reached_recursion_limit: false,
 113             },
 114             include_raw_pointers: false,
 115             silence_errors: false,
 116         }
 117     }
 118
 119     fn overloaded_deref_ty(&mut self, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
 120         debug!("overloaded_deref_ty({:?})", ty);
 121
 122         let tcx = self.infcx.tcx;
 123
 124         // <ty as Deref>
 125         let trait_ref = TraitRef {
 126             def_id: tcx.lang_items().deref_trait()?,
 127             substs: tcx.mk_substs_trait(ty, &[]),
 128         };
 129
 130         let cause = traits::ObligationCause::misc(self.span, self.body_id);
 131
 132         let obligation = traits::Obligation::new(
 133             tcx,
 134             cause.clone(),
 135             self.param_env,
 136             ty::Binder::dummy(trait_ref).without_const(),
 137         );
 138         if !self.infcx.predicate_may_hold(&obligation) {
 139             debug!("overloaded_deref_ty: cannot match obligation");
 140             return None;
 141         }
 142
 143         let mut fulfillcx = <dyn TraitEngine<'tcx>>::new_in_snapshot(tcx);
 144         let normalized_ty = fulfillcx.normalize_projection_type(
 145             &self.infcx,
 146             self.param_env,
 147             ty::ProjectionTy {
 148                 item_def_id: tcx.lang_items().deref_target()?,
 149                 substs: trait_ref.substs,
 150             },
 151             cause,
 152         );
 153         let errors = fulfillcx.select_where_possible(&self.infcx);
 154         if !errors.is_empty() {
 155             // This shouldn't happen, except for evaluate/fulfill mismatches,
 156             // but that's not a reason for an ICE (`predicate_may_hold` is conservative
 157             // by design).
 158             debug!("overloaded_deref_ty: encountered errors {:?} while fulfilling", errors);
 159             return None;
 160         }
 161         let obligations = fulfillcx.pending_obligations();
 162         debug!("overloaded_deref_ty({:?}) = ({:?}, {:?})", ty, normalized_ty, obligations);
 163         self.state.obligations.extend(obligations);
 164
 165         Some(self.infcx.resolve_vars_if_possible(normalized_ty))
 166     }
 167
 168     /// Returns the final type we ended up with, which may be an inference
 169     /// variable (we will resolve it first, if we want).
 170     pub fn final_ty(&self, resolve: bool) -> Ty<'tcx> {
 171         if resolve {
 172             self.infcx.resolve_vars_if_possible(self.state.cur_ty)
 173         } else {
 174             self.state.cur_ty
 175         }
 176     }
 177
 178     pub fn step_count(&self) -> usize {
 179         self.state.steps.len()
 180     }
 181
 182     pub fn into_obligations(self) -> Vec<traits::PredicateObligation<'tcx>> {
 183         self.state.obligations
 184     }
 185
 186     pub fn steps(&self) -> &[(Ty<'tcx>, AutoderefKind)] {
 187         &self.state.steps
 188     }
 189
 190     pub fn span(&self) -> Span {
 191         self.span
 192     }
 193
 194     pub fn reached_recursion_limit(&self) -> bool {
 195         self.state.reached_recursion_limit
 196     }
 197
 198     /// also dereference through raw pointer types
 199     /// e.g., assuming ptr_to_Foo is the type `*const Foo`
 200     /// fcx.autoderef(span, ptr_to_Foo)  => [*const Foo]
 201     /// fcx.autoderef(span, ptr_to_Foo).include_raw_ptrs() => [*const Foo, Foo]
 202     pub fn include_raw_pointers(mut self) -> Self {
 203         self.include_raw_pointers = true;
 204         self
 205     }
 206
 207     pub fn silence_errors(mut self) -> Self {
 208         self.silence_errors = true;
 209         self
 210     }
 211 }
 212
 213 pub fn report_autoderef_recursion_limit_error<'tcx>(tcx: TyCtxt<'tcx>, span: Span, ty: Ty<'tcx>) {
 214     // We've reached the recursion limit, error gracefully.
 215     let suggested_limit = match tcx.recursion_limit() {
 216         Limit(0) => Limit(2),
 217         limit => limit * 2,
 218     };
 219     tcx.sess.emit_err(AutoDerefReachedRecursionLimit {
 220         span,
 221         ty,
 222         suggested_limit,
 223         crate_name: tcx.crate_name(LOCAL_CRATE),
 224     });
 225 }