Gracefully handle overflow errors in impl rematching

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/mod.rs

@@ -23,6 +23,7 @@ use crate::solve::InferCtxtSelectExt;
 use crate::traits::error_reporting::TypeErrCtxtExt;
 use crate::traits::normalize::normalize_with_depth;
 use crate::traits::normalize::normalize_with_depth_to;
+use crate::traits::normalize::try_normalize_with_depth_to;
 use crate::traits::project::ProjectAndUnifyResult;
 use crate::traits::project::ProjectionCacheKeyExt;
 use crate::traits::ProjectionCacheKey;
@@ -41,11 +42,13 @@ use rustc_middle::dep_graph::DepNodeIndex;
 use rustc_middle::mir::interpret::ErrorHandled;
 use rustc_middle::ty::_match::MatchAgainstFreshVars;
 use rustc_middle::ty::abstract_const::NotConstEvaluatable;
+use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::relate::TypeRelation;
 use rustc_middle::ty::GenericArgsRef;
 use rustc_middle::ty::{self, PolyProjectionPredicate, ToPredicate};
 use rustc_middle::ty::{Ty, TyCtxt, TypeFoldable, TypeVisitableExt};
 use rustc_span::symbol::sym;
+use rustc_span::ErrorGuaranteed;
 use rustc_span::Symbol;
 
 use std::cell::{Cell, RefCell};
@@ -2083,6 +2086,16 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
     }
 }
 
+#[derive(Debug)]
+enum MatchImplFailure<'tcx> {
+    ReservationImpl,
+    #[allow(dead_code)]
+    TypeError(TypeError<'tcx>),
+    #[allow(dead_code)]
+    Overflow(OverflowError),
+    Error(ErrorGuaranteed),
+}
+
 impl<'tcx> SelectionContext<'_, 'tcx> {
     fn sized_conditions(
         &mut self,
@@ -2435,9 +2448,11 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
         let impl_trait_header = self.tcx().impl_trait_header(impl_def_id).unwrap();
         match self.match_impl(impl_def_id, impl_trait_header, obligation) {
             Ok(args) => args,
-            Err(()) => {
+            Err(err) => {
                 let predicate = self.infcx.resolve_vars_if_possible(obligation.predicate);
-                bug!("impl {impl_def_id:?} was matchable against {predicate:?} but now is not")
+                bug!(
+                    "impl {impl_def_id:?} was matchable against {predicate:?} but now is not: {err:?}"
+                )
             }
         }
     }
@@ -2448,30 +2463,30 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
         impl_def_id: DefId,
         impl_trait_header: ty::ImplTraitHeader<'tcx>,
         obligation: &PolyTraitObligation<'tcx>,
-    ) -> Result<Normalized<'tcx, GenericArgsRef<'tcx>>, ()> {
+    ) -> Result<Normalized<'tcx, GenericArgsRef<'tcx>>, MatchImplFailure<'tcx>> {
         let placeholder_obligation =
             self.infcx.enter_forall_and_leak_universe(obligation.predicate);
         let placeholder_obligation_trait_ref = placeholder_obligation.trait_ref;
 
         let impl_args = self.infcx.fresh_args_for_item(obligation.cause.span, impl_def_id);
 
         let trait_ref = impl_trait_header.trait_ref.instantiate(self.tcx(), impl_args);
-        if trait_ref.references_error() {
-            return Err(());
-        }
+        trait_ref.error_reported().map_err(MatchImplFailure::Error)?;
 
         debug!(?impl_trait_header);
 
-        let Normalized { value: impl_trait_ref, obligations: mut nested_obligations } =
-            ensure_sufficient_stack(|| {
-                normalize_with_depth(
-                    self,
-                    obligation.param_env,
-                    obligation.cause.clone(),
-                    obligation.recursion_depth + 1,
-                    trait_ref,
-                )
-            });
+        let mut nested_obligations = vec![];
+        let impl_trait_ref = ensure_sufficient_stack(|| {
+            try_normalize_with_depth_to(
+                self,
+                obligation.param_env,
+                obligation.cause.clone(),
+                obligation.recursion_depth + 1,
+                trait_ref,
+                &mut nested_obligations,
+            )
+        })
+        .map_err(MatchImplFailure::Overflow)?;
 
         debug!(?impl_trait_ref, ?placeholder_obligation_trait_ref);
 
@@ -2485,14 +2500,12 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             .infcx
             .at(&cause, obligation.param_env)
             .eq(DefineOpaqueTypes::No, placeholder_obligation_trait_ref, impl_trait_ref)
-            .map_err(|e| {
-                debug!("match_impl: failed eq_trait_refs due to `{}`", e.to_string(self.tcx()))
-            })?;
+            .map_err(MatchImplFailure::TypeError)?;
         nested_obligations.extend(obligations);
 
         if !self.is_intercrate() && impl_trait_header.polarity == ty::ImplPolarity::Reservation {
             debug!("reservation impls only apply in intercrate mode");
-            return Err(());
+            return Err(MatchImplFailure::ReservationImpl);
         }
 
         Ok(Normalized { value: impl_args, obligations: nested_obligations })

compiler/rustc_traits/src/normalize_projection_ty.rs

@@ -40,7 +40,8 @@ fn normalize_canonicalized_projection_ty<'tcx>(
                 cause,
                 0,
                 &mut obligations,
-            );
+            )
+            .map_err(|_| NoSolution)?;
             ocx.register_obligations(obligations);
             // #112047: With projections and opaques, we are able to create opaques that
             // are recursive (given some generic parameters of the opaque's type variables).

tests/ui/associated-types/hr-associated-type-bound-2.rs

@@ -8,7 +8,8 @@ where
     }
 }
 
-impl X<'_> for u32 //~ overflow evaluating the requirement `for<'b> u32: X<'b>`
+impl X<'_> for u32
+//~^ ERROR: overflow evaluating the requirement `for<'b> <u32 as X<'b>>::U: Clone`
 where
     for<'b> <Self as X<'b>>::U: Clone,
 {