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,10 +206,11 @@
 //! regardless of whether it is actually needed or not.
 
 use std::path::PathBuf;
+use std::sync::atomic::Ordering;
 
 use rustc_attr_parsing::InlineAttr;
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_data_structures::sync::{LRef, MTLock, par_for_each_in};
+use rustc_data_structures::sync::{AtomicU32, LRef, MTLock, par_for_each_in};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
@@ -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: AtomicU32,
 }
 
 pub(crate) struct UsageMap<'tcx> {
@@ -466,9 +471,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) => {
@@ -527,6 +538,15 @@ fn collect_items_rec<'tcx>(
             span: starting_item.span,
             formatted_item,
         });
+        if state.error_count.load(Ordering::Relaxed) > MAX_NUMBER_OF_ERRORS {
+            tcx.dcx().span_fatal(
+                starting_item.span,
+                format!(
+                    "aborting after reaching the limit of {} errors during monomorphization",
+                    MAX_NUMBER_OF_ERRORS
+                ),
+            );
+        }
     }
     // Only updating `usage_map` for used items as otherwise we may be inserting the same item
     // multiple times (if it is first 'mentioned' and then later actuall used), and the usage map
@@ -626,6 +646,8 @@ struct MirUsedCollector<'a, 'tcx> {
     /// Note that this contains *not-monomorphized* items!
     used_mentioned_items: &'a mut UnordSet<MentionedItem<'tcx>>,
     instance: Instance<'tcx>,
+    /// If an error is encountered during const evaluation.
+    tained_by_errors: Option<ErrorGuaranteed>,
 }
 
 impl<'a, 'tcx> MirUsedCollector<'a, 'tcx> {
@@ -658,9 +680,10 @@ impl<'a, 'tcx> MirUsedCollector<'a, 'tcx> {
                 "collection encountered polymorphic constant: {:?}",
                 const_
             ),
-            Err(err @ ErrorHandled::Reported(..)) => {
+            Err(err @ ErrorHandled::Reported(reported, _)) => {
                 err.emit_note(self.tcx);
-                return None;
+                self.tained_by_errors = Some(reported.into());
+                None
             }
         }
     }
@@ -1211,7 +1234,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);
 
@@ -1235,6 +1258,7 @@ fn collect_items_of_instance<'tcx>(
         used_items: &mut used_items,
         used_mentioned_items: &mut used_mentioned_items,
         instance,
+        tained_by_errors: None,
     };
 
     if mode == CollectionMode::UsedItems {
@@ -1260,19 +1284,23 @@ fn collect_items_of_instance<'tcx>(
         }
     }
 
-    (used_items, mentioned_items)
+    if let Some(err) = collector.tained_by_errors {
+        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 +1679,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: AtomicU32::new(0),
     };
     let recursion_limit = tcx.recursion_limit();
 

compiler/rustc_monomorphize/src/errors.rs

@@ -3,6 +3,16 @@ use std::path::PathBuf;
 use rustc_macros::{Diagnostic, LintDiagnostic};
 use rustc_span::{Span, Symbol};
 
+// This constant should be used to limit the number of post-monomorphization
+// errors that are emitted during the monomorphization process preventing the
+// process from emitting too many errors, which could cause the process to
+// hang indefinitely.
+//
+// It is set to 10 because it is a reasonable number of
+// post-monomorphization errors to emit before stopping
+// the process.
+pub(crate) const MAX_NUMBER_OF_ERRORS: u32 = 10;
+
 #[derive(Diagnostic)]
 #[diag(monomorphize_recursion_limit)]
 pub(crate) struct RecursionLimit {

src/librustdoc/html/templates/type_layout.html

@@ -28,13 +28,15 @@ <h2 id="layout" class="section-header"> {# #}
         {% endfor %}
     </ul>
     {% endif %}
-    {# This kind of layout error can occur with valid code, e.g. if you try to
-    get the layout of a generic type such as `Vec<T>`. #}
+        {# This kind of layout error can occur with valid code.
+        It can happen for various reasons, e.g., if you try to get
+        the layout of an array with a length that is not a constant
+        and it has not a generic parameter such as
+        `[(); size_of::<<() as Trait>::Assoc>()]`. #}
         {% when Err(LayoutError::Unknown(_)) %}
         <p> {# #}
-            <strong>Note:</strong> Unable to compute type layout, {#+ #}
-            possibly due to this type having generic parameters. {#+ #}
-            Layout can only be computed for concrete, fully-instantiated types. {# #}
+            <strong>Note:</strong> Unable to compute type layout. {#+ #}
+            It can happen for various reasons. {# #}
         </p>
         {# This kind of error probably can't happen with valid code, but we don't
         want to panic and prevent the docs from building, so we just let the
@@ -44,13 +46,13 @@ <h2 id="layout" class="section-header"> {# #}
             <strong>Note:</strong> Encountered an error during type layout; {#+ #}
             the type was too big. {# #}
         </p>
-        {# This kind of error probably can't happen with valid code, but we don't
-        want to panic and prevent the docs from building, so we just let the
-        user know that we couldn't compute the layout. #}
+        {# This kind of layout error can occur with valid code, e.g. if you try to
+        get the layout of a generic type such as `Vec<T>`. #}
         {% when Err(LayoutError::TooGeneric(_)) %}
         <p> {# #}
-            <strong>Note:</strong> Encountered an error during type layout; {#+ #}
-            the type was too generic. {# #}
+            <strong>Note:</strong> Unable to compute type layout, {#+ #}
+            possibly due to this type having generic parameters. {#+ #}
+            Layout can only be computed for concrete, fully-instantiated types. {# #}
         </p>
         {% when Err(LayoutError::ReferencesError(_)) %}
         <p> {# #}

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,5 @@
-//@ known-bug: #114484
+//@ build-fail
+
 use std::marker::PhantomData;
 
 trait MyTrait {
@@ -15,8 +16,8 @@ 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) } //~ ERROR aborting after reaching the limit of 10 errors during monomorphization
+        // unsafe { virtualize_my_trait(L, &self.0) } // <-- this code fixes the problem
     }
 }