transition to Fallible

Author: nikomatsakis

src/librustc/traits/query/mod.rs

@@ -16,6 +16,7 @@
 //! `librustc_traits`.
 
 use infer::canonical::Canonical;
+use ty::error::TypeError;
 use ty::{self, Ty};
 
 pub mod dropck_outlives;
@@ -49,4 +50,10 @@ pub struct NoSolution;
 
 pub type Fallible<T> = Result<T, NoSolution>;
 
+impl<'tcx> From<TypeError<'tcx>> for NoSolution {
+    fn from(_: TypeError<'tcx>) -> NoSolution {
+        NoSolution
+    }
+}
+
 impl_stable_hash_for!(struct NoSolution { });

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

@@ -8,7 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use infer::{InferCtxt, InferResult};
+use infer::{InferCtxt, InferOk};
+use traits::query::Fallible;
 use ty::TyCtxt;
 use std::fmt;
 
@@ -20,7 +21,7 @@ pub struct CustomTypeOp<F, G> {
 impl<F, G> CustomTypeOp<F, G> {
     pub fn new<'gcx, 'tcx, R>(closure: F, description: G) -> Self
     where
-        F: FnOnce(&InferCtxt<'_, 'gcx, 'tcx>) -> InferResult<'tcx, R>,
+        F: FnOnce(&InferCtxt<'_, 'gcx, 'tcx>) -> Fallible<InferOk<'tcx, R>>,
         G: Fn() -> String,
     {
         CustomTypeOp {
@@ -32,7 +33,7 @@ impl<F, G> CustomTypeOp<F, G> {
 
 impl<'gcx, 'tcx, F, R, G> super::TypeOp<'gcx, 'tcx> for CustomTypeOp<F, G>
 where
-    F: for<'a, 'cx> FnOnce(&'a InferCtxt<'cx, 'gcx, 'tcx>) -> InferResult<'tcx, R>,
+    F: for<'a, 'cx> FnOnce(&'a InferCtxt<'cx, 'gcx, 'tcx>) -> Fallible<InferOk<'tcx, R>>,
     G: Fn() -> String,
 {
     type Output = R;
@@ -41,8 +42,8 @@ where
         Err(self)
     }
 
-    fn perform(self, infcx: &InferCtxt<'_, 'gcx, 'tcx>) -> InferResult<'tcx, R> {
-        (self.closure)(infcx)
+    fn perform(self, infcx: &InferCtxt<'_, 'gcx, 'tcx>) -> Fallible<InferOk<'tcx, R>> {
+        Ok((self.closure)(infcx)?)
     }
 }
 

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

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use infer::canonical::{Canonical, CanonicalizedQueryResult, QueryResult};
+use traits::query::Fallible;
 use ty::{self, ParamEnv, Ty, TyCtxt};
 
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
@@ -42,8 +43,8 @@ impl<'gcx: 'tcx, 'tcx> super::QueryTypeOp<'gcx, 'tcx> for Eq<'tcx> {
     fn perform_query(
         tcx: TyCtxt<'_, 'gcx, 'tcx>,
         canonicalized: Canonical<'gcx, Eq<'gcx>>,
-    ) -> CanonicalizedQueryResult<'gcx, ()> {
-        tcx.type_op_eq(canonicalized).unwrap()
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, ()>> {
+        tcx.type_op_eq(canonicalized)
     }
 
     fn upcast_result(

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

@@ -12,12 +12,12 @@ use infer::canonical::query_result;
 use infer::canonical::{
     Canonical, Canonicalized, CanonicalizedQueryResult, QueryRegionConstraint, QueryResult,
 };
-use infer::{InferCtxt, InferOk, InferResult};
+use infer::{InferCtxt, InferOk};
 use std::fmt;
 use std::rc::Rc;
 use syntax::codemap::DUMMY_SP;
+use traits::query::Fallible;
 use traits::{ObligationCause, TraitEngine};
-use ty::error::TypeError;
 use ty::fold::TypeFoldable;
 use ty::{Lift, ParamEnv, TyCtxt};
 
@@ -42,15 +42,18 @@ pub trait TypeOp<'gcx, 'tcx>: Sized + fmt::Debug {
     /// should use `fully_perform`, which will take those resulting
     /// obligations and prove them, and then process the combined
     /// results into region obligations which are returned.
-    fn perform(self, infcx: &InferCtxt<'_, 'gcx, 'tcx>) -> InferResult<'tcx, Self::Output>;
+    fn perform(
+        self,
+        infcx: &InferCtxt<'_, 'gcx, 'tcx>,
+    ) -> Fallible<InferOk<'tcx, Self::Output>>;
 
     /// Processes the operation and all resulting obligations,
     /// returning the final result along with any region constraints
     /// (they will be given over to the NLL region solver).
     fn fully_perform(
         self,
         infcx: &InferCtxt<'_, 'gcx, 'tcx>,
-    ) -> Result<(Self::Output, Option<Rc<Vec<QueryRegionConstraint<'tcx>>>>), TypeError<'tcx>> {
+    ) -> Fallible<(Self::Output, Option<Rc<Vec<QueryRegionConstraint<'tcx>>>>)> {
         match self.trivial_noop(infcx.tcx) {
             Ok(r) => Ok((r, None)),
             Err(op) => op.fully_perform_nontrivial(infcx),
@@ -62,7 +65,7 @@ pub trait TypeOp<'gcx, 'tcx>: Sized + fmt::Debug {
     fn fully_perform_nontrivial(
         self,
         infcx: &InferCtxt<'_, 'gcx, 'tcx>,
-    ) -> Result<(Self::Output, Option<Rc<Vec<QueryRegionConstraint<'tcx>>>>), TypeError<'tcx>> {
+    ) -> Fallible<(Self::Output, Option<Rc<Vec<QueryRegionConstraint<'tcx>>>>)> {
         if cfg!(debug_assertions) {
             info!(
                 "fully_perform_op_and_get_region_constraint_data({:?})",
@@ -112,7 +115,7 @@ pub trait QueryTypeOp<'gcx: 'tcx, 'tcx>: TypeFoldable<'tcx> + Lift<'gcx> {
     fn perform_query(
         tcx: TyCtxt<'_, 'gcx, 'tcx>,
         canonicalized: Canonicalized<'gcx, Self>,
-    ) -> CanonicalizedQueryResult<'gcx, Self::QueryResult>;
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, Self::QueryResult>>;
 
     /// "Upcasts" a lifted query result (which is in the gcx lifetime)
     /// into the tcx lifetime. This is always just an identity cast,
@@ -136,15 +139,18 @@ where
         QueryTypeOp::trivial_noop(self, tcx)
     }
 
-    fn perform(self, infcx: &InferCtxt<'_, 'gcx, 'tcx>) -> InferResult<'tcx, Self::Output> {
+    fn perform(
+        self,
+        infcx: &InferCtxt<'_, 'gcx, 'tcx>,
+    ) -> Fallible<InferOk<'tcx, Self::Output>> {
         let param_env = self.param_env();
 
         // FIXME(#33684) -- We need to use
         // `canonicalize_hr_query_hack` here because of things like
         // the subtype query, which go awry around `'static`
         // otherwise.
         let (canonical_self, canonical_var_values) = infcx.canonicalize_hr_query_hack(&self);
-        let canonical_result = Q::perform_query(infcx.tcx, canonical_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
@@ -155,11 +161,11 @@ where
         // `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(
+        Ok(infcx.instantiate_query_result_and_region_obligations(
             &ObligationCause::dummy(),
             param_env,
             &canonical_var_values,
             Q::upcast_result(&canonical_result),
-        )
+        )?)
     }
 }

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

@@ -10,6 +10,7 @@
 
 use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResult, QueryResult};
 use std::fmt;
+use traits::query::Fallible;
 use ty::fold::TypeFoldable;
 use ty::{self, Lift, ParamEnv, Ty, TyCtxt};
 
@@ -49,7 +50,7 @@ where
     fn perform_query(
         tcx: TyCtxt<'_, 'gcx, 'tcx>,
         canonicalized: Canonicalized<'gcx, Self>,
-    ) -> CanonicalizedQueryResult<'gcx, Self::QueryResult> {
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, Self::QueryResult>> {
         T::type_op_method(tcx, canonicalized)
     }
 
@@ -64,7 +65,7 @@ pub trait Normalizable<'gcx, 'tcx>: fmt::Debug + TypeFoldable<'tcx> + Lift<'gcx>
     fn type_op_method(
         tcx: TyCtxt<'_, 'gcx, 'tcx>,
         canonicalized: Canonicalized<'gcx, Normalize<'gcx, Self>>,
-    ) -> CanonicalizedQueryResult<'gcx, Self>;
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, Self>>;
 
     /// Convert from the `'gcx` (lifted) form of `Self` into the `tcx`
     /// form of `Self`.
@@ -80,8 +81,8 @@ where
     fn type_op_method(
         tcx: TyCtxt<'_, 'gcx, 'tcx>,
         canonicalized: Canonicalized<'gcx, Normalize<'gcx, Self>>,
-    ) -> CanonicalizedQueryResult<'gcx, Self> {
-        tcx.type_op_normalize_ty(canonicalized).unwrap()
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, Self>> {
+        tcx.type_op_normalize_ty(canonicalized)
     }
 
     fn upcast_result(
@@ -98,8 +99,8 @@ where
     fn type_op_method(
         tcx: TyCtxt<'_, 'gcx, 'tcx>,
         canonicalized: Canonicalized<'gcx, Normalize<'gcx, Self>>,
-    ) -> CanonicalizedQueryResult<'gcx, Self> {
-        tcx.type_op_normalize_predicate(canonicalized).unwrap()
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, Self>> {
+        tcx.type_op_normalize_predicate(canonicalized)
     }
 
     fn upcast_result(
@@ -116,8 +117,8 @@ where
     fn type_op_method(
         tcx: TyCtxt<'_, 'gcx, 'tcx>,
         canonicalized: Canonicalized<'gcx, Normalize<'gcx, Self>>,
-    ) -> CanonicalizedQueryResult<'gcx, Self> {
-        tcx.type_op_normalize_poly_fn_sig(canonicalized).unwrap()
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, Self>> {
+        tcx.type_op_normalize_poly_fn_sig(canonicalized)
     }
 
     fn upcast_result(
@@ -134,8 +135,8 @@ where
     fn type_op_method(
         tcx: TyCtxt<'_, 'gcx, 'tcx>,
         canonicalized: Canonicalized<'gcx, Normalize<'gcx, Self>>,
-    ) -> CanonicalizedQueryResult<'gcx, Self> {
-        tcx.type_op_normalize_fn_sig(canonicalized).unwrap()
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, Self>> {
+        tcx.type_op_normalize_fn_sig(canonicalized)
     }
 
     fn upcast_result(

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

@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use infer::{InferCtxt, InferResult};
+use infer::{InferCtxt, InferOk};
 use traits::query::dropck_outlives::trivial_dropck_outlives;
+use traits::query::Fallible;
 use traits::ObligationCause;
 use ty::subst::Kind;
 use ty::{ParamEnv, Ty, TyCtxt};
@@ -40,7 +41,10 @@ impl<'gcx, 'tcx> super::TypeOp<'gcx, 'tcx> for DropckOutlives<'tcx> {
         }
     }
 
-    fn perform(self, infcx: &InferCtxt<'_, 'gcx, 'tcx>) -> InferResult<'tcx, Self::Output> {
+    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))

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

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use infer::canonical::{Canonical, CanonicalizedQueryResult, QueryResult};
+use traits::query::Fallible;
 use ty::{ParamEnv, Predicate, TyCtxt};
 
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
@@ -40,8 +41,8 @@ impl<'gcx: 'tcx, 'tcx> super::QueryTypeOp<'gcx, 'tcx> for ProvePredicate<'tcx> {
     fn perform_query(
         tcx: TyCtxt<'_, 'gcx, 'tcx>,
         canonicalized: Canonical<'gcx, ProvePredicate<'gcx>>,
-    ) -> CanonicalizedQueryResult<'gcx, ()> {
-        tcx.type_op_prove_predicate(canonicalized).unwrap()
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, ()>> {
+        tcx.type_op_prove_predicate(canonicalized)
     }
 
     fn upcast_result(

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

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use infer::canonical::{Canonical, CanonicalizedQueryResult, QueryResult};
+use traits::query::Fallible;
 use ty::{ParamEnv, Ty, TyCtxt};
 
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
@@ -46,8 +47,8 @@ impl<'gcx: 'tcx, 'tcx> super::QueryTypeOp<'gcx, 'tcx> for Subtype<'tcx> {
     fn perform_query(
         tcx: TyCtxt<'_, 'gcx, 'tcx>,
         canonicalized: Canonical<'gcx, Subtype<'gcx>>,
-    ) -> CanonicalizedQueryResult<'gcx, ()> {
-        tcx.type_op_subtype(canonicalized).unwrap()
+    ) -> Fallible<CanonicalizedQueryResult<'gcx, ()>> {
+        tcx.type_op_subtype(canonicalized)
     }
 
     fn upcast_result(

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

@@ -22,14 +22,14 @@ use dataflow::MaybeInitializedPlaces;
 use rustc::hir::def_id::DefId;
 use rustc::infer::canonical::QueryRegionConstraint;
 use rustc::infer::region_constraints::GenericKind;
-use rustc::infer::{InferCtxt, LateBoundRegionConversionTime, UnitResult};
+use rustc::infer::{InferCtxt, LateBoundRegionConversionTime};
 use rustc::mir::interpret::EvalErrorKind::BoundsCheck;
 use rustc::mir::tcx::PlaceTy;
 use rustc::mir::visit::{PlaceContext, Visitor};
 use rustc::mir::*;
 use rustc::traits::query::type_op;
+use rustc::traits::query::{Fallible, NoSolution};
 use rustc::traits::ObligationCause;
-use rustc::ty::error::TypeError;
 use rustc::ty::fold::TypeFoldable;
 use rustc::ty::{self, ToPolyTraitRef, Ty, TyCtxt, TypeVariants};
 use std::fmt;
@@ -733,7 +733,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
         &mut self,
         locations: Locations,
         op: impl type_op::TypeOp<'gcx, 'tcx, Output = R>,
-    ) -> Result<R, TypeError<'tcx>> {
+    ) -> Fallible<R> {
         let (r, opt_data) = op.fully_perform(self.infcx)?;
 
         if let Some(data) = &opt_data {
@@ -775,15 +775,15 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
         sub: Ty<'tcx>,
         sup: Ty<'tcx>,
         locations: Locations,
-    ) -> UnitResult<'tcx> {
+    ) -> Fallible<()> {
         let param_env = self.param_env;
         self.fully_perform_op(
             locations,
             type_op::subtype::Subtype::new(param_env, sub, sup),
         )
     }
 
-    fn eq_types(&mut self, a: Ty<'tcx>, b: Ty<'tcx>, locations: Locations) -> UnitResult<'tcx> {
+    fn eq_types(&mut self, a: Ty<'tcx>, b: Ty<'tcx>, locations: Locations) -> Fallible<()> {
         let param_env = self.param_env;
         self.fully_perform_op(locations, type_op::eq::Eq::new(param_env, b, a))
     }
@@ -1561,11 +1561,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
                 predicate, location,
             );
 
-            let param_env = self.param_env;
-            self.fully_perform_op(
-                location.at_self(),
-                type_op::prove_predicate::ProvePredicate::new(param_env, predicate),
-            ).unwrap()
+            self.prove_predicate(predicate, location);
         }
     }
 
@@ -1579,7 +1575,9 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
         self.fully_perform_op(
             location.at_self(),
             type_op::prove_predicate::ProvePredicate::new(param_env, predicate),
-        ).unwrap()
+        ).unwrap_or_else(|NoSolution| {
+            span_mirbug!(self, NoSolution, "could not prove {:?}", predicate);
+        })
     }
 
     fn typeck_mir(&mut self, mir: &Mir<'tcx>) {
@@ -1610,14 +1608,17 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
 
     fn normalize<T>(&mut self, value: T, location: impl ToLocations) -> T
     where
-        T: type_op::normalize::Normalizable<'gcx, 'tcx>,
+        T: type_op::normalize::Normalizable<'gcx, 'tcx> + Copy,
     {
         debug!("normalize(value={:?}, location={:?})", value, location);
         let param_env = self.param_env;
         self.fully_perform_op(
             location.to_locations(),
             type_op::normalize::Normalize::new(param_env, value),
-        ).unwrap()
+        ).unwrap_or_else(|NoSolution| {
+            span_mirbug!(self, NoSolution, "failed to normalize `{:?}`", value);
+            value
+        })
     }
 }