Move logic to mono_checks

Author: saethlin

compiler/rustc_monomorphize/src/collector.rs

@@ -208,7 +208,6 @@
 mod autodiff;
 
 use std::cell::OnceCell;
-use std::ops::ControlFlow;
 
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sync::{MTLock, par_for_each_in};
@@ -229,7 +228,7 @@ use rustc_middle::ty::adjustment::{CustomCoerceUnsized, PointerCoercion};
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::{
     self, GenericArgs, GenericParamDefKind, Instance, InstanceKind, Ty, TyCtxt, TypeFoldable,
-    TypeVisitable, TypeVisitableExt, TypeVisitor, VtblEntry,
+    TypeVisitableExt, VtblEntry,
 };
 use rustc_middle::util::Providers;
 use rustc_middle::{bug, span_bug};
@@ -474,23 +473,6 @@ 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());
@@ -621,33 +603,6 @@ 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 {
-    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(()),
-            }
-        }
-    }
-
-    let body = tcx.instance_mir(instance.def);
-    let mut checker = NormalizationChecker { tcx, instance };
-    body.visit_with(&mut checker).is_break()
-}
-
 fn check_recursion_limit<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: Instance<'tcx>,
@@ -1815,5 +1770,4 @@ 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_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);
 }

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 });
+    }
+}