Feed HIR for by-move coroutine body def, since the inliner tries to read its attrs

Author: compiler-errors

compiler/rustc_mir_transform/src/coroutine/by_move_body.rs

@@ -219,6 +219,8 @@ pub(crate) fn coroutine_by_move_body_def_id<'tcx>(
         mir::MirSource::from_instance(InstanceKind::Item(body_def.def_id().to_def_id()));
     dump_mir(tcx, false, "built", &"after", &by_move_body, |_, _| Ok(()));
 
+    // Feed HIR because we try to access this body's attrs in the inliner.
+    body_def.feed_hir();
     // Inherited from the by-ref coroutine.
     body_def.codegen_fn_attrs(tcx.codegen_fn_attrs(coroutine_def_id).clone());
     body_def.coverage_attr_on(tcx.coverage_attr_on(coroutine_def_id));

tests/ui/async-await/async-closures/by-move-body-inlined-attrs.rs

@@ -0,0 +1,28 @@
+//@ check-pass
+//@ compile-flags: -Zinline-mir -Zvalidate-mir
+//@ edition: 2024
+
+// See comment below.
+
+use std::future::Future;
+use std::pin::pin;
+use std::task::{Context, Waker};
+
+fn call_once<T>(f: impl FnOnce() -> T) -> T { f() }
+
+fn main() {
+    let x = async || {};
+    // We first inline `call_once<{async closure}>`.
+    //
+    // This gives us a future whose type is the "FnOnce" flavor of the async closure's
+    // child coroutine. The body of this coroutine is synthetic, which we synthesize in
+    // the by-move body query.
+    let fut = pin!(call_once(x));
+    // We then try to inline that body in this poll call.
+    //
+    // The inliner does some inlinability checks; one of these checks involves checking
+    // the body for the `#[rustc_no_mir_inline]` attribute. Since the synthetic body had
+    // no HIR synthesized, but it's still a local def id, we end up ICEing in the
+    // `local_def_id_to_hir_id` call when trying to read its attrs.
+    fut.poll(&mut Context::from_waker(Waker::noop()));
+}