convert dropck_outlives type-op to use the query

Author: nikomatsakis

src/librustc/traits/query/dropck_outlives.rs

@@ -11,6 +11,7 @@
 use infer::at::At;
 use infer::InferOk;
 use std::iter::FromIterator;
+use syntax::codemap::Span;
 use ty::subst::Kind;
 use ty::{self, Ty, TyCtxt};
 
@@ -60,22 +61,9 @@ impl<'cx, 'gcx, 'tcx> At<'cx, 'gcx, 'tcx> {
                     &orig_values,
                     result,
                 ) {
-                    Ok(InferOk {
-                        value: DropckOutlivesResult { kinds, overflows },
-                        obligations,
-                    }) => {
-                        for overflow_ty in overflows.into_iter().take(1) {
-                            let mut err = struct_span_err!(
-                                tcx.sess,
-                                span,
-                                E0320,
-                                "overflow while adding drop-check rules for {}",
-                                self.infcx.resolve_type_vars_if_possible(&ty),
-                            );
-                            err.note(&format!("overflowed on {}", overflow_ty));
-                            err.emit();
-                        }
-
+                    Ok(InferOk { value, obligations }) => {
+                        let ty = self.infcx.resolve_type_vars_if_possible(&ty);
+                        let kinds = value.into_kinds_reporting_overflows(tcx, span, ty);
                         return InferOk {
                             value: kinds,
                             obligations,
@@ -102,12 +90,44 @@ impl<'cx, 'gcx, 'tcx> At<'cx, 'gcx, 'tcx> {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 pub struct DropckOutlivesResult<'tcx> {
     pub kinds: Vec<Kind<'tcx>>,
     pub overflows: Vec<Ty<'tcx>>,
 }
 
+impl<'tcx> DropckOutlivesResult<'tcx> {
+    pub fn report_overflows(
+        &self,
+        tcx: TyCtxt<'_, '_, 'tcx>,
+        span: Span,
+        ty: Ty<'tcx>,
+    ) {
+        for overflow_ty in self.overflows.iter().take(1) {
+            let mut err = struct_span_err!(
+                tcx.sess,
+                span,
+                E0320,
+                "overflow while adding drop-check rules for {}",
+                ty,
+            );
+            err.note(&format!("overflowed on {}", overflow_ty));
+            err.emit();
+        }
+    }
+
+    pub fn into_kinds_reporting_overflows(
+        self,
+        tcx: TyCtxt<'_, '_, 'tcx>,
+        span: Span,
+        ty: Ty<'tcx>,
+    ) -> Vec<Kind<'tcx>> {
+        self.report_overflows(tcx, span, ty);
+        let DropckOutlivesResult { kinds, overflows: _ } = self;
+        kinds
+    }
+}
+
 /// A set of constraints that need to be satisfied in order for
 /// a type to be valid for destruction.
 #[derive(Clone, Debug)]

src/librustc/traits/query/type_op/outlives.rs

@@ -8,12 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use infer::{InferCtxt, InferOk};
+use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResult, QueryResult};
 use traits::query::dropck_outlives::trivial_dropck_outlives;
+use traits::query::dropck_outlives::DropckOutlivesResult;
 use traits::query::Fallible;
-use traits::ObligationCause;
-use ty::subst::Kind;
-use ty::{ParamEnv, Ty, TyCtxt};
+use ty::{ParamEnv, ParamEnvAnd, Ty, TyCtxt};
 
 #[derive(Debug)]
 pub struct DropckOutlives<'tcx> {
@@ -30,23 +29,39 @@ impl<'tcx> DropckOutlives<'tcx> {
     }
 }
 
-impl<'gcx, 'tcx> super::TypeOp<'gcx, 'tcx> for DropckOutlives<'tcx> {
-    type Output = Vec<Kind<'tcx>>;
+impl super::QueryTypeOp<'gcx, 'tcx> for DropckOutlives<'tcx>
+where
+    'gcx: 'tcx,
+{
+    type QueryKey = ParamEnvAnd<'tcx, Ty<'tcx>>;
+    type QueryResult = DropckOutlivesResult<'tcx>;
 
-    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 trivial_dropck_outlives(tcx, self.dropped_ty) {
-            Ok(vec![])
+            Ok(DropckOutlivesResult::default())
         } else {
             Err(self)
         }
     }
 
-    fn perform(
-        self,
-        infcx: &InferCtxt<'_, 'gcx, 'tcx>,
-    ) -> Fallible<InferOk<'tcx, Vec<Kind<'tcx>>>> {
-        Ok(infcx
-            .at(&ObligationCause::dummy(), self.param_env)
-            .dropck_outlives(self.dropped_ty))
+    fn param_env(&self) -> ParamEnv<'tcx> {
+        self.param_env
+    }
+
+    fn into_query_key(self) -> Self::QueryKey {
+        self.param_env.and(self.dropped_ty)
+    }
+
+    fn perform_query(
+        tcx: TyCtxt<'_, 'gcx, 'tcx>,
+        canonicalized: Canonicalized<'gcx, Self::QueryKey>,
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, Self::QueryResult>> {
+        tcx.dropck_outlives(canonicalized)
+    }
+
+    fn upcast_result(
+        lifted_query_result: &'a CanonicalizedQueryResult<'gcx, Self::QueryResult>,
+    ) -> &'a Canonical<'tcx, QueryResult<'tcx, Self::QueryResult>> {
+        lifted_query_result
     }
 }

