Prevent infinite recursion in monomorphization error handling

Signed-off-by: FedericoBruzzone <[email protected]>

Author: FedericoBruzzone

compiler/rustc_middle/src/query/erase.rs

@@ -164,6 +164,11 @@ impl EraseType for Result<ty::EarlyBinder<'_, Ty<'_>>, CyclePlaceholder> {
     type Result = [u8; size_of::<Result<ty::EarlyBinder<'static, Ty<'_>>, CyclePlaceholder>>()];
 }
 
+impl<T> EraseType for Result<(&'_ [T], &'_ [T]), rustc_errors::ErrorGuaranteed> {
+    type Result =
+        [u8; size_of::<Result<(&'static [()], &'static [()]), rustc_errors::ErrorGuaranteed>>()];
+}
+
 impl<T> EraseType for Option<&'_ T> {
     type Result = [u8; size_of::<Option<&'static ()>>()];
 }

compiler/rustc_middle/src/query/mod.rs

@@ -2490,7 +2490,12 @@ rustc_queries! {
         desc { "functions to skip for move-size check" }
     }
 
-    query items_of_instance(key: (ty::Instance<'tcx>, CollectionMode)) -> (&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]) {
+    query items_of_instance(
+        key: (ty::Instance<'tcx>, CollectionMode)
+    ) -> Result<
+        (&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]),
+        ErrorGuaranteed
+    > {
         desc { "collecting items used by `{}`", key.0 }
         cache_on_disk_if { true }
     }

compiler/rustc_monomorphize/src/collector.rs

@@ -206,6 +206,7 @@
 //! regardless of whether it is actually needed or not.
 
 use std::path::PathBuf;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 use rustc_attr_parsing::InlineAttr;
 use rustc_data_structures::fx::FxIndexMap;
@@ -233,10 +234,12 @@ use rustc_middle::{bug, span_bug};
 use rustc_session::Limit;
 use rustc_session::config::EntryFnType;
 use rustc_span::source_map::{Spanned, dummy_spanned, respan};
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 use tracing::{debug, instrument, trace};
 
-use crate::errors::{self, EncounteredErrorWhileInstantiating, NoOptimizedMir, RecursionLimit};
+use crate::errors::{
+    self, EncounteredErrorWhileInstantiating, MAX_NUMBER_OF_ERRORS, NoOptimizedMir, RecursionLimit,
+};
 
 #[derive(PartialEq)]
 pub(crate) enum MonoItemCollectionStrategy {
@@ -253,6 +256,8 @@ struct SharedState<'tcx> {
     mentioned: MTLock<UnordSet<MonoItem<'tcx>>>,
     /// Which items are being used where, for better errors.
     usage_map: MTLock<UsageMap<'tcx>>,
+    /// Number of errors that have occurred during collection.
+    error_count: AtomicUsize,
 }
 
 pub(crate) struct UsageMap<'tcx> {
@@ -362,6 +367,16 @@ fn collect_items_rec<'tcx>(
     recursion_limit: Limit,
     mode: CollectionMode,
 ) {
+    if state.error_count.load(Ordering::Relaxed) > MAX_NUMBER_OF_ERRORS {
+        tcx.dcx().span_fatal(
+            starting_item.span,
+            format!(
+                "the limit of {} errors has been reached during monomorphization",
+                MAX_NUMBER_OF_ERRORS
+            ),
+        );
+    }
+
     if mode == CollectionMode::UsedItems {
         if !state.visited.lock_mut().insert(starting_item.node) {
             // We've been here already, no need to search again.
@@ -466,9 +481,15 @@ fn collect_items_rec<'tcx>(
             ));
 
             rustc_data_structures::stack::ensure_sufficient_stack(|| {
-                let (used, mentioned) = tcx.items_of_instance((instance, mode));
-                used_items.extend(used.into_iter().copied());
-                mentioned_items.extend(mentioned.into_iter().copied());
+                match tcx.items_of_instance((instance, mode)) {
+                    Ok((used, mentioned)) => {
+                        used_items.extend(used.into_iter().copied());
+                        mentioned_items.extend(mentioned.into_iter().copied());
+                    }
+                    Err(_) => {
+                        state.error_count.fetch_add(1, Ordering::Relaxed);
+                    }
+                };
             });
         }
         MonoItem::GlobalAsm(item_id) => {
@@ -660,7 +681,7 @@ impl<'a, 'tcx> MirUsedCollector<'a, 'tcx> {
             ),
             Err(err @ ErrorHandled::Reported(..)) => {
                 err.emit_note(self.tcx);
-                return None;
+                None
             }
         }
     }
@@ -1211,7 +1232,7 @@ fn collect_items_of_instance<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: Instance<'tcx>,
     mode: CollectionMode,
