Do not compute coroutine layout in non-Codegen typing mode.

Author: cjgillot

compiler/rustc_hir_typeck/src/intrinsicck.rs

@@ -147,7 +147,7 @@ pub(crate) fn check_transmutes(tcx: TyCtxt<'_>, owner: LocalDefId) {
     let typeck_results = tcx.typeck(owner);
     let None = typeck_results.tainted_by_errors else { return };
 
-    let typing_env = ty::TypingEnv::post_analysis(tcx, owner);
+    let typing_env = ty::TypingEnv::codegen(tcx, owner);
     for &(from, to, hir_id) in &typeck_results.transmutes_to_check {
         check_transmute(tcx, typing_env, from, to, hir_id);
     }

compiler/rustc_interface/src/passes.rs

@@ -1102,7 +1102,7 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
                 if !tcx.is_async_drop_in_place_coroutine(def_id.to_def_id()) {
                     // Eagerly check the unsubstituted layout for cycles.
                     tcx.ensure_ok().layout_of(
-                        ty::TypingEnv::post_analysis(tcx, def_id.to_def_id())
+                        ty::TypingEnv::codegen(tcx, def_id.to_def_id())
                             .as_query_input(tcx.type_of(def_id).instantiate_identity()),
                     );
                 }

compiler/rustc_middle/src/query/mod.rs

@@ -1645,7 +1645,7 @@ rustc_queries! {
     /// Like `param_env`, but returns the `ParamEnv` after all opaque types have been
     /// replaced with their hidden type. This is used in the old trait solver
     /// when in `PostAnalysis` mode and should not be called directly.
-    query typing_env_normalized_for_post_analysis(def_id: DefId) -> ty::TypingEnv<'tcx> {
+    query param_env_normalized_for_post_analysis(def_id: DefId) -> ty::ParamEnv<'tcx> {
         desc { |tcx| "computing revealed normalized predicates of `{}`", tcx.def_path_str(def_id) }
     }
 

compiler/rustc_middle/src/ty/mod.rs

@@ -1009,6 +1009,17 @@ impl<'tcx> ParamEnv<'tcx> {
     pub fn and<T: TypeVisitable<TyCtxt<'tcx>>>(self, value: T) -> ParamEnvAnd<'tcx, T> {
         ParamEnvAnd { param_env: self, value }
     }
+
+    /// Eagerly reveal all opaque types in the `param_env`.
+    pub fn with_normalized(self, tcx: TyCtxt<'tcx>) -> ParamEnv<'tcx> {
+        // No need to reveal opaques with the new solver enabled,
+        // since we have lazy norm.
+        if tcx.next_trait_solver_globally() {
+            self
+        } else {
+            ParamEnv::new(tcx.reveal_opaque_types_in_bounds(self.caller_bounds))
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable)]
@@ -1062,7 +1073,17 @@ impl<'tcx> TypingEnv<'tcx> {
     }
 
     pub fn post_analysis(tcx: TyCtxt<'tcx>, def_id: impl IntoQueryParam<DefId>) -> TypingEnv<'tcx> {
-        tcx.typing_env_normalized_for_post_analysis(def_id)
+        TypingEnv {
+            typing_mode: TypingMode::PostAnalysis,
+            param_env: tcx.param_env_normalized_for_post_analysis(def_id),
+        }
+    }
+
+    pub fn codegen(tcx: TyCtxt<'tcx>, def_id: impl IntoQueryParam<DefId>) -> TypingEnv<'tcx> {
+        TypingEnv {
+            typing_mode: TypingMode::Codegen,
+            param_env: tcx.param_env_normalized_for_post_analysis(def_id),
+        }
     }
 
     /// Modify the `typing_mode` to `PostAnalysis` or `Codegen` and eagerly reveal all opaque types
@@ -1073,16 +1094,22 @@ impl<'tcx> TypingEnv<'tcx> {
             return self;
         }
 
-        // No need to reveal opaques with the new solver enabled,
-        // since we have lazy norm.
-        let param_env = if tcx.next_trait_solver_globally() {
-            param_env
-        } else {
-            ParamEnv::new(tcx.reveal_opaque_types_in_bounds(param_env.caller_bounds()))
-        };
+        let param_env = param_env.with_normalized(tcx);
         TypingEnv { typing_mode: TypingMode::PostAnalysis, param_env }
     }
 
+    /// Modify the `typing_mode` to `PostAnalysis` or `Codegen` and eagerly reveal all opaque types
+    /// in the `param_env`.
+    pub fn with_codegen_normalized(self, tcx: TyCtxt<'tcx>) -> TypingEnv<'tcx> {
+        let TypingEnv { typing_mode, param_env } = self;
+        if let TypingMode::Codegen = typing_mode {
+            return self;
+        }
+
+        let param_env = param_env.with_normalized(tcx);
+        TypingEnv { typing_mode: TypingMode::Codegen, param_env }
+    }
+
     /// Combine this typing environment with the given `value` to be used by
     /// not (yet) canonicalized queries. This only works if the value does not
     /// contain anything local to some `InferCtxt`, i.e. inference variables or

compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs

@@ -105,8 +105,7 @@ impl<'tcx> ConstToPat<'tcx> {
         //
         // FIXME: `const_eval_resolve_for_typeck` should probably just modify the env itself
         // instead of having this logic here
-        let typing_env =
-            self.tcx.erase_regions(self.typing_env).with_post_analysis_normalized(self.tcx);
+        let typing_env = self.tcx.erase_regions(self.typing_env).with_codegen_normalized(self.tcx);
         let uv = self.tcx.erase_regions(uv);
 
         // try to resolve e.g. associated constants to their definition on an impl, and then

compiler/rustc_ty_utils/src/layout.rs

@@ -482,6 +482,17 @@ fn layout_of_uncached<'tcx>(
         }
 
         ty::Coroutine(def_id, args) => {
+            match cx.typing_env.typing_mode {
+                ty::TypingMode::Codegen => {}
+                ty::TypingMode::Coherence
+                | ty::TypingMode::Analysis { .. }
+                | ty::TypingMode::Borrowck { .. }
+                | ty::TypingMode::PostBorrowckAnalysis { .. }
+                | ty::TypingMode::PostAnalysis => {
+                    return Err(error(cx, LayoutError::TooGeneric(ty)));
+                }
+            }
+
             use rustc_middle::ty::layout::PrimitiveExt as _;
 
             let info = tcx.coroutine_layout(def_id, args)?;
@@ -605,7 +616,10 @@ fn layout_of_uncached<'tcx>(
 
             let maybe_unsized = def.is_struct()
                 && def.non_enum_variant().tail_opt().is_some_and(|last_field| {
-                    let typing_env = ty::TypingEnv::post_analysis(tcx, def.did());
+                    let typing_env = ty::TypingEnv {
+                        typing_mode: cx.typing_env.typing_mode,
+                        param_env: tcx.param_env_normalized_for_post_analysis(def.did()),
+                    };
                     !tcx.type_of(last_field.did).instantiate_identity().is_sized(tcx, typing_env)
                 });
 

compiler/rustc_ty_utils/src/ty.rs

@@ -278,8 +278,8 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ImplTraitInTraitFinder<'_, 'tcx> {
     }
 }
 
-fn typing_env_normalized_for_post_analysis(tcx: TyCtxt<'_>, def_id: DefId) -> ty::TypingEnv<'_> {
-    ty::TypingEnv::non_body_analysis(tcx, def_id).with_post_analysis_normalized(tcx)
+fn param_env_normalized_for_post_analysis(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ParamEnv<'_> {
+    tcx.param_env(def_id).with_normalized(tcx)
 }
 
 /// Check if a function is async.
@@ -394,7 +394,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         asyncness,
         adt_sizedness_constraint,
         param_env,
-        typing_env_normalized_for_post_analysis,
+        param_env_normalized_for_post_analysis,
         defaultness,
         unsizing_params_for_adt,
         impl_self_is_guaranteed_unsized,