Fix normalization overflow ICEs in monomorphization

compiler/rustc_middle/src/query/mod.rs

@@ -2698,6 +2698,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 }

compiler/rustc_monomorphize/src/collector.rs

@@ -473,6 +473,23 @@ fn collect_items_rec<'tcx>(
                 recursion_limit,
             ));
 
+            // 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.
+            if tcx.has_normalization_error_in_mono(instance) {
+                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: starting_item.span,
+                    instance,
+                    def_span,
+                    def_path_str,
+                });
+            }
+
             rustc_data_structures::stack::ensure_sufficient_stack(|| {
                 let (used, mentioned) = tcx.items_of_instance((instance, mode));
                 used_items.extend(used.into_iter().copied());
@@ -603,6 +620,21 @@ fn collect_items_rec<'tcx>(
     }
 }
 
+// Check whether we can normalize the MIR body. Make it a query since decoding MIR from disk cache
+// may be expensive.
+fn has_normalization_error_in_mono<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> bool {
+    let body = tcx.instance_mir(instance.def);
+    body.local_decls.iter().any(|local| {
+        instance
+            .try_instantiate_mir_and_normalize_erasing_regions(
+                tcx,
+                ty::TypingEnv::fully_monomorphized(),
+                ty::EarlyBinder::bind(local.ty),
+            )
+            .is_err()
+    })
+}
+
 fn check_recursion_limit<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: Instance<'tcx>,
@@ -1757,4 +1789,5 @@ pub(crate) fn collect_crate_mono_items<'tcx>(
 pub(crate) fn provide(providers: &mut Providers) {
     providers.hooks.should_codegen_locally = should_codegen_locally;
     providers.items_of_instance = items_of_instance;
+    providers.has_normalization_error_in_mono = has_normalization_error_in_mono;
 }

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_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),

tests/crashes/105275.rs → 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(())
 }

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
+

tests/crashes/105937.rs → 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(())
 }

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
+

tests/crashes/117696-2.rs → 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
     }
 }

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
+

tests/crashes/118590.rs → 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
 }

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
+

tests/crashes/122823.rs → 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));

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
+

tests/crashes/131342.rs → 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 (),

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
+

tests/crashes/139659.rs → 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;
 }

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
+

tests/crashes/92004.rs → 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));

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
+

tests/crashes/92470.rs → 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;

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
+

tests/crashes/95134.rs → 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(())
 }

tests/ui/codegen/normalization-overflow/recursion-issue-95134.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 EmptyWriter>`
+  --> $DIR/recursion-issue-95134.rs:6:9
+   |
+LL |         encode_num(n / 16, &mut writer)?;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `encode_num` defined here
+  --> $DIR/recursion-issue-95134.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
+