src/librustc_mir/borrow_check/nll/type_check/liveness.rs

@@ -13,12 +13,12 @@ use borrow_check::nll::type_check::AtLocation;
 use dataflow::move_paths::{HasMoveData, MoveData};
 use dataflow::MaybeInitializedPlaces;
 use dataflow::{FlowAtLocation, FlowsAtLocation};
+use rustc::traits::query::dropck_outlives::DropckOutlivesResult;
 use rustc::infer::canonical::QueryRegionConstraint;
 use rustc::mir::Local;
 use rustc::mir::{BasicBlock, Location, Mir};
 use rustc::traits::query::type_op::outlives::DropckOutlives;
 use rustc::traits::query::type_op::TypeOp;
-use rustc::ty::subst::Kind;
 use rustc::ty::{Ty, TypeFoldable};
 use rustc_data_structures::fx::FxHashMap;
 use std::rc::Rc;
@@ -71,7 +71,7 @@ where
 }
 
 struct DropData<'tcx> {
-    dropped_kinds: Vec<Kind<'tcx>>,
+    dropck_result: DropckOutlivesResult<'tcx>,
     region_constraint_data: Option<Rc<Vec<QueryRegionConstraint<'tcx>>>>,
 }
 
@@ -202,10 +202,16 @@ impl<'gen, 'typeck, 'flow, 'gcx, 'tcx> TypeLivenessGenerator<'gen, 'typeck, 'flo
             self.cx.push_region_constraints(location.at_self(), data);
         }
 
+        drop_data.dropck_result.report_overflows(
+            self.cx.infcx.tcx,
+            self.mir.source_info(location).span,
+            dropped_ty,
+        );
+
         // All things in the `outlives` array may be touched by
         // the destructor and must be live at this point.
         let cause = Cause::DropVar(dropped_local, location);
-        for &kind in &drop_data.dropped_kinds {
+        for &kind in &drop_data.dropck_result.kinds {
             Self::push_type_live_constraint(&mut self.cx, kind, location, cause);
         }
     }
@@ -217,12 +223,12 @@ impl<'gen, 'typeck, 'flow, 'gcx, 'tcx> TypeLivenessGenerator<'gen, 'typeck, 'flo
         debug!("compute_drop_data(dropped_ty={:?})", dropped_ty,);
 
         let param_env = cx.param_env;
-        let (dropped_kinds, region_constraint_data) = DropckOutlives::new(param_env, dropped_ty)
+        let (dropck_result, region_constraint_data) = DropckOutlives::new(param_env, dropped_ty)
             .fully_perform(cx.infcx)
             .unwrap();
 
         DropData {
-            dropped_kinds,
+            dropck_result,
             region_constraint_data,
         }
     }