check normalization overflow in monomorphization

Author: adwinwhite

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 }

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,19 @@ 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);
+    instance
+        .try_instantiate_mir_and_normalize_erasing_regions(
+            tcx,
+            ty::TypingEnv::fully_monomorphized(),
+            ty::EarlyBinder::bind(body),
+        )
+        .is_err()
+}
+
 fn check_recursion_limit<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: Instance<'tcx>,
@@ -1770,4 +1800,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;
 }