1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
13 use super::{FnCtxt, LvalueOp};
14 use super::method::MethodCallee;
16 use rustc::infer::InferOk;
18 use rustc::ty::{self, Ty, TraitRef};
19 use rustc::ty::{ToPredicate, TypeFoldable};
20 use rustc::ty::{LvaluePreference, NoPreference};
21 use rustc::ty::adjustment::{Adjustment, Adjust, OverloadedDeref};
24 use syntax::symbol::Symbol;
28 #[derive(Copy, Clone, Debug)]
34 pub struct Autoderef<'a, 'gcx: 'tcx, 'tcx: 'a> {
35 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
36 steps: Vec<(Ty<'tcx>, AutoderefKind)>,
38 obligations: Vec<traits::PredicateObligation<'tcx>>,
40 include_raw_pointers: bool,
44 impl<'a, 'gcx, 'tcx> Iterator for Autoderef<'a, 'gcx, 'tcx> {
45 type Item = (Ty<'tcx>, usize);
47 fn next(&mut self) -> Option<Self::Item> {
48 let tcx = self.fcx.tcx;
50 debug!("autoderef: steps={:?}, cur_ty={:?}",
54 self.at_start = false;
55 debug!("autoderef stage #0 is {:?}", self.cur_ty);
56 return Some((self.cur_ty, 0));
59 if self.steps.len() == tcx.sess.recursion_limit.get() {
60 // We've reached the recursion limit, error gracefully.
61 let suggested_limit = tcx.sess.recursion_limit.get() * 2;
62 struct_span_err!(tcx.sess,
65 "reached the recursion limit while auto-dereferencing {:?}",
67 .span_label(self.span, "deref recursion limit reached")
69 "consider adding a `#[recursion_limit=\"{}\"]` attribute to your crate",
75 if self.cur_ty.is_ty_var() {
79 // Otherwise, deref if type is derefable:
81 if let Some(mt) = self.cur_ty.builtin_deref(self.include_raw_pointers, NoPreference) {
82 (AutoderefKind::Builtin, mt.ty)
84 let ty = self.overloaded_deref_ty(self.cur_ty)?;
85 (AutoderefKind::Overloaded, ty)
88 if new_ty.references_error() {
92 self.steps.push((self.cur_ty, kind));
93 debug!("autoderef stage #{:?} is {:?} from {:?}",
99 Some((self.cur_ty, self.steps.len()))
103 impl<'a, 'gcx, 'tcx> Autoderef<'a, 'gcx, 'tcx> {
104 fn overloaded_deref_ty(&mut self, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
105 debug!("overloaded_deref_ty({:?})", ty);
107 let tcx = self.fcx.tcx();
110 let trait_ref = TraitRef {
111 def_id: tcx.lang_items().deref_trait()?,
112 substs: tcx.mk_substs_trait(self.cur_ty, &[]),
115 let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id);
117 let mut selcx = traits::SelectionContext::new(self.fcx);
118 let obligation = traits::Obligation::new(cause.clone(),
120 trait_ref.to_predicate());
121 if !selcx.evaluate_obligation(&obligation) {
122 debug!("overloaded_deref_ty: cannot match obligation");
126 let normalized = traits::normalize_projection_type(&mut selcx,
128 ty::ProjectionTy::from_ref_and_name(
131 Symbol::intern("Target"),
136 debug!("overloaded_deref_ty({:?}) = {:?}", ty, normalized);
137 self.obligations.extend(normalized.obligations);
139 Some(self.fcx.resolve_type_vars_if_possible(&normalized.value))
142 /// Returns the final type, generating an error if it is an
143 /// unresolved inference variable.
144 pub fn unambiguous_final_ty(&self) -> Ty<'tcx> {
145 self.fcx.structurally_resolved_type(self.span, self.cur_ty)
148 /// Returns the final type we ended up with, which may well be an
149 /// inference variable (we will resolve it first, if possible).
150 pub fn maybe_ambiguous_final_ty(&self) -> Ty<'tcx> {
151 self.fcx.resolve_type_vars_if_possible(&self.cur_ty)
154 pub fn step_count(&self) -> usize {
158 /// Returns the adjustment steps.
159 pub fn adjust_steps(&self, pref: LvaluePreference)
160 -> Vec<Adjustment<'tcx>> {
161 self.fcx.register_infer_ok_obligations(self.adjust_steps_as_infer_ok(pref))
164 pub fn adjust_steps_as_infer_ok(&self, pref: LvaluePreference)
165 -> InferOk<'tcx, Vec<Adjustment<'tcx>>> {
166 let mut obligations = vec![];
167 let targets = self.steps.iter().skip(1).map(|&(ty, _)| ty)
168 .chain(iter::once(self.cur_ty));
169 let steps: Vec<_> = self.steps.iter().map(|&(source, kind)| {
170 if let AutoderefKind::Overloaded = kind {
171 self.fcx.try_overloaded_deref(self.span, source, pref)
172 .and_then(|InferOk { value: method, obligations: o }| {
173 obligations.extend(o);
174 if let ty::TyRef(region, mt) = method.sig.output().sty {
175 Some(OverloadedDeref {
186 }).zip(targets).map(|(autoderef, target)| {
188 kind: Adjust::Deref(autoderef),
199 /// also dereference through raw pointer types
200 /// e.g. assuming ptr_to_Foo is the type `*const Foo`
201 /// fcx.autoderef(span, ptr_to_Foo) => [*const Foo]
202 /// fcx.autoderef(span, ptr_to_Foo).include_raw_ptrs() => [*const Foo, Foo]
203 pub fn include_raw_pointers(mut self) -> Self {
204 self.include_raw_pointers = true;
208 pub fn finalize(self) {
210 fcx.register_predicates(self.into_obligations());
213 pub fn into_obligations(self) -> Vec<traits::PredicateObligation<'tcx>> {
218 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
219 pub fn autoderef(&'a self, span: Span, base_ty: Ty<'tcx>) -> Autoderef<'a, 'gcx, 'tcx> {
223 cur_ty: self.resolve_type_vars_if_possible(&base_ty),
226 include_raw_pointers: false,
231 pub fn try_overloaded_deref(&self,
234 pref: LvaluePreference)
235 -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
236 self.try_overloaded_lvalue_op(span, base_ty, &[], pref, LvalueOp::Deref)