Auto merge of #146096 - adwinwhite:handle_normalization_overflow_in_mono1, r=<try>

rust-bors[bot] · web-flow · commit fbddf9b07d54 · 2025-09-26T20:48:23.000Z
Fix normalization overflow ICEs in monomorphization
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
@@ -2709,6 +2709,11 @@ rustc_queries! {
         cache_on_disk_if { true }
     }
 
+    query has_normalization_error_in_mono(key: ty::Instance<'tcx>) -> bool {
+        desc { "checking whether {}'s body has post-analysis normalization error", key }
+        cache_on_disk_if { true }
+    }
+
     query size_estimate(key: ty::Instance<'tcx>) -> usize {
         desc { "estimating codegen size of `{}`", key }
         cache_on_disk_if { true }
diff --git a/compiler/rustc_monomorphize/src/mono_checks/mod.rs b/compiler/rustc_monomorphize/src/mono_checks/mod.rs
@@ -7,9 +7,12 @@ use rustc_middle::ty::{Instance, TyCtxt};
 
 mod abi_check;
 mod move_check;
+mod normalization_check;
 
 fn check_mono_item<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) {
     let body = tcx.instance_mir(instance.def);
+
+    normalization_check::check_normalization_error(tcx, instance, body);
     abi_check::check_feature_dependent_abi(tcx, instance, body);
     move_check::check_moves(tcx, instance, body);
 }
diff --git a/compiler/rustc_monomorphize/src/mono_checks/normalization_check.rs b/compiler/rustc_monomorphize/src/mono_checks/normalization_check.rs
@@ -0,0 +1,45 @@
+use std::ops::ControlFlow;
+
+use rustc_middle::mir::Body;
+use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeVisitable, TypeVisitor};
+
+use crate::errors::RecursionLimit;
+
+struct NormalizationChecker<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    instance: Instance<'tcx>,
+}
+
+impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for NormalizationChecker<'tcx> {
+    type Result = ControlFlow<()>;
+
+    fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
+        match self.instance.try_instantiate_mir_and_normalize_erasing_regions(
+            self.tcx,
+            ty::TypingEnv::fully_monomorphized(),
+            ty::EarlyBinder::bind(t),
+        ) {
+            Ok(_) => ControlFlow::Continue(()),
+            Err(_) => ControlFlow::Break(()),
+        }
+    }
+}
+
+pub(crate) fn check_normalization_error<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    instance: Instance<'tcx>,
+    body: &Body<'tcx>,
+) {
+    let mut checker = NormalizationChecker { tcx, instance };
+    if body.visit_with(&mut checker).is_break() {
+        // Plenty of code paths later assume that everything can be normalized.
+        // Check normalization here to provide better diagnostics.
+        // Normalization errors here are usually due to trait solving overflow.
+        // FIXME: I assume that there are few type errors at post-analysis stage, but not
+        // entirely sure.
+        let def_id = instance.def_id();
+        let def_span = tcx.def_span(def_id);
+        let def_path_str = tcx.def_path_str(def_id);
+        tcx.dcx().emit_fatal(RecursionLimit { span: def_span, instance, def_span, def_path_str });
+    }
+}
diff --git a/compiler/rustc_traits/src/normalize_erasing_regions.rs b/compiler/rustc_traits/src/normalize_erasing_regions.rs
@@ -42,7 +42,18 @@ fn try_normalize_after_erasing_regions<'tcx, T: TypeFoldable<TyCtxt<'tcx>> + Par
             // us a test case.
             debug_assert_eq!(normalized_value, resolved_value);
             let erased = infcx.tcx.erase_and_anonymize_regions(resolved_value);
