refactor autoderef to avoid prematurely registering obligations

src/librustc/traits/mod.rs

@@ -31,7 +31,7 @@ pub use self::coherence::overlapping_impls;
 pub use self::coherence::OrphanCheckErr;
 pub use self::fulfill::{FulfillmentContext, GlobalFulfilledPredicates, RegionObligation};
 pub use self::project::{MismatchedProjectionTypes, ProjectionMode};
-pub use self::project::{normalize, Normalized};
+pub use self::project::{normalize, normalize_projection_type, Normalized};
 pub use self::object_safety::ObjectSafetyViolation;
 pub use self::object_safety::MethodViolationCode;
 pub use self::select::{EvaluationCache, SelectionContext, SelectionCache};

src/librustc/ty/adjustment.rs

@@ -235,8 +235,9 @@ impl<'a, 'gcx, 'tcx> ty::TyS<'tcx> {
  None => {
  span_bug!(
  expr_span,
- "the {}th autoderef failed: {}",
+ "the {}th autoderef for {} failed: {}",
  autoderef,
+ expr_id,
  adjusted_ty);
  }
  }

src/librustc_typeck/check/autoderef.rs

@@ -0,0 +1,210 @@
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use astconv::AstConv;
+
+use super::FnCtxt;
+
+use rustc::traits;
+use rustc::ty::{self, Ty, TraitRef};
+use rustc::ty::{ToPredicate, TypeFoldable};
+use rustc::ty::{MethodCall, MethodCallee};
+use rustc::ty::subst::Substs;
+use rustc::ty::{LvaluePreference, NoPreference, PreferMutLvalue};
+use rustc::hir;
+
+use syntax::codemap::Span;
+use syntax::parse::token;
+
+#[derive(Copy, Clone, Debug)]
+enum AutoderefKind {
+ Builtin,
+ Overloaded
+}
+
+pub struct Autoderef<'a, 'gcx: 'tcx, 'tcx: 'a> {
+ fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
+ steps: Vec<(Ty<'tcx>, AutoderefKind)>,
+ cur_ty: Ty<'tcx>,
+ obligations: Vec<traits::PredicateObligation<'tcx>>,
+ at_start: bool,
+ span: Span
+}
+
+impl<'a, 'gcx, 'tcx> Iterator for Autoderef<'a, 'gcx, 'tcx> {
+ type Item = (Ty<'tcx>, usize);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let tcx = self.fcx.tcx;
+
+ debug!("autoderef: steps={:?}, cur_ty={:?}",
+ self.steps, self.cur_ty);
+ if self.at_start {
+ self.at_start = false;
+ debug!("autoderef stage #0 is {:?}", self.cur_ty);
+ return Some((self.cur_ty, 0));
+ }
+
+ if self.steps.len() == tcx.sess.recursion_limit.get() {
+ // We've reached the recursion limit, error gracefully.
+ span_err!(tcx.sess, self.span, E0055,
+ "reached the recursion limit while auto-dereferencing {:?}",
+ self.cur_ty);
+ return None;
+ }
+
+ if self.cur_ty.is_ty_var() {
+ return None;
+ }
+
+ // Otherwise, deref if type is derefable:
+ let (kind, new_ty) = if let Some(mt) = self.cur_ty.builtin_deref(false, NoPreference) {
+ (AutoderefKind::Builtin, mt.ty)
+ } else {
+ match self.overloaded_deref_ty(self.cur_ty) {
+ Some(ty) => (AutoderefKind::Overloaded, ty),
+ _ => return None
+ }
+ };
+
+ if new_ty.references_error() {
+ return None;
+ }
+
+ self.steps.push((self.cur_ty, kind));
+ debug!("autoderef stage #{:?} is {:?} from {:?}", self.steps.len(),
+ new_ty, (self.cur_ty, kind));
+ self.cur_ty = new_ty;
+
+ Some((self.cur_ty, self.steps.len()))
+ }
+}
+
+impl<'a, 'gcx, 'tcx> Autoderef<'a, 'gcx, 'tcx> {
+ fn overloaded_deref_ty(&mut self, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+ debug!("overloaded_deref_ty({:?})", ty);
+
+ let tcx = self.fcx.tcx();
+
+ // <cur_ty as Deref>
+ let trait_ref = TraitRef {
+ def_id: match tcx.lang_items.deref_trait() {
+ Some(f) => f,
+ None => return None
+ },
+ substs: tcx.mk_substs(Substs::new_trait(vec![], vec![], self.cur_ty))
+ };
+
+ let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id);
+
+ let mut selcx = traits::SelectionContext::new(self.fcx);
+ let obligation = traits::Obligation::new(cause.clone(), trait_ref.to_predicate());
+ if !selcx.evaluate_obligation(&obligation) {
+ debug!("overloaded_deref_ty: cannot match obligation");
+ return None;
+ }
+
+ let normalized = traits::normalize_projection_type(
+ &mut selcx,
+ ty::ProjectionTy {
+ trait_ref: trait_ref,
+ item_name: token::intern("Target")
+ },
+ cause,
+ 0
+ );
+
+ debug!("overloaded_deref_ty({:?}) = {:?}", ty, normalized);
+ self.obligations.extend(normalized.obligations);
+
+ Some(self.fcx.resolve_type_vars_if_possible(&normalized.value))
+ }
+
+ pub fn unambiguous_final_ty(&self) -> Ty<'tcx> {
+ self.fcx.structurally_resolved_type(self.span, self.cur_ty)
+ }
+
+ pub fn finalize<'b, I>(self, pref: LvaluePreference, exprs: I)
+ where I: IntoIterator<Item=&'b hir::Expr>
+ {
+ let methods : Vec<_> = self.steps.iter().map(|&(ty, kind)| {
+ if let AutoderefKind::Overloaded = kind {
+ self.fcx.try_overloaded_deref(self.span, None, ty, pref)
+ } else {
+ None
+ }
+ }).collect();
+
+ debug!("finalize({:?}) - {:?},{:?}", pref, methods, self.obligations);
+
+ for expr in exprs {
+ debug!("finalize - finalizing #{} - {:?}", expr.id, expr);
+ for (n, method) in methods.iter().enumerate() {
+ if let &Some(method) = method {
+ let method_call = MethodCall::autoderef(expr.id, n as u32);
+ self.fcx.tables.borrow_mut().method_map.insert(method_call, method);
+ }
+ }
+ }
+
+ for obligation in self.obligations {
+ self.fcx.register_predicate(obligation);
+ }
+ }
+}
+
+impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
+ pub fn autoderef(&'a self,
+ span: Span,
+ base_ty: Ty<'tcx>)
+ -> Autoderef<'a, 'gcx, 'tcx>
+ {
+ Autoderef {
+ fcx: self,
+ steps: vec![],
+ cur_ty: self.resolve_type_vars_if_possible(&base_ty),
+ obligations: vec![],
+ at_start: true,
+ span: span
+ }
+ }
+
+ pub fn try_overloaded_deref(&self,
+ span: Span,
+ base_expr: Option<&hir::Expr>,
+ base_ty: Ty<'tcx>,
+ lvalue_pref: LvaluePreference)
+ -> Option<MethodCallee<'tcx>>
+ {
+ debug!("try_overloaded_deref({:?},{:?},{:?},{:?})",
+ span, base_expr, base_ty, lvalue_pref);
+ // Try DerefMut first, if preferred.
+ let method = match (lvalue_pref, self.tcx.lang_items.deref_mut_trait()) {
+ (PreferMutLvalue, Some(trait_did)) => {
+ self.lookup_method_in_trait(span, base_expr,
+ token::intern("deref_mut"), trait_did,
+ base_ty, None)
+ }
+ _ => None
+ };
+
+ // Otherwise, fall back to Deref.
+ let method = match (method, self.tcx.lang_items.deref_trait()) {
+ (None, Some(trait_did)) => {
+ self.lookup_method_in_trait(span, base_expr,
+ token::intern("deref"), trait_did,
+ base_ty, None)
+ }
+ (method, _) => method
+ };
+
+ method
+ }
+}

