introduce QueryTypeOp trait and use it for eq

Author: nikomatsakis

src/librustc_mir/borrow_check/nll/type_check/type_op/eq.rs

@@ -8,11 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use rustc::infer::{InferCtxt, InferResult};
-use rustc::traits::ObligationCause;
-use rustc::ty::{ParamEnv, Ty, TyCtxt};
+use rustc::infer::canonical::{CanonicalizedQueryResult, Canonical};
+use rustc::traits::query::NoSolution;
+use rustc::traits::{FulfillmentContext, ObligationCause};
+use rustc::ty::{self, ParamEnv, Ty, TyCtxt};
+use syntax::codemap::DUMMY_SP;
 
-#[derive(Debug)]
+#[derive(Copy, Clone, Debug)]
 crate struct Eq<'tcx> {
     param_env: ParamEnv<'tcx>,
     a: Ty<'tcx>,
@@ -25,20 +27,55 @@ impl<'tcx> Eq<'tcx> {
     }
 }
 
-impl<'gcx, 'tcx> super::TypeOp<'gcx, 'tcx> for Eq<'tcx> {
-    type Output = ();
+impl<'gcx: 'tcx, 'tcx> super::QueryTypeOp<'gcx, 'tcx> for Eq<'tcx> {
+    type QueryResult = ();
 
-    fn trivial_noop(self, _tcx: TyCtxt<'_, 'gcx, 'tcx>) -> Result<Self::Output, Self> {
+    fn trivial_noop(self, _tcx: TyCtxt<'_, 'gcx, 'tcx>) -> Result<Self::QueryResult, Self> {
         if self.a == self.b {
             Ok(())
         } else {
             Err(self)
         }
     }
 
-    fn perform(self, infcx: &InferCtxt<'_, 'gcx, 'tcx>) -> InferResult<'tcx, Self::Output> {
-        infcx
-            .at(&ObligationCause::dummy(), self.param_env)
-            .eq(self.a, self.b)
+    fn param_env(&self) -> ty::ParamEnv<'tcx> {
+        self.param_env
+    }
+
+    fn perform_query(
+        tcx: TyCtxt<'_, 'gcx, 'tcx>,
+        canonicalized: Canonical<'gcx, Eq<'gcx>>,
+    ) -> CanonicalizedQueryResult<'gcx, ()> {
+        let tcx = tcx.global_tcx();
+        tcx.infer_ctxt()
+            .enter(|ref infcx| {
+                let (Eq { param_env, a, b }, canonical_inference_vars) =
+                    infcx.instantiate_canonical_with_fresh_inference_vars(DUMMY_SP, &canonicalized);
+                let fulfill_cx = &mut FulfillmentContext::new();
+                let obligations = match infcx.at(&ObligationCause::dummy(), param_env).eq(a, b) {
+                    Ok(v) => v.into_obligations(),
+                    Err(_) => return Err(NoSolution),
+                };
+                fulfill_cx.register_predicate_obligations(infcx, obligations);
+                infcx.make_canonicalized_query_result(canonical_inference_vars, (), fulfill_cx)
+            })
+            .unwrap()
+    }
+}
+
+BraceStructTypeFoldableImpl! {
+    impl<'tcx> TypeFoldable<'tcx> for Eq<'tcx> {
+        param_env,
+        a,
+        b,
+    }
+}
+
+BraceStructLiftImpl! {
+    impl<'a, 'tcx> Lift<'tcx> for Eq<'a> {
+        type Lifted = Eq<'tcx>;
+        param_env,
+        a,
+        b,
     }
 }

src/librustc_mir/borrow_check/nll/type_check/type_op/mod.rs

@@ -9,20 +9,21 @@
 // except according to those terms.
 
 use rustc::infer::canonical::query_result;
-use rustc::infer::canonical::QueryRegionConstraint;
+use rustc::infer::canonical::{Canonicalized, CanonicalizedQueryResult, QueryRegionConstraint};
 use rustc::infer::{InferCtxt, InferOk, InferResult};
 use rustc::traits::{ObligationCause, TraitEngine};
 use rustc::ty::error::TypeError;
-use rustc::ty::TyCtxt;
+use rustc::ty::fold::TypeFoldable;
+use rustc::ty::{Lift, ParamEnv, TyCtxt};
 use std::fmt;
 use std::rc::Rc;
 use syntax::codemap::DUMMY_SP;
 
 crate mod custom;
 crate mod eq;
 crate mod normalize;
-crate mod predicates;
 crate mod outlives;
+crate mod predicates;
 crate mod subtype;
 
 crate trait TypeOp<'gcx, 'tcx>: Sized + fmt::Debug {
@@ -96,3 +97,58 @@ crate trait TypeOp<'gcx, 'tcx>: Sized + fmt::Debug {
         }
     }
 }
+
+type Lifted<'gcx, T> = <T as Lift<'gcx>>::Lifted;
+
+crate trait QueryTypeOp<'gcx: 'tcx, 'tcx>: TypeFoldable<'tcx> + Lift<'gcx> {
+    type QueryResult: TypeFoldable<'tcx> + Lift<'gcx>;
+
+    /// Micro-optimization: returns `Ok(x)` if we can trivially
+    /// produce the output, else returns `Err(self)` back.
+    fn trivial_noop(
+        self,
+        tcx: TyCtxt<'_, 'gcx, 'tcx>,
+    ) -> Result<Lifted<'gcx, Self::QueryResult>, Self>;
+
+    fn param_env(&self) -> ParamEnv<'tcx>;
+
+    fn perform_query(
+        tcx: TyCtxt<'_, 'gcx, 'tcx>,
+        canonicalized: Canonicalized<'gcx, Self>,
+    ) -> CanonicalizedQueryResult<'gcx, Self::QueryResult>;
+}
+
+impl<'gcx: 'tcx, 'tcx, Q> TypeOp<'gcx, 'tcx> for Q
+where
+    Q: QueryTypeOp<'gcx, 'tcx>,
+    Lifted<'gcx, Q::QueryResult>: TypeFoldable<'tcx>,
+{
+    type Output = Lifted<'gcx, Q::QueryResult>;
+
+    fn trivial_noop(self, tcx: TyCtxt<'_, 'gcx, 'tcx>) -> Result<Self::Output, Self> {
+        QueryTypeOp::trivial_noop(self, tcx)
+    }
+
+    fn perform(self, infcx: &InferCtxt<'_, 'gcx, 'tcx>) -> InferResult<'tcx, Self::Output> {
+        let param_env = self.param_env();
+
+        let (canonical_self, canonical_var_values) = infcx.canonicalize_query(&self);
+        let canonical_result = Q::perform_query(infcx.tcx, canonical_self);
+
+        // FIXME: This is not the most efficient setup. The
+        // `instantiate_query_result_and_region_obligations` basically
+        // takes the `QueryRegionConstraint` values that we ultimately
+        // want to use and converts them into obligations. We return
+        // those to our caller, which will convert them into AST
+        // region constraints; we then convert *those* back into
+        // `QueryRegionConstraint` and ultimately into NLL
+        // constraints. We should cut out the middleman but that will
+        // take a bit of refactoring.
+        infcx.instantiate_query_result_and_region_obligations(
+            &ObligationCause::dummy(),
+            param_env,
+            &canonical_var_values,
+            &canonical_result,
+        )
+    }
+}