Gracefully handle overflow errors in impl rematching

compiler/rustc_middle/src/traits/select.rs

@@ -324,9 +324,6 @@ TrivialTypeTraversalImpls! { OverflowError }
 
 impl<'tcx> From<OverflowError> for SelectionError<'tcx> {
     fn from(overflow_error: OverflowError) -> SelectionError<'tcx> {
-        match overflow_error {
-            OverflowError::Error(e) => SelectionError::Overflow(OverflowError::Error(e)),
-            OverflowError::Canonical => SelectionError::Overflow(OverflowError::Canonical),
-        }
+        SelectionError::Overflow(overflow_error)
     }
 }

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -1,11 +1,14 @@
 //! Deeply normalize types using the old trait solver.
+use crate::traits::project::ProjectionNormalizationFailure;
+
 use super::error_reporting::OverflowCause;
 use super::error_reporting::TypeErrCtxtExt;
 use super::SelectionContext;
 use super::{project, with_replaced_escaping_bound_vars, BoundVarReplacer, PlaceholderReplacer};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_infer::infer::at::At;
 use rustc_infer::infer::InferOk;
+use rustc_infer::traits::OverflowError;
 use rustc_infer::traits::PredicateObligation;
 use rustc_infer::traits::{FulfillmentError, Normalized, Obligation, TraitEngine};
 use rustc_middle::traits::{ObligationCause, ObligationCauseCode, Reveal};
@@ -97,6 +100,27 @@ where
     result
 }
 
+#[instrument(level = "info", skip(selcx, param_env, cause, obligations))]
+pub(crate) fn try_normalize_with_depth_to<'a, 'b, 'tcx, T>(
+    selcx: &'a mut SelectionContext<'b, 'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+    cause: ObligationCause<'tcx>,
+    depth: usize,
+    value: T,
+    obligations: &mut Vec<PredicateObligation<'tcx>>,
+) -> Result<T, OverflowError>
+where
+    T: TypeFoldable<TyCtxt<'tcx>>,
+{
+    debug!(obligations.len = obligations.len());
+    let mut normalizer = AssocTypeNormalizer::new(selcx, param_env, cause, depth, obligations);
+    let result = ensure_sufficient_stack(|| normalizer.fold(value));
+    debug!(?result, obligations.len = normalizer.obligations.len());
+    debug!(?normalizer.obligations,);
+    normalizer.overflowed?;
+    Ok(result)
+}
+
 pub(super) fn needs_normalization<'tcx, T: TypeVisitable<TyCtxt<'tcx>>>(
     value: &T,
     reveal: Reveal,
@@ -121,6 +145,11 @@ struct AssocTypeNormalizer<'a, 'b, 'tcx> {
     obligations: &'a mut Vec<PredicateObligation<'tcx>>,
     depth: usize,
     universes: Vec<Option<ty::UniverseIndex>>,
+    /// Signals that there was an overflow during normalization somewhere.
+    /// We use this side channel instead of a `FallibleTypeFolder`, because
+    /// most code expects to get their value back on error, and we'd have to
+    /// clone the original value before normalization to achieve this.
+    overflowed: Result<(), OverflowError>,
 }
 
 impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
@@ -132,7 +161,15 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
         obligations: &'a mut Vec<PredicateObligation<'tcx>>,
     ) -> AssocTypeNormalizer<'a, 'b, 'tcx> {
         debug_assert!(!selcx.infcx.next_trait_solver());
-        AssocTypeNormalizer { selcx, param_env, cause, obligations, depth, universes: vec![] }
+        AssocTypeNormalizer {
+            selcx,
+            param_env,
+            cause,
+            obligations,
+            depth,
+            universes: vec![],
+            overflowed: Ok(()),
+        }
     }
 
     fn fold<T: TypeFoldable<TyCtxt<'tcx>>>(&mut self, value: T) -> T {
@@ -243,14 +280,21 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
                     self.depth,
                     self.obligations,
                 );
+                let normalized_ty = match normalized_ty {
+                    Ok(term) => term.ty().unwrap(),
+                    Err(oflo) => {
+                        self.overflowed = Err(oflo);
+                        return ty;
+                    }
+                };
                 debug!(
                     ?self.depth,
                     ?ty,
                     ?normalized_ty,
                     obligations.len = ?self.obligations.len(),
                     "AssocTypeNormalizer: normalized type"
                 );
