remove the typeck::autoderef::Autoderef fcx field

This allows using it in an fcx-independent context

Author: arielb1

src/librustc_typeck/check/autoderef.rs

@@ -8,20 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use astconv::AstConv;
-
 use super::{FnCtxt, PlaceOp, Needs};
 use super::method::MethodCallee;
 
-use rustc::infer::InferOk;
+use rustc::infer::{InferCtxt, InferOk};
 use rustc::session::DiagnosticMessageId;
 use rustc::traits::{self, TraitEngine};
 use rustc::ty::{self, Ty, TraitRef};
 use rustc::ty::{ToPredicate, TypeFoldable};
 use rustc::ty::adjustment::{Adjustment, Adjust, OverloadedDeref};
 
 use syntax_pos::Span;
-use syntax::ast::Ident;
+use syntax::ast::{NodeId, Ident};
 
 use std::iter;
 
@@ -32,7 +30,9 @@ enum AutoderefKind {
 }
 
 pub struct Autoderef<'a, 'gcx: 'tcx, 'tcx: 'a> {
-    fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
+    infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
+    body_id: NodeId,
+    param_env: ty::ParamEnv<'tcx>,
     steps: Vec<(Ty<'tcx>, AutoderefKind)>,
     cur_ty: Ty<'tcx>,
     obligations: Vec<traits::PredicateObligation<'tcx>>,
@@ -45,7 +45,7 @@ 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;
+        let tcx = self.infcx.tcx;
 
         debug!("autoderef: steps={:?}, cur_ty={:?}",
                self.steps,
@@ -110,35 +110,35 @@ 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();
+        let tcx = self.infcx.tcx;
 
         // <cur_ty as Deref>
         let trait_ref = TraitRef {
             def_id: tcx.lang_items().deref_trait()?,
             substs: tcx.mk_substs_trait(self.cur_ty, &[]),
         };
 
-        let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id);
+        let cause = traits::ObligationCause::misc(self.span, self.body_id);
 
         let obligation = traits::Obligation::new(cause.clone(),
-                                                 self.fcx.param_env,
+                                                 self.param_env,
                                                  trait_ref.to_predicate());
-        if !self.fcx.predicate_may_hold(&obligation) {
+        if !self.infcx.predicate_may_hold(&obligation) {
             debug!("overloaded_deref_ty: cannot match obligation");
             return None;
         }
 
         let mut fulfillcx = traits::FulfillmentContext::new_in_snapshot();
         let normalized_ty = fulfillcx.normalize_projection_type(
-            &self.fcx,
-            self.fcx.param_env,
+            &self.infcx,
+            self.param_env,
             ty::ProjectionTy::from_ref_and_name(
                 tcx,
                 trait_ref,
                 Ident::from_str("Target"),
             ),
             cause);
-        if let Err(e) = fulfillcx.select_where_possible(&self.fcx) {
+        if let Err(e) = fulfillcx.select_where_possible(&self.infcx) {
             // This shouldn't happen, except for evaluate/fulfill mismatches,
             // but that's not a reason for an ICE (`predicate_may_hold` is conservative
             // by design).
@@ -151,39 +151,39 @@ impl<'a, 'gcx, 'tcx> Autoderef<'a, 'gcx, 'tcx> {
                ty, normalized_ty, obligations);
         self.obligations.extend(obligations);
 
-        Some(self.fcx.resolve_type_vars_if_possible(&normalized_ty))
+        Some(self.infcx.resolve_type_vars_if_possible(&normalized_ty))
     }
 
     /// Returns the final type, generating an error if it is an
     /// unresolved inference variable.
-    pub fn unambiguous_final_ty(&self) -> Ty<'tcx> {
-        self.fcx.structurally_resolved_type(self.span, self.cur_ty)
+    pub fn unambiguous_final_ty(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> {
+        fcx.structurally_resolved_type(self.span, self.cur_ty)
     }
 
     /// Returns the final type we ended up with, which may well be an
     /// inference variable (we will resolve it first, if possible).
     pub fn maybe_ambiguous_final_ty(&self) -> Ty<'tcx> {
-        self.fcx.resolve_type_vars_if_possible(&self.cur_ty)
+        self.infcx.resolve_type_vars_if_possible(&self.cur_ty)
     }
 
     pub fn step_count(&self) -> usize {
         self.steps.len()
     }
 
     /// Returns the adjustment steps.
-    pub fn adjust_steps(&self, needs: Needs)
+    pub fn adjust_steps(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, needs: Needs)
                         -> Vec<Adjustment<'tcx>> {
-        self.fcx.register_infer_ok_obligations(self.adjust_steps_as_infer_ok(needs))
+        fcx.register_infer_ok_obligations(self.adjust_steps_as_infer_ok(fcx, needs))
     }
 
-    pub fn adjust_steps_as_infer_ok(&self, needs: Needs)
+    pub fn adjust_steps_as_infer_ok(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, needs: Needs)
                                     -> InferOk<'tcx, Vec<Adjustment<'tcx>>> {
         let mut obligations = vec![];
         let targets = self.steps.iter().skip(1).map(|&(ty, _)| ty)
             .chain(iter::once(self.cur_ty));
         let steps: Vec<_> = self.steps.iter().map(|&(source, kind)| {
             if let AutoderefKind::Overloaded = kind {
-                self.fcx.try_overloaded_deref(self.span, source, needs)
+                fcx.try_overloaded_deref(self.span, source, needs)
                     .and_then(|InferOk { value: method, obligations: o }| {
                         obligations.extend(o);
                         if let ty::Ref(region, _, mutbl) = method.sig.output().sty {
@@ -220,8 +220,7 @@ impl<'a, 'gcx, 'tcx> Autoderef<'a, 'gcx, 'tcx> {
         self
     }
 
-    pub fn finalize(self) {
-        let fcx = self.fcx;
+    pub fn finalize(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) {
         fcx.register_predicates(self.into_obligations());
     }
 
@@ -233,7 +232,9 @@ impl<'a, 'gcx, 'tcx> Autoderef<'a, 'gcx, 'tcx> {
 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,
+            infcx: &self.infcx,
+            body_id: self.body_id,
+            param_env: self.param_env,
             steps: vec![],
             cur_ty: self.resolve_type_vars_if_possible(&base_ty),
             obligations: vec![],

src/librustc_typeck/check/callee.rs

@@ -57,7 +57,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         while result.is_none() && autoderef.next().is_some() {
             result = self.try_overloaded_call_step(call_expr, callee_expr, &autoderef);
         }
-        autoderef.finalize();
+        autoderef.finalize(self);
 
         let output = match result {
             None => {
@@ -89,15 +89,15 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                 callee_expr: &'gcx hir::Expr,
                                 autoderef: &Autoderef<'a, 'gcx, 'tcx>)
                                 -> Option<CallStep<'tcx>> {
-        let adjusted_ty = autoderef.unambiguous_final_ty();
+        let adjusted_ty = autoderef.unambiguous_final_ty(self);
         debug!("try_overloaded_call_step(call_expr={:?}, adjusted_ty={:?})",
                call_expr,
                adjusted_ty);
 
         // If the callee is a bare function or a closure, then we're all set.
         match adjusted_ty.sty {
             ty::FnDef(..) | ty::FnPtr(_) => {
-                let adjustments = autoderef.adjust_steps(Needs::None);
+                let adjustments = autoderef.adjust_steps(self, Needs::None);
                 self.apply_adjustments(callee_expr, adjustments);
                 return Some(CallStep::Builtin(adjusted_ty));
             }
@@ -114,7 +114,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                                                    infer::FnCall,
                                                                    &closure_ty)
                         .0;
-                    let adjustments = autoderef.adjust_steps(Needs::None);
+                    let adjustments = autoderef.adjust_steps(self, Needs::None);
                     self.record_deferred_call_resolution(def_id, DeferredCallResolution {
                         call_expr,
                         callee_expr,
@@ -144,7 +144,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         }
 
         self.try_overloaded_call_traits(call_expr, adjusted_ty).map(|(autoref, method)| {
-            let mut adjustments = autoderef.adjust_steps(Needs::None);
+            let mut adjustments = autoderef.adjust_steps(self, Needs::None);
             adjustments.extend(autoref);
             self.apply_adjustments(callee_expr, adjustments);
             CallStep::Overloaded(method)

src/librustc_typeck/check/coercion.rs

@@ -422,7 +422,7 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
 
         let needs = Needs::maybe_mut_place(mt_b.mutbl);
         let InferOk { value: mut adjustments, obligations: o }
-            = autoderef.adjust_steps_as_infer_ok(needs);
+            = autoderef.adjust_steps_as_infer_ok(self, needs);
         obligations.extend(o);
         obligations.extend(autoderef.into_obligations());
 

src/librustc_typeck/check/method/confirm.rs

@@ -161,9 +161,9 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> {
         let (_, n) = autoderef.nth(pick.autoderefs).unwrap();
         assert_eq!(n, pick.autoderefs);
 
-        let mut adjustments = autoderef.adjust_steps(Needs::None);
+        let mut adjustments = autoderef.adjust_steps(self, Needs::None);
 
-        let mut target = autoderef.unambiguous_final_ty();
+        let mut target = autoderef.unambiguous_final_ty(self);
 
         if let Some(mutbl) = pick.autoref {
             let region = self.next_region_var(infer::Autoref(self.span));
@@ -202,7 +202,7 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> {
             assert!(pick.unsize.is_none());
         }
 
-        autoderef.finalize();
+        autoderef.finalize(self);
 
         // Write out the final adjustments.
         self.apply_adjustments(self.self_expr, adjustments);

src/librustc_typeck/check/method/probe.rs

@@ -49,7 +49,7 @@ struct ProbeContext<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
     mode: Mode,
     method_name: Option<ast::Ident>,
     return_type: Option<Ty<'tcx>>,
-    steps: Rc<Vec<CandidateStep<'tcx>>>,
+    steps: Rc<Vec<CandidateStep<'gcx, 'tcx>>>,
     inherent_candidates: Vec<Candidate<'tcx>>,
     extension_candidates: Vec<Candidate<'tcx>>,
     impl_dups: FxHashSet<DefId>,
@@ -80,8 +80,8 @@ impl<'a, 'gcx, 'tcx> Deref for ProbeContext<'a, 'gcx, 'tcx> {
 }
 
 #[derive(Debug)]
-struct CandidateStep<'tcx> {
-    self_ty: Ty<'tcx>,
+struct CandidateStep<'gcx: 'tcx, 'tcx> {
+    self_ty: Canonical<'gcx, QueryResult<'gcx, Ty<'gcx>>>,
     autoderefs: usize,
     // true if the type results from a dereference of a raw pointer.
     // when assembling candidates, we include these steps, but not when
@@ -247,31 +247,34 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                       -> Result<R, MethodError<'tcx>>
         where OP: FnOnce(ProbeContext<'a, 'gcx, 'tcx>) -> Result<R, MethodError<'tcx>>
     {
-        // FIXME(#18741) -- right now, creating the steps involves evaluating the
-        // `*` operator, which registers obligations that then escape into
-        // the global fulfillment context and thus has global
-        // side-effects. This is a bit of a pain to refactor. So just let
-        // it ride, although it's really not great, and in fact could I
-        // think cause spurious errors. Really though this part should
-        // take place in the `self.probe` below.
+        let mut orig_values = SmallVec::new();
+        let self_ty = self.infcx.canonicalize_data(&self_ty, &mut orig_values);
         let steps = if mode == Mode::MethodCall {
-            match self.create_steps(span, scope_expr_id, self_ty, is_suggestion) {
-                Some(steps) => steps,
-                None => {
-                    return Err(MethodError::NoMatch(NoMatchData::new(Vec::new(),
-                                                                     Vec::new(),
-                                                                     Vec::new(),
-                                                                     None,
-                                                                     mode)))
+            tcx.infer_ctxt().enter(|ref infcx| {
+                match create_steps(infcx, span, scope_expr_id, self_ty, is_suggestion) {
+                    Some(steps) => Ok(steps),
+                    None => {
+                        return Err(MethodError::NoMatch(NoMatchData::new(Vec::new(),
+                                                                         Vec::new(),
+                                                                         Vec::new(),
+                                                                         None,
+                                                                         mode)))
+                    }
                 }
-            }
+            })?;
         } else {
             vec![CandidateStep {
-                     self_ty,
-                     autoderefs: 0,
-                     from_unsafe_deref: false,
-                     unsize: false,
-                 }]
+                self_ty,
+                autoderefs: 0,
+                from_unsafe_deref: false,
+                unsize: false,
+            }];
+        }
+
+        let steps =
+
+        } else {
+
         };
 
         debug!("ProbeContext: steps for self_ty={:?} are {:?}",
@@ -295,19 +298,20 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
             op(probe_cx)
         })
     }
+}
 
-    fn create_steps(&self,
-                    span: Span,
-                    scope_expr_id: ast::NodeId,
-                    self_ty: Ty<'tcx>,
-                    is_suggestion: IsSuggestion)
-                    -> Option<Vec<CandidateStep<'tcx>>> {
-        // FIXME: we don't need to create the entire steps in one pass
-
-        let mut autoderef = self.autoderef(span, self_ty).include_raw_pointers();
-        let mut reached_raw_pointer = false;
-        let mut steps: Vec<_> = autoderef.by_ref()
-            .map(|(ty, d)| {
+fn create_steps(&self,
+                span: Span,
+                scope_expr_id: ast::NodeId,
+                self_ty: Ty<'tcx>,
+                is_suggestion: IsSuggestion)
+                -> Option<Vec<CandidateStep<'tcx>>> {
+    // FIXME: we don't need to create the entire steps in one pass
+
+    let mut autoderef = self.autoderef(span, self_ty).include_raw_pointers();
+    let mut reached_raw_pointer = false;
+    let mut steps: Vec<_> = autoderef.by_ref()
+        .map(|(ty, d)| {
                 let step = CandidateStep {
                     self_ty: ty,
                     autoderefs: d,
@@ -376,7 +380,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
 
         Some(steps)
     }
-}
+
 
 impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
     fn new(fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,