1 use crate::errors::AutoDerefReachedRecursionLimit;
2 use crate::infer::InferCtxtExt as _;
3 use crate::traits::query::evaluate_obligation::InferCtxtExt;
4 use crate::traits::{self, TraitEngine, TraitEngineExt};
6 use rustc_infer::infer::InferCtxt;
7 use rustc_middle::ty::TypeVisitable;
8 use rustc_middle::ty::{self, Ty, TyCtxt};
9 use rustc_session::Limit;
10 use rustc_span::def_id::LOCAL_CRATE;
13 #[derive(Copy, Clone, Debug)]
14 pub enum AutoderefKind {
19 struct AutoderefSnapshot<'tcx> {
21 reached_recursion_limit: bool,
22 steps: Vec<(Ty<'tcx>, AutoderefKind)>,
24 obligations: Vec<traits::PredicateObligation<'tcx>>,
27 pub struct Autoderef<'a, 'tcx> {
29 infcx: &'a InferCtxt<'tcx>,
32 param_env: ty::ParamEnv<'tcx>,
35 state: AutoderefSnapshot<'tcx>,
38 include_raw_pointers: bool,
42 impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
43 type Item = (Ty<'tcx>, usize);
45 fn next(&mut self) -> Option<Self::Item> {
46 let tcx = self.infcx.tcx;
48 debug!("autoderef: steps={:?}, cur_ty={:?}", self.state.steps, self.state.cur_ty);
49 if self.state.at_start {
50 self.state.at_start = false;
51 debug!("autoderef stage #0 is {:?}", self.state.cur_ty);
52 return Some((self.state.cur_ty, 0));
55 // If we have reached the recursion limit, error gracefully.
56 if !tcx.recursion_limit().value_within_limit(self.state.steps.len()) {
57 if !self.silence_errors {
58 report_autoderef_recursion_limit_error(tcx, self.span, self.state.cur_ty);
60 self.state.reached_recursion_limit = true;
64 if self.state.cur_ty.is_ty_var() {
68 // Otherwise, deref if type is derefable:
70 if let Some(mt) = self.state.cur_ty.builtin_deref(self.include_raw_pointers) {
71 (AutoderefKind::Builtin, mt.ty)
72 } else if let Some(ty) = self.overloaded_deref_ty(self.state.cur_ty) {
73 (AutoderefKind::Overloaded, ty)
78 if new_ty.references_error() {
82 self.state.steps.push((self.state.cur_ty, kind));
84 "autoderef stage #{:?} is {:?} from {:?}",
87 (self.state.cur_ty, kind)
89 self.state.cur_ty = new_ty;
91 Some((self.state.cur_ty, self.step_count()))
95 impl<'a, 'tcx> Autoderef<'a, 'tcx> {
97 infcx: &'a InferCtxt<'tcx>,
98 param_env: ty::ParamEnv<'tcx>,
102 ) -> Autoderef<'a, 'tcx> {
108 state: AutoderefSnapshot {
110 cur_ty: infcx.resolve_vars_if_possible(base_ty),
113 reached_recursion_limit: false,
115 include_raw_pointers: false,
116 silence_errors: false,
120 fn overloaded_deref_ty(&mut self, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
121 debug!("overloaded_deref_ty({:?})", ty);
123 let tcx = self.infcx.tcx;
126 let trait_ref = tcx.mk_trait_ref(tcx.lang_items().deref_trait()?, [ty]);
128 let cause = traits::ObligationCause::misc(self.span, self.body_id);
130 let obligation = traits::Obligation::new(
134 ty::Binder::dummy(trait_ref),
136 if !self.infcx.predicate_may_hold(&obligation) {
137 debug!("overloaded_deref_ty: cannot match obligation");
141 let normalized_ty = self.infcx.partially_normalize_associated_types_in(
144 tcx.mk_projection(tcx.lang_items().deref_target()?, trait_ref.substs),
146 let mut fulfillcx = <dyn TraitEngine<'tcx>>::new_in_snapshot(tcx);
148 normalized_ty.into_value_registering_obligations(self.infcx, &mut *fulfillcx);
149 let errors = fulfillcx.select_where_possible(&self.infcx);
150 if !errors.is_empty() {
151 // This shouldn't happen, except for evaluate/fulfill mismatches,
152 // but that's not a reason for an ICE (`predicate_may_hold` is conservative
154 debug!("overloaded_deref_ty: encountered errors {:?} while fulfilling", errors);
157 let obligations = fulfillcx.pending_obligations();
158 debug!("overloaded_deref_ty({:?}) = ({:?}, {:?})", ty, normalized_ty, obligations);
159 self.state.obligations.extend(obligations);
161 Some(self.infcx.resolve_vars_if_possible(normalized_ty))
164 /// Returns the final type we ended up with, which may be an inference
165 /// variable (we will resolve it first, if we want).
166 pub fn final_ty(&self, resolve: bool) -> Ty<'tcx> {
168 self.infcx.resolve_vars_if_possible(self.state.cur_ty)
174 pub fn step_count(&self) -> usize {
175 self.state.steps.len()
178 pub fn into_obligations(self) -> Vec<traits::PredicateObligation<'tcx>> {
179 self.state.obligations
182 pub fn steps(&self) -> &[(Ty<'tcx>, AutoderefKind)] {
186 pub fn span(&self) -> Span {
190 pub fn reached_recursion_limit(&self) -> bool {
191 self.state.reached_recursion_limit
194 /// also dereference through raw pointer types
195 /// e.g., assuming ptr_to_Foo is the type `*const Foo`
196 /// fcx.autoderef(span, ptr_to_Foo) => [*const Foo]
197 /// fcx.autoderef(span, ptr_to_Foo).include_raw_ptrs() => [*const Foo, Foo]
198 pub fn include_raw_pointers(mut self) -> Self {
199 self.include_raw_pointers = true;
203 pub fn silence_errors(mut self) -> Self {
204 self.silence_errors = true;
209 pub fn report_autoderef_recursion_limit_error<'tcx>(tcx: TyCtxt<'tcx>, span: Span, ty: Ty<'tcx>) {
210 // We've reached the recursion limit, error gracefully.
211 let suggested_limit = match tcx.recursion_limit() {
212 Limit(0) => Limit(2),
215 tcx.sess.emit_err(AutoDerefReachedRecursionLimit {
219 crate_name: tcx.crate_name(LOCAL_CRATE),