src/librustc_typeck/check/callee.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use super::{DeferredCallResolution, Expectation, FnCtxt,
- TupleArgumentsFlag, UnresolvedTypeAction};
+ TupleArgumentsFlag};
 
 use CrateCtxt;
 use middle::cstore::LOCAL_CRATE;
@@ -72,15 +72,13 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
  {
  self.check_expr(callee_expr);
  let original_callee_ty = self.expr_ty(callee_expr);
- let (callee_ty, _, result) =
- self.autoderef(callee_expr.span,
- original_callee_ty,
- || Some(callee_expr),
- UnresolvedTypeAction::Error,
- LvaluePreference::NoPreference,
- |adj_ty, idx| {
- self.try_overloaded_call_step(call_expr, callee_expr, adj_ty, idx)
- });
+
+ let mut autoderef = self.autoderef(callee_expr.span, original_callee_ty);
+ let result = autoderef.by_ref().flat_map(|(adj_ty, idx)| {
+ self.try_overloaded_call_step(call_expr, callee_expr, adj_ty, idx)
+ }).next();
+ let callee_ty = autoderef.unambiguous_final_ty();
+ autoderef.finalize(LvaluePreference::NoPreference, Some(callee_expr));
 
  match result {
  None => {

src/librustc_typeck/check/coercion.rs

@@ -60,7 +60,7 @@
 //! sort of a minor point so I've opted to leave it for later---after all
 //! we may want to adjust precisely when coercions occur.
 
-use check::{FnCtxt, UnresolvedTypeAction};
+use check::{FnCtxt};
 
 use rustc::hir;
 use rustc::infer::{Coercion, InferOk, TypeOrigin, TypeTrace};
@@ -220,7 +220,8 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
  -> CoerceResult<'tcx>
  // FIXME(eddyb) use copyable iterators when that becomes ergonomic.
  where E: Fn() -> I,
- I: IntoIterator<Item=&'a hir::Expr> {
+ I: IntoIterator<Item=&'a hir::Expr>
+ {
 
  debug!("coerce_borrowed_pointer(a={:?}, b={:?})", a, b);
 
@@ -240,18 +241,16 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
 
  let span = self.origin.span();
 
- let lvalue_pref = LvaluePreference::from_mutbl(mt_b.mutbl);
  let mut first_error = None;
  let mut r_borrow_var = None;
- let (_, autoderefs, success) = self.autoderef(span, a, exprs,
- UnresolvedTypeAction::Ignore,
- lvalue_pref,
- |referent_ty, autoderef|
- {
- if autoderef == 0 {
+ let mut autoderef = self.autoderef(span, a);
+ let mut success = None;
+
+ for (referent_ty, autoderefs) in autoderef.by_ref() {
+ if autoderefs == 0 {
  // Don't let this pass, otherwise it would cause
  // &T to autoref to &&T.
- return None;
+ continue
  }
 
  // At this point, we have deref'd `a` to `referent_ty`. So
@@ -326,7 +325,7 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
  // and let regionck figure it out.
  let r = if !self.use_lub {
  r_b // [2] above
- } else if autoderef == 1 {
+ } else if autoderefs == 1 {
  r_a // [3] above
  } else {
  if r_borrow_var.is_none() { // create var lazilly, at most once
@@ -341,30 +340,31 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
  mutbl: mt_b.mutbl // [1] above
  });
  match self.unify(derefd_ty_a, b) {
- Ok(ty) => Some(ty),
+ Ok(ty) => { success = Some((ty, autoderefs)); break },
  Err(err) => {
  if first_error.is_none() {
  first_error = Some(err);
  }
- None
  }
  }
- });
+ }
 
  // Extract type or return an error. We return the first error
  // we got, which should be from relating the "base" type
  // (e.g., in example above, the failure from relating `Vec<T>`
  // to the target type), since that should be the least
  // confusing.
- let ty = match success {
- Some(ty) => ty,
+ let (ty, autoderefs) = match success {
+ Some(d) => d,
  None => {
  let err = first_error.expect("coerce_borrowed_pointer had no error");
  debug!("coerce_borrowed_pointer: failed with err = {:?}", err);
  return Err(err);
  }
  };
 
+ autoderef.finalize(LvaluePreference::from_mutbl(mt_b.mutbl), exprs());
+
  // Now apply the autoref. We have to extract the region out of
  // the final ref type we got.
  if ty == a && mt_a.mutbl == hir::MutImmutable && autoderefs == 1 {