-                normalized_ty.ty().unwrap()
+                normalized_ty
             }
 
             ty::Projection => {
@@ -277,21 +321,24 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
                     self.cause.clone(),
                     self.depth,
                     self.obligations,
-                )
-                .ok()
-                .flatten()
-                .map(|term| term.ty().unwrap())
-                .map(|normalized_ty| {
-                    PlaceholderReplacer::replace_placeholders(
+                );
+                let normalized_ty = match normalized_ty {
+                    Ok(Some(term)) => PlaceholderReplacer::replace_placeholders(
                         infcx,
                         mapped_regions,
                         mapped_types,
                         mapped_consts,
                         &self.universes,
-                        normalized_ty,
-                    )
-                })
-                .unwrap_or_else(|| ty.super_fold_with(self));
+                        term.ty().unwrap(),
+                    ),
+                    Ok(None) | Err(ProjectionNormalizationFailure::InProgress) => {
+                        ty.super_fold_with(self)
+                    }
+                    Err(ProjectionNormalizationFailure::Overflow(oflo)) => {
+                        self.overflowed = Err(oflo);
+                        return ty;
+                    }
+                };
 
                 debug!(
                     ?self.depth,

compiler/rustc_trait_selection/src/traits/project.rs

@@ -46,7 +46,14 @@ pub type ProjectionObligation<'tcx> = Obligation<'tcx, ty::ProjectionPredicate<'
 
 pub type ProjectionTyObligation<'tcx> = Obligation<'tcx, ty::AliasTy<'tcx>>;
 
-pub(super) struct InProgress;
+/// Signals the various ways in which we can fail to normalize a projection
+#[derive(Debug)]
+pub enum ProjectionNormalizationFailure {
+    /// Blocked on inference variables resolving
+    InProgress,
+    /// Fatal failure, overflow occurred.
+    Overflow(OverflowError),
+}
 
 /// When attempting to resolve `<T as TraitRef>::Name` ...
 #[derive(Debug)]
@@ -252,7 +259,10 @@ fn project_and_unify_type<'cx, 'tcx>(
     ) {
         Ok(Some(n)) => n,
         Ok(None) => return ProjectAndUnifyResult::FailedNormalization,
-        Err(InProgress) => return ProjectAndUnifyResult::Recursive,
+        Err(
+            ProjectionNormalizationFailure::InProgress
+            | ProjectionNormalizationFailure::Overflow(_),
+        ) => return ProjectAndUnifyResult::Recursive,
     };
     debug!(?normalized, ?obligations, "project_and_unify_type result");
     let actual = obligation.predicate.term;
@@ -298,24 +308,29 @@ pub fn normalize_projection_type<'a, 'b, 'tcx>(
     cause: ObligationCause<'tcx>,
     depth: usize,
     obligations: &mut Vec<PredicateObligation<'tcx>>,
-) -> Term<'tcx> {
-    opt_normalize_projection_type(
+) -> Result<Term<'tcx>, OverflowError> {
+    let normalized = opt_normalize_projection_type(
         selcx,
         param_env,
         projection_ty,
         cause.clone(),
         depth,
         obligations,
-    )
-    .ok()
-    .flatten()
-    .unwrap_or_else(move || {
-        // if we bottom out in ambiguity, create a type variable
-        // and a deferred predicate to resolve this when more type
-        // information is available.
-
-        selcx.infcx.infer_projection(param_env, projection_ty, cause, depth + 1, obligations).into()
-    })
+    );
+    match normalized {
+        Ok(Some(term)) => Ok(term),
+        Ok(None) | Err(ProjectionNormalizationFailure::InProgress) => {
+            // if we bottom out in ambiguity, create a type variable
+            // and a deferred predicate to resolve this when more type
+            // information is available.
+
+            Ok(selcx
+                .infcx
+                .infer_projection(param_env, projection_ty, cause, depth + 1, obligations)
+                .into())
+        }
+        Err(ProjectionNormalizationFailure::Overflow(oflo)) => Err(oflo),
+    }
 }
 
 /// The guts of `normalize`: normalize a specific projection like `<T
@@ -328,15 +343,15 @@ pub fn normalize_projection_type<'a, 'b, 'tcx>(
 /// often immediately appended to another obligations vector. So now this
 /// function takes an obligations vector and appends to it directly, which is
 /// slightly uglier but avoids the need for an extra short-lived allocation.
