support fulfillment with non-fatal overflow

Author: lcnr

compiler/rustc_trait_selection/src/traits/engine.rs

@@ -27,6 +27,13 @@ use rustc_span::Span;
 pub trait TraitEngineExt<'tcx> {
     fn new(tcx: TyCtxt<'tcx>) -> Box<Self>;
     fn new_in_snapshot(tcx: TyCtxt<'tcx>) -> Box<Self>;
+    /// Creates a new fulfillment context which does not abort compilation
+    /// on overflow.
+    ///
+    /// WARNING: Overflow will be returned as an error in `select_where_possible`
+    /// even though the overflow may not be the final result for the given obligation,
+    /// so you have to be incredibly careful when using `select_where_possible.
+    fn with_query_mode_canonical(tcx: TyCtxt<'tcx>) -> Box<Self>;
 }
 
 impl<'tcx> TraitEngineExt<'tcx> for dyn TraitEngine<'tcx> {
@@ -45,6 +52,14 @@ impl<'tcx> TraitEngineExt<'tcx> for dyn TraitEngine<'tcx> {
             TraitSolver::Next => Box::new(NextFulfillmentCtxt::new()),
         }
     }
+
+    fn with_query_mode_canonical(tcx: TyCtxt<'tcx>) -> Box<Self> {
+        match tcx.sess.opts.unstable_opts.trait_solver {
+            TraitSolver::Classic => Box::new(FulfillmentContext::with_query_mode_canonical()),
+            TraitSolver::Chalk => Box::new(ChalkFulfillmentContext::new()),
+            TraitSolver::Next => Box::new(NextFulfillmentCtxt::new()),
+        }
+    }
 }
 
 /// Used if you want to have pleasant experience when dealing
@@ -63,6 +78,18 @@ impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
         Self { infcx, engine: RefCell::new(<dyn TraitEngine<'_>>::new_in_snapshot(infcx.tcx)) }
     }
 
+    /// You have to be incredibly careful when using this method.
+    ///
+    /// Used in places where we have to deal with overflow in a non-fatal way.
+    /// Note that by using this the trait solver ends up being incomplete in a
+    /// may way because overflow is returned as a hard error instead of ambiguity.
+    pub fn with_query_mode_canonical(infcx: &'a InferCtxt<'tcx>) -> Self {
+        Self {
+            infcx,
+            engine: RefCell::new(<dyn TraitEngine<'_>>::with_query_mode_canonical(infcx.tcx)),
+        }
+    }
+
     pub fn register_obligation(&self, obligation: PredicateObligation<'tcx>) {
         self.engine.borrow_mut().register_predicate_obligation(self.infcx, obligation);
     }

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -12,7 +12,6 @@ use rustc_middle::ty::subst::SubstsRef;
 use rustc_middle::ty::{self, Binder, Const, TypeVisitableExt};
 use std::marker::PhantomData;
 
-use super::const_evaluatable;
 use super::project::{self, ProjectAndUnifyResult};
 use super::select::SelectionContext;
 use super::wf;
@@ -22,6 +21,7 @@ use super::CodeSelectionError;
 use super::EvaluationResult;
 use super::PredicateObligation;
 use super::Unimplemented;
+use super::{const_evaluatable, TraitQueryMode};
 use super::{FulfillmentError, FulfillmentErrorCode};
 
 use crate::traits::project::PolyProjectionObligation;
@@ -64,6 +64,8 @@ pub struct FulfillmentContext<'tcx> {
     // a snapshot (they don't *straddle* a snapshot, so there
     // is no trouble there).
     usable_in_snapshot: bool,
+
+    query_mode: TraitQueryMode,
 }
 
 #[derive(Clone, Debug)]
@@ -80,38 +82,30 @@ pub struct PendingPredicateObligation<'tcx> {
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
 static_assert_size!(PendingPredicateObligation<'_>, 72);
 
-impl<'a, 'tcx> FulfillmentContext<'tcx> {
+impl<'tcx> FulfillmentContext<'tcx> {
     /// Creates a new fulfillment context.
     pub(super) fn new() -> FulfillmentContext<'tcx> {
-        FulfillmentContext { predicates: ObligationForest::new(), usable_in_snapshot: false }
+        FulfillmentContext {
+            predicates: ObligationForest::new(),
+            usable_in_snapshot: false,
+            query_mode: TraitQueryMode::Standard,
+        }
     }
 
     pub(super) fn new_in_snapshot() -> FulfillmentContext<'tcx> {
-        FulfillmentContext { predicates: ObligationForest::new(), usable_in_snapshot: true }
+        FulfillmentContext {
+            predicates: ObligationForest::new(),
+            usable_in_snapshot: true,
+            query_mode: TraitQueryMode::Standard,
+        }
     }
 
-    /// Attempts to select obligations using `selcx`.
-    fn select(&mut self, selcx: SelectionContext<'a, 'tcx>) -> Vec<FulfillmentError<'tcx>> {
-        let span = debug_span!("select", obligation_forest_size = ?self.predicates.len());
-        let _enter = span.enter();
-
-        // Process pending obligations.
-        let outcome: Outcome<_, _> =
-            self.predicates.process_obligations(&mut FulfillProcessor { selcx });
-
-        // FIXME: if we kept the original cache key, we could mark projection
-        // obligations as complete for the projection cache here.
-
-        let errors: Vec<FulfillmentError<'tcx>> =
-            outcome.errors.into_iter().map(to_fulfillment_error).collect();
-
-        debug!(
-            "select({} predicates remaining, {} errors) done",
-            self.predicates.len(),
-            errors.len()
-        );
-
-        errors
+    pub(super) fn with_query_mode_canonical() -> FulfillmentContext<'tcx> {
+        FulfillmentContext {
+            predicates: ObligationForest::new(),
+            usable_in_snapshot: false,
+            query_mode: TraitQueryMode::Canonical,
+        }
     }
 }
 
@@ -138,8 +132,27 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
     }
 
     fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {
-        let selcx = SelectionContext::new(infcx);
-        self.select(selcx)
+        let span = debug_span!("select", obligation_forest_size = ?self.predicates.len());
+        let selcx = SelectionContext::with_query_mode(infcx, self.query_mode);
+        let _enter = span.enter();
+
+        // Process pending obligations.
+        let outcome: Outcome<_, _> =
+            self.predicates.process_obligations(&mut FulfillProcessor { selcx });
+
+        // FIXME: if we kept the original cache key, we could mark projection
+        // obligations as complete for the projection cache here.
+
+        let errors: Vec<FulfillmentError<'tcx>> =
+            outcome.errors.into_iter().map(to_fulfillment_error).collect();
+
+        debug!(
+            "select({} predicates remaining, {} errors) done",
+            self.predicates.len(),
+            errors.len()
+        );
+
+        errors
     }
 
     fn drain_unstalled_obligations(