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

@@ -1112,7 +1112,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

@@ -1663,7 +1663,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

@@ -1002,6 +1002,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)]
@@ -1055,7 +1066,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
@@ -1066,16 +1087,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,10 +105,8 @@ 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_and_anonymize_regions(self.typing_env)
-            .with_post_analysis_normalized(self.tcx);
+        let typing_env =
+            self.tcx.erase_and_anonymize_regions(self.typing_env).with_codegen_normalized(self.tcx);
         let uv = self.tcx.erase_and_anonymize_regions(uv);
 
         // try to resolve e.g. associated constants to their definition on an impl, and then

compiler/rustc_ty_utils/src/layout.rs

@@ -498,6 +498,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)?;
@@ -637,7 +648,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

@@ -285,8 +285,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.
@@ -402,7 +402,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,

tests/crashes/120016.rs

@@ -1,5 +1,4 @@
 //@ known-bug: #120016
-//@ compile-flags: -Zcrate-attr=feature(const_async_blocks)
 //@ edition: 2021
 
 #![feature(type_alias_impl_trait, const_async_blocks)]

tests/crashes/137916.rs renamed to tests/ui/async-await/box-dyn-non-send.rs

@@ -1,9 +1,11 @@
-//@ known-bug: #137916
+//! Regression test for ICE #137916.
 //@ edition: 2021
+
 use std::ptr::null;
 
 async fn a() -> Box<dyn Send> {
     Box::new(async {
+        //~^ ERROR future cannot be sent between threads safely
         let non_send = null::<()>();
         &non_send;
         async {}.await

tests/ui/async-await/box-dyn-non-send.stderr

@@ -0,0 +1,24 @@
+error: future cannot be sent between threads safely
+  --> $DIR/box-dyn-non-send.rs:7:5
+   |
+LL | /     Box::new(async {
+LL | |
+LL | |         let non_send = null::<()>();
+LL | |         &non_send;
+LL | |         async {}.await
+LL | |     })
+   | |______^ future created by async block is not `Send`
+   |
+   = help: within `{async block@$DIR/box-dyn-non-send.rs:7:14: 7:19}`, the trait `Send` is not implemented for `*const ()`
+note: future is not `Send` as this value is used across an await
+  --> $DIR/box-dyn-non-send.rs:11:18
+   |
+LL |         let non_send = null::<()>();
+   |             -------- has type `*const ()` which is not `Send`
+LL |         &non_send;
+LL |         async {}.await
+   |                  ^^^^^ await occurs here, with `non_send` maybe used later
+   = note: required for the cast from `Box<{async block@$DIR/box-dyn-non-send.rs:7:14: 7:19}>` to `Box<dyn Send>`
+
+error: aborting due to 1 previous error
+