-#[instrument(level = "debug", skip(selcx, param_env, cause, obligations))]
+#[instrument(level = "debug", skip(selcx, param_env, cause, obligations), ret)]
 pub(super) fn opt_normalize_projection_type<'a, 'b, 'tcx>(
     selcx: &'a mut SelectionContext<'b, 'tcx>,
     param_env: ty::ParamEnv<'tcx>,
     projection_ty: ty::AliasTy<'tcx>,
     cause: ObligationCause<'tcx>,
     depth: usize,
     obligations: &mut Vec<PredicateObligation<'tcx>>,
-) -> Result<Option<Term<'tcx>>, InProgress> {
+) -> Result<Option<Term<'tcx>>, ProjectionNormalizationFailure> {
     let infcx = selcx.infcx;
     debug_assert!(!selcx.infcx.next_trait_solver());
     // Don't use the projection cache in intercrate mode -
@@ -387,11 +402,11 @@ pub(super) fn opt_normalize_projection_type<'a, 'b, 'tcx>(
             if use_cache {
                 infcx.inner.borrow_mut().projection_cache().recur(cache_key);
             }
-            return Err(InProgress);
+            return Err(ProjectionNormalizationFailure::InProgress);
         }
         Err(ProjectionCacheEntry::Recur) => {
             debug!("recur cache");
-            return Err(InProgress);
+            return Err(ProjectionNormalizationFailure::InProgress);
         }
         Err(ProjectionCacheEntry::NormalizedTy { ty, complete: _ }) => {
             // This is the hottest path in this function.
@@ -471,6 +486,12 @@ pub(super) fn opt_normalize_projection_type<'a, 'b, 'tcx>(
             }
             Ok(None)
         }
+        Err(ProjectionError::TraitSelectionError(SelectionError::Overflow(oflo))) => {
+            if use_cache {
+                infcx.inner.borrow_mut().projection_cache().error(cache_key);
+            }
+            Err(ProjectionNormalizationFailure::Overflow(oflo))
+        }
         Err(ProjectionError::TraitSelectionError(_)) => {
             debug!("opt_normalize_projection_type: ERROR");
             // if we got an error processing the `T as Trait` part,

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -925,6 +925,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 // since we don't actually use them.
                 &mut vec![],
             )
+            .ok()?
             .ty()
             .unwrap();
 

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -11,6 +11,7 @@ use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_hir::lang_items::LangItem;
 use rustc_infer::infer::HigherRankedType;
 use rustc_infer::infer::{DefineOpaqueTypes, InferOk};
+use rustc_infer::traits::OverflowError;
 use rustc_middle::traits::{BuiltinImplSource, SignatureMismatchData};
 use rustc_middle::ty::{
     self, GenericArgs, GenericArgsRef, GenericParamDefKind, ToPolyTraitRef, ToPredicate,
@@ -63,7 +64,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
 
             ImplCandidate(impl_def_id) => {
-                ImplSource::UserDefined(self.confirm_impl_candidate(obligation, impl_def_id))
+                ImplSource::UserDefined(self.confirm_impl_candidate(obligation, impl_def_id)?)
             }
 
             AutoImplCandidate => {
@@ -441,14 +442,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         &mut self,
         obligation: &PolyTraitObligation<'tcx>,
         impl_def_id: DefId,
-    ) -> ImplSourceUserDefinedData<'tcx, PredicateObligation<'tcx>> {
+    ) -> Result<ImplSourceUserDefinedData<'tcx, PredicateObligation<'tcx>>, OverflowError> {
         debug!(?obligation, ?impl_def_id, "confirm_impl_candidate");
 
         // First, create the generic parameters by matching the impl again,
         // this time not in a probe.
-        let args = self.rematch_impl(impl_def_id, obligation);
+        let args = self.rematch_impl(impl_def_id, obligation)?;
         debug!(?args, "impl args");
-        ensure_sufficient_stack(|| {
+        Ok(ensure_sufficient_stack(|| {
             self.vtable_impl(
                 impl_def_id,
                 args,
@@ -457,7 +458,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 obligation.param_env,
                 obligation.predicate,
             )
-        })
+        }))
     }
 
     fn vtable_impl(
@@ -1370,7 +1371,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 trait_pred.trait_ref.def_id = drop_trait;
                 trait_pred
             });
-            let args = self.rematch_impl(impl_def_id, &new_obligation);
+            let args = self.rematch_impl(impl_def_id, &new_obligation)?;
             debug!(?args, "impl args");
 
             let cause = obligation.derived_cause(|derived| {