-) -> (MonoItems<'tcx>, MonoItems<'tcx>) {
+) -> Result<(MonoItems<'tcx>, MonoItems<'tcx>), ErrorGuaranteed> {
     // This item is getting monomorphized, do mono-time checks.
     tcx.ensure().check_mono_item(instance);
 
@@ -1245,9 +1266,12 @@ fn collect_items_of_instance<'tcx>(
 
     // Always visit all `required_consts`, so that we evaluate them and abort compilation if any of
     // them errors.
+    let mut error_occurred = false;
     for const_op in body.required_consts() {
         if let Some(val) = collector.eval_constant(const_op) {
             collect_const_value(tcx, val, &mut mentioned_items);
+        } else {
+            error_occurred = true;
         }
     }
 
@@ -1260,19 +1284,25 @@ fn collect_items_of_instance<'tcx>(
         }
     }
 
-    (used_items, mentioned_items)
+    if error_occurred {
+        let def_span = tcx.def_span(instance.def_id());
+        let err = tcx.dcx().span_delayed_bug(def_span, "constant evaluation error");
+        return Err(err);
+    }
+
+    Ok((used_items, mentioned_items))
 }
 
 fn items_of_instance<'tcx>(
     tcx: TyCtxt<'tcx>,
     (instance, mode): (Instance<'tcx>, CollectionMode),
-) -> (&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]) {
-    let (used_items, mentioned_items) = collect_items_of_instance(tcx, instance, mode);
+) -> Result<(&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]), ErrorGuaranteed> {
+    let (used_items, mentioned_items) = collect_items_of_instance(tcx, instance, mode)?;
 
     let used_items = tcx.arena.alloc_from_iter(used_items);
     let mentioned_items = tcx.arena.alloc_from_iter(mentioned_items);
 
-    (used_items, mentioned_items)
+    Ok((used_items, mentioned_items))
 }
 
 /// `item` must be already monomorphized.
@@ -1651,6 +1681,7 @@ pub(crate) fn collect_crate_mono_items<'tcx>(
         visited: MTLock::new(UnordSet::default()),
         mentioned: MTLock::new(UnordSet::default()),
         usage_map: MTLock::new(UsageMap::new()),
+        error_count: AtomicUsize::new(0),
     };
     let recursion_limit = tcx.recursion_limit();
 

compiler/rustc_monomorphize/src/errors.rs

@@ -3,6 +3,8 @@ use std::path::PathBuf;
 use rustc_macros::{Diagnostic, LintDiagnostic};
 use rustc_span::{Span, Symbol};
 
+pub(crate) const MAX_NUMBER_OF_ERRORS: usize = 100;
+
 #[derive(Diagnostic)]
 #[diag(monomorphize_recursion_limit)]
 pub(crate) struct RecursionLimit {

tests/ui/polymorphic-const-2-issue-105249.rs

@@ -0,0 +1,18 @@
+//@ check-pass
+
+fn pass_to_ptr_call<T>(f: fn(T), x: T) {
+    f(x);
+}
+
+trait TrackedTrait {
+    fn trait_tracked_unit_default(_: ()) {
+        let location = std::panic::Location::caller();
+        assert_eq!(location.file(), file!());
+    }
+}
+
+impl TrackedTrait for () {}
+
+fn main() {
+    pass_to_ptr_call(<() as TrackedTrait>::trait_tracked_unit_default, ());
+}

tests/ui/polymorphic-const-issue-105249.rs

@@ -0,0 +1,15 @@
+//@ check-pass
+
+trait Foo<T> {
+    fn print<'a>(&'a self) where T: 'a { println!("foo"); }
+}
+
+impl<'a> Foo<&'a ()> for () { }
+
+trait Bar: for<'a> Foo<&'a ()> { }
+
+impl Bar for () {}
+
+fn main() {
+    (&() as &dyn Bar).print();
+}

tests/ui/print-mono-items-issue-105249.rs

@@ -0,0 +1,16 @@
+//@ check-pass
+
+// When -Zprint-mono-items=eager option was used, the following
+// code previously caused an ICE.
+
+pub struct S();
+
+pub trait X {
+    fn unused3(var: i32) {
+        println!("{}", var);
+    }
+}
+
+impl X for S {}
+
+fn main() {}

tests/crashes/114484.rs renamed to tests/ui/too-errors-monomorphization-collector-issue-114484.rs

@@ -1,4 +1,12 @@
-//@ known-bug: #114484
+// Avoiding using `don't-check-compiler-stderr` the compiletest tool
+// emit `TRUNCATED, SHOWING THE FIRST {} BYTES` because the error message
+// is too long.
+
+//@ build-fail
+//@ dont-check-compiler-stderr
+//@ error-pattern: reached the recursion limit finding the struct tail for `[u8; 256]`
+//@ error-pattern: as Pointee>::Metadata` has an unknown layout
+
 use std::marker::PhantomData;
 
 trait MyTrait {
@@ -16,7 +24,7 @@ impl<T, const L: u8> VirtualWrapper<T, L> {
 impl<T: MyTrait + 'static, const L: u8> MyTrait for VirtualWrapper<T, L> {
     fn virtualize(&self) -> &dyn MyTrait {
         unsafe { virtualize_my_trait(L, self) }
-        // unsafe { virtualize_my_trait(L, &self.0) }    // <-- this code fixes the problem
+        // unsafe { virtualize_my_trait(L, &self.0) } // <-- this code fixes the problem
     }
 }