-            debug_assert!(!erased.has_infer(), "{erased:?}");
+            if infcx.next_trait_solver() {
+                debug_assert!(!erased.has_infer(), "{erased:?}");
+            } else {
+                // The old solver returns an ty var with the failed obligation in case of
+                // selection error. And when the obligation is re-tried, the error should be
+                // reported. However in case of overflow error, the obligation may be fulfilled
+                // due to the original depth being dropped.
+                // In conclusion, overflow results in an unconstrained ty var.
+                if erased.has_infer() {
+                    return Err(NoSolution);
+                }
+            }
             Ok(erased)
         }
         Err(NoSolution) => Err(NoSolution),
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-105275.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-105275.rs
@@ -1,9 +1,10 @@
-//@ known-bug: #105275
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 
 pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
     if n > 15 {
         encode_num(n / 16, &mut writer)?;
+        //~^ ERROR: reached the recursion limit while instantiating
     }
     Ok(())
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-105275.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-105275.stderr
@@ -0,0 +1,14 @@
+error: reached the recursion limit while instantiating `encode_num::<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut Error>`
+  --> $DIR/recursion-issue-105275.rs:6:9
+   |
+LL |         encode_num(n / 16, &mut writer)?;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `encode_num` defined here
+  --> $DIR/recursion-issue-105275.rs:4:1
+   |
+LL | pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-105937.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-105937.rs
@@ -1,9 +1,10 @@
-//@ known-bug: #105937
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 
 pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
     if n > 15 {
         encode_num(n / 16, &mut writer)?;
+        //~^ ERROR: reached the recursion limit while instantiating
     }
     Ok(())
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-105937.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-105937.stderr
@@ -0,0 +1,14 @@
+error: reached the recursion limit while instantiating `encode_num::<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut Error>`
+  --> $DIR/recursion-issue-105937.rs:6:9
+   |
+LL |         encode_num(n / 16, &mut writer)?;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `encode_num` defined here
+  --> $DIR/recursion-issue-105937.rs:4:1
+   |
+LL | pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #117696
+//@ build-fail
 fn main() {
     let mut it = (Empty);
     rec(&mut it);
@@ -23,6 +23,7 @@ where
 {
     if () == () {
         T::count(it);
+        //~^ ERROR: reached the recursion limit while instantiating
     } else {
         rec(identity(&mut it))
     }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.stderr
@@ -0,0 +1,11 @@
+error: reached the recursion limit while instantiating `<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut Empty as Iterator>::count`
+  --> $DIR/recursion-issue-117696-1.rs:25:9
+   |
+LL |         T::count(it);
+   |         ^^^^^^^^^^^^
+   |
+note: `count` defined here
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #117696
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 fn main() {
     rec(&mut None::<()>.into_iter());
@@ -9,5 +9,6 @@ fn rec<T: Iterator>(mut it: T) {
         it.next();
     } else {
         rec(&mut it);
+        //~^ ERROR: reached the recursion limit while instantiating
     }
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.stderr
@@ -0,0 +1,14 @@
+error: reached the recursion limit while instantiating `rec::<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut std::option::IntoIter<()>>`
+  --> $DIR/recursion-issue-117696-2.rs:11:9
+   |
+LL |         rec(&mut it);
+   |         ^^^^^^^^^^^^
+   |
+note: `rec` defined here
+  --> $DIR/recursion-issue-117696-2.rs:7:1
+   |
+LL | fn rec<T: Iterator>(mut it: T) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-118590.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-118590.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #118590
+//@ build-fail
 
 fn main() {
     recurse(std::iter::empty::<()>())
@@ -8,4 +8,5 @@ fn recurse(nums: impl Iterator) {
     if true { return }
 
     recurse(nums.skip(42).peekable())
+    //~^ ERROR: reached the recursion limit while instantiating
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-118590.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-118590.stderr
@@ -0,0 +1,11 @@
+error: reached the recursion limit while instantiating `<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<std::iter::Empty<()>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as Iterator>::peekable`
+  --> $DIR/recursion-issue-118590.rs:10:13
+   |
+LL |     recurse(nums.skip(42).peekable())
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `peekable` defined here
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-122823.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-122823.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #122823
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 // ignore-tidy-linelength
 
@@ -41,6 +41,7 @@ pub fn operator_packet<I: Iterator<Item = u64>>(version: u64, type_id: u64, itr:
         version: version,
         type_id: type_id,
         packets: decode_packets(&mut itr.take(0).peekable()),
+        //~^ ERROR: reached the recursion limit while instantiating
     };
 
     return Some(Packet::Operator(p));
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-122823.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-122823.stderr
@@ -0,0 +1,11 @@
+error: reached the recursion limit while instantiating `<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::vec::IntoIter<u64>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as Iterator>::peekable`
+  --> $DIR/recursion-issue-122823.rs:43:38
+   |
+LL |         packets: decode_packets(&mut itr.take(0).peekable()),
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `peekable` defined here
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-131342.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-131342.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #131342
+//@ build-fail
 
 fn main() {
     let mut items = vec![1, 2, 3, 4, 5].into_iter();
@@ -7,6 +7,7 @@ fn main() {
 
 fn problem_thingy(items: &mut impl Iterator<Item = u8>) {
     let mut peeker = items.peekable();
+    //~^ ERROR: reached the recursion limit while instantiating
     match peeker.peek() {
         Some(_) => (),
         None => return (),
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-131342.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-131342.stderr
@@ -0,0 +1,11 @@
+error: reached the recursion limit while instantiating `<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut std::vec::IntoIter<u8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as Iterator>::peekable`
+  --> $DIR/recursion-issue-131342.rs:9:22
+   |
+LL |     let mut peeker = items.peekable();
+   |                      ^^^^^^^^^^^^^^^^
+   |
+note: `peekable` defined here
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-139659.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-139659.rs
@@ -1,5 +1,6 @@
-//@ known-bug: #139659
+//@ build-fail
 //@compile-flags: -Cdebuginfo=2 -Copt-level=0 --crate-type lib
+//~^^ ERROR: reached the recursion limit while instantiating
 trait Trait {
     type Output;
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-139659.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-139659.stderr
@@ -0,0 +1,10 @@
+error: reached the recursion limit while instantiating `recurse`
+   |
+note: `recurse` defined here
+  --> $DIR/recursion-issue-139659.rs:27:1
+   |
+LL | pub fn recurse() -> impl Sized {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-92004.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-92004.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #102310
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 //@ edition:2021
 // ignore-tidy-linelength
@@ -42,6 +42,7 @@ pub fn operator_packet<I: Iterator<Item = u64>>(version: u64, type_id: u64, itr:
         version: version,
         type_id: type_id,
         packets: decode_packets(&mut itr.take(0).peekable()),
+        //~^ ERROR: reached the recursion limit while instantiating
     };
 
     return Some(Packet::Operator(p));
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-92004.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-92004.stderr
@@ -0,0 +1,11 @@
+error: reached the recursion limit while instantiating `<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::vec::IntoIter<u64>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as Iterator>::peekable`
+  --> $DIR/recursion-issue-92004.rs:44:38
+   |
+LL |         packets: decode_packets(&mut itr.take(0).peekable()),
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `peekable` defined here
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-92470.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-92470.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #92470
+//@ build-fail
 fn main() {
     encode(&mut EncoderImpl);
 }
@@ -10,8 +10,10 @@ pub trait Encoder {
 }
 
 fn encode<E: Encoder>(mut encoder: E) {
+//~^ WARN: function cannot return without recursing
     encoder.writer();
     encode(&mut encoder);
+    //~^ ERROR: reached the recursion limit while instantiating
 }
 
 struct EncoderImpl;
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-92470.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-92470.stderr
@@ -0,0 +1,26 @@
+warning: function cannot return without recursing
+  --> $DIR/recursion-issue-92470.rs:12:1
+   |
+LL | fn encode<E: Encoder>(mut encoder: E) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
+...
+LL |     encode(&mut encoder);
+   |     -------------------- recursive call site
+   |
+   = help: a `loop` may express intention better if this is on purpose
+   = note: `#[warn(unconditional_recursion)]` on by default
+
+error: reached the recursion limit while instantiating `encode::<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut EncoderImpl>`
+  --> $DIR/recursion-issue-92470.rs:15:5
+   |
+LL |     encode(&mut encoder);
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+note: `encode` defined here
+  --> $DIR/recursion-issue-92470.rs:12:1
+   |
+LL | fn encode<E: Encoder>(mut encoder: E) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error; 1 warning emitted
+
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-95134.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-95134.rs
@@ -1,9 +1,10 @@
-//@ known-bug: #95134
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 
 pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
     if n > 15 {
         encode_num(n / 16, &mut writer)?;
+        //~^ ERROR: reached the recursion limit while instantiating
     }
     Ok(())
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-95134.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-95134.stderr

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,10 @@`
`1`		`-//@ known-bug: #105275`
	`1`	`+//@ build-fail`
`2`	`2`	`//@ compile-flags: -Copt-level=0`
`3`	`3`
`4`	`4`	`pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {`
`5`	`5`	`if n > 15 {`
`6`	`6`	`encode_num(n / 16, &mut writer)?;`
	`7`	`+ //~^ ERROR: reached the recursion limit while instantiating`
`7`	`8`	`}`
`8`	`9`	`Ok(())`
`9`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,10 @@`
`1`		`-//@ known-bug: #105937`
	`1`	`+//@ build-fail`
`2`	`2`	`//@ compile-flags: -Copt-level=0`
`3`	`3`
`4`	`4`	`pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {`
`5`	`5`	`if n > 15 {`
`6`	`6`	`encode_num(n / 16, &mut writer)?;`
	`7`	`+ //~^ ERROR: reached the recursion limit while instantiating`
`7`	`8`	`}`
`8`	`9`	`Ok(())`
`9`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-//@ known-bug: #117696`
	`1`	`+//@ build-fail`
`2`	`2`	`fn main() {`
`3`	`3`	`let mut it = (Empty);`
`4`	`4`	`rec(&mut it);`
`@@ -23,6 +23,7 @@ where`
`23`	`23`	`{`
`24`	`24`	`if () == () {`
`25`	`25`	`T::count(it);`
	`26`	`+ //~^ ERROR: reached the recursion limit while instantiating`
`26`	`27`	`} else {`
`27`	`28`	`rec(identity(&mut it))`
`28`	`29`	`}`