Rollup merge of rust-lang#156246 - jdonszelmann:rerun-error-type, r=lcnr

Introduce a `RerunNonErased` error type mirroring `NoSolution`, to better track when we're bailing

r? @lcnr

@rustbot blocked rust-lang#155443

Author: JonathanBrouwer

compiler/rustc_ast_ir/src/visit.rs

@@ -41,6 +41,29 @@ impl<T> VisitorResult for ControlFlow<T> {
     }
 }
 
+impl<E> VisitorResult for Result<(), E> {
+    type Residual = E;
+
+    fn output() -> Self {
+        Ok(())
+    }
+    fn from_residual(residual: Self::Residual) -> Self {
+        Err(residual)
+    }
+    fn from_branch(b: ControlFlow<Self::Residual>) -> Self {
+        match b {
+            ControlFlow::Continue(()) => Ok(()),
+            ControlFlow::Break(e) => Err(e),
+        }
+    }
+    fn branch(self) -> ControlFlow<Self::Residual> {
+        match self {
+            Ok(()) => ControlFlow::Continue(()),
+            Err(e) => ControlFlow::Break(e),
+        }
+    }
+}
+
 #[macro_export]
 macro_rules! try_visit {
     ($e:expr) => {

compiler/rustc_middle/src/ty/context/impl_interner.rs

@@ -1,5 +1,6 @@
 //! Implementation of [`rustc_type_ir::Interner`] for [`TyCtxt`].
 
+use std::ops::ControlFlow;
 use std::{debug_assert_matches, fmt};
 
 use rustc_errors::ErrorGuaranteed;
@@ -9,7 +10,9 @@ use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::lang_items::LangItem;
 use rustc_span::{DUMMY_SP, Span, Symbol};
 use rustc_type_ir::lang_items::{SolverAdtLangItem, SolverProjectionLangItem, SolverTraitLangItem};
-use rustc_type_ir::{CollectAndApply, Interner, TypeFoldable, Unnormalized, search_graph};
+use rustc_type_ir::{
+    CollectAndApply, Interner, TypeFoldable, Unnormalized, VisitorResult, search_graph,
+};
 
 use crate::dep_graph::{DepKind, DepNodeIndex};
 use crate::infer::canonical::CanonicalVarKinds;
@@ -522,20 +525,31 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     // This implementation is a bit different from `TyCtxt::for_each_relevant_impl`,
     // since we want to skip over blanket impls for non-rigid aliases, and also we
     // only want to consider types that *actually* unify with float/int vars.
-    fn for_each_relevant_impl(
+    fn for_each_relevant_impl<R: VisitorResult>(
         self,
         trait_def_id: DefId,
         self_ty: Ty<'tcx>,
-        mut f: impl FnMut(DefId),
-    ) {
+        mut f: impl FnMut(DefId) -> R,
+    ) -> R {
+        macro_rules! ret {
+            ($e: expr) => {
+                match $e.branch() {
+                    ControlFlow::Break(b) => return R::from_residual(b),
+                    ControlFlow::Continue(()) => {}
+                }
+            };
+        }
+
         let tcx = self;
         let trait_impls = tcx.trait_impls_of(trait_def_id);
         let mut consider_impls_for_simplified_type = |simp| {
             if let Some(impls_for_type) = trait_impls.non_blanket_impls().get(&simp) {
                 for &impl_def_id in impls_for_type {
-                    f(impl_def_id);
+                    ret!(f(impl_def_id))
                 }
             }
+
+            R::output()
         };
 
         match self_ty.kind() {
@@ -566,7 +580,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
                     self_ty,
                     ty::fast_reject::TreatParams::AsRigid,
                 ) {
-                    consider_impls_for_simplified_type(simp);
+                    ret!(consider_impls_for_simplified_type(simp));
                 }
             }
 
@@ -595,7 +609,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
                     ty::SimplifiedType::Uint(Usize),
                 ];
                 for simp in possible_integers {
-                    consider_impls_for_simplified_type(simp);
+                    ret!(consider_impls_for_simplified_type(simp));
                 }
             }
 
@@ -610,7 +624,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
                 ];
 
                 for simp in possible_floats {
-                    consider_impls_for_simplified_type(simp);
+                    ret!(consider_impls_for_simplified_type(simp));
                 }
             }
 
@@ -634,11 +648,20 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         #[allow(rustc::usage_of_type_ir_traits)]
         self.for_each_blanket_impl(trait_def_id, f)
     }
-    fn for_each_blanket_impl(self, trait_def_id: DefId, mut f: impl FnMut(DefId)) {
+    fn for_each_blanket_impl<R: VisitorResult>(
+        self,
+        trait_def_id: DefId,
+        mut f: impl FnMut(DefId) -> R,
+    ) -> R {
         let trait_impls = self.trait_impls_of(trait_def_id);
         for &impl_def_id in trait_impls.blanket_impls() {
-            f(impl_def_id);
+            match f(impl_def_id).branch() {
+                ControlFlow::Break(b) => return R::from_residual(b),
+                ControlFlow::Continue(()) => {}
+            }
         }
+
+        R::output()
     }
 
     fn has_item_definition(self, def_id: DefId) -> bool {

compiler/rustc_next_trait_solver/src/solve/alias_relate.rs

@@ -16,12 +16,12 @@
 //! relate them structurally.
 
 use rustc_type_ir::inherent::*;
-use rustc_type_ir::solve::GoalSource;
+use rustc_type_ir::solve::{GoalSource, QueryResultOrRerunNonErased};
 use rustc_type_ir::{self as ty, Interner};
 use tracing::{instrument, trace};
 
 use crate::delegate::SolverDelegate;
-use crate::solve::{Certainty, EvalCtxt, Goal, QueryResult};
+use crate::solve::{Certainty, EvalCtxt, Goal};
 
 impl<D, I> EvalCtxt<'_, D>
 where
@@ -32,7 +32,7 @@ where
     pub(super) fn compute_alias_relate_goal(
         &mut self,
         goal: Goal<I, (I::Term, I::Term, ty::AliasRelationDirection)>,
-    ) -> QueryResult<I> {
+    ) -> QueryResultOrRerunNonErased<I> {
         let cx = self.cx();
         let Goal { param_env, predicate: (lhs, rhs, direction) } = goal;