Change how coroutine layout is dumped in MIR.

cjgillot · cjgillot · commit d332a1249cf0 · 2026-05-29T20:11:32.000Z
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -15,6 +15,7 @@ use crate::mir::interpret::{
 };
 use crate::mir::visit::Visitor;
 use crate::mir::*;
+use crate::ty::CoroutineArgsExt;
 
 const INDENT: &str = "    ";
 /// Alignment for lining up comments following MIR statements
@@ -185,9 +186,6 @@ impl<'a, 'tcx> MirDumper<'a, 'tcx> {
             Some(promoted) => write!(w, "::{promoted:?}`")?,
         }
         writeln!(w, " {} {}", self.disambiguator, self.pass_name)?;
-        if let Some(ref layout) = body.coroutine_layout_raw() {
-            writeln!(w, "/* coroutine_layout = {layout:#?} */")?;
-        }
         writeln!(w)?;
         (self.writer.extra_data)(PassWhere::BeforeCFG, w)?;
         write_user_type_annotations(self.tcx(), body, w)?;
@@ -429,6 +427,31 @@ fn write_scope_tree(
         }
     }
 
+    // Coroutine debuginfo.
+    if let Some(layout) = body.coroutine_layout_raw() {
+        for (field, name) in layout.field_names.iter_enumerated() {
+            if let Some(name) = name
+                && let source_info = layout.field_tys[field].source_info
+                && source_info.scope == parent
+            {
+                let indented_debug_info =
+                    format!("{0:1$}coroutine debug {2} => {3:?};", INDENT, indent, name, field);
+
+                if options.include_extra_comments {
+                    writeln!(
+                        w,
+                        "{0:1$} // in {2}",
+                        indented_debug_info,
+                        ALIGN,
+                        comment(tcx, source_info),
+                    )?;
+                } else {
+                    writeln!(w, "{indented_debug_info}")?;
+                }
+            }
+        }
+    }
+
     // Local variable types.
     for (local, local_decl) in body.local_decls.iter_enumerated() {
         if (1..body.arg_count + 1).contains(&local.index()) {
@@ -530,6 +553,50 @@ impl Debug for VarDebugInfo<'_> {
     }
 }
 
+fn write_coroutine_layout<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    layout: &CoroutineLayout<'_>,
+    w: &mut dyn io::Write,
+    options: PrettyPrintMirOptions,
+) -> io::Result<()> {
+    let CoroutineLayout {
+        field_tys,
+        field_names: _, // Dumped in scope tree with debug info.
+        variant_fields,
+        variant_source_info,
+        storage_conflicts,
+    } = layout;
+
+    writeln!(w, "{INDENT}coroutine layout {{")?;
+
+    for (field, CoroutineSavedTy { ty, source_info, ignore_for_traits }) in
+        field_tys.iter_enumerated()
+    {
+        let ignore_for_traits = if *ignore_for_traits { " (ignored for traits)" } else { "" };
+        let indented_body = format!("{INDENT}{INDENT}field {field:?}: {ty}{ignore_for_traits};",);
+        if options.include_extra_comments {
+            writeln!(w, "{0:ALIGN$} // in {1}", indented_body, comment(tcx, *source_info))?;
+        } else {
+            writeln!(w, "{}", indented_body)?;
+        }
+    }
+
+    writeln!(w, "{INDENT}{INDENT}variant_fields = {{")?;
+    for (variant, fields) in variant_fields.iter_enumerated() {
+        let variant_name = ty::CoroutineArgs::variant_name(variant);
+        let header = format!("{INDENT}{INDENT}{INDENT}{variant_name:9}({variant:?}): {fields:?},");
+        if options.include_extra_comments {
+            let source_info = variant_source_info[variant];
+            writeln!(w, "{0:ALIGN$} // in {1}", header, comment(tcx, source_info))?;
+        } else {
+            writeln!(w, "{}", header)?;
+        }
+    }
+    writeln!(w, "{INDENT}{INDENT}}}")?;
+    writeln!(w, "{INDENT}{INDENT}storage_conflicts = {storage_conflicts:?}")?;
+    writeln!(w, "{INDENT}}}")
+}
+
 /// Write out a human-readable textual representation of the MIR's `fn` type and the types of its
 /// local variables (both user-defined bindings and compiler temporaries).
 fn write_mir_intro<'tcx>(
@@ -541,6 +608,10 @@ fn write_mir_intro<'tcx>(
     write_mir_sig(tcx, body, w)?;
     writeln!(w, "{{")?;
 
+    if let Some(ref layout) = body.coroutine_layout_raw() {
+        write_coroutine_layout(tcx, layout, w, options)?;
+    }
+
     // construct a scope tree and write it out
     let mut scope_tree: FxHashMap<SourceScope, Vec<SourceScope>> = Default::default();
     for (index, scope_data) in body.source_scopes.iter_enumerated() {
diff --git a/tests/mir-opt/coroutine/async_await.a-{closure#0}.coroutine_resume.0.mir b/tests/mir-opt/coroutine/async_await.a-{closure#0}.coroutine_resume.0.mir
@@ -1,15 +1,14 @@
 // MIR for `a::{closure#0}` 0 coroutine_resume
-/* coroutine_layout = CoroutineLayout {
-    field_tys: {},
-    variant_fields: {
-        Unresumed(0): [],
-        Returned (1): [],
-        Panicked (2): [],
-    },
-    storage_conflicts: BitMatrix(0x0) {},
-} */
 
 fn a::{closure#0}(_1: Pin<&mut {async fn body of a()}>, _2: &mut Context<'_>) -> Poll<()> {
+    coroutine layout {
+        variant_fields = {
+            Unresumed(0): [],
+            Returned (1): [],
+            Panicked (2): [],
+        }
+        storage_conflicts = BitMatrix(0x0) {}
+    }
     debug _task_context => _2;
     let mut _0: std::task::Poll<()>;
     let mut _3: ();
diff --git a/tests/mir-opt/coroutine/async_await.b-{closure#0}.coroutine_resume.0.mir b/tests/mir-opt/coroutine/async_await.b-{closure#0}.coroutine_resume.0.mir
@@ -1,56 +1,21 @@
 // MIR for `b::{closure#0}` 0 coroutine_resume
-/* coroutine_layout = CoroutineLayout {
-    field_tys: {
-        _s0: CoroutineSavedTy {
-            ty: Coroutine(
-                DefId(0:5 ~ async_await[ccf8]::a::{closure#0}),
-                [
-                    (),
-                    std::future::ResumeTy,
-                    (),
-                    (),
-                    (),
-                ],
-            ),
-            source_info: SourceInfo {
-                span: $DIR/async_await.rs:27:5: 27:14 (#9),
-                scope: scope[0],
-            },
-            ignore_for_traits: false,
-        },
-        _s1: CoroutineSavedTy {
-            ty: Coroutine(
-                DefId(0:5 ~ async_await[ccf8]::a::{closure#0}),
-                [
-                    (),
-                    std::future::ResumeTy,
-                    (),
-                    (),
-                    (),
-                ],
-            ),
-            source_info: SourceInfo {
-                span: $DIR/async_await.rs:28:5: 28:14 (#11),
-                scope: scope[0],
-            },
-            ignore_for_traits: false,
-        },
-    },
-    variant_fields: {
-        Unresumed(0): [],
-        Returned (1): [],
-        Panicked (2): [],
-        Suspend0 (3): [_s0],
-        Suspend1 (4): [_s1],
-    },
-    storage_conflicts: BitMatrix(2x2) {
-        (_s0, _s0),
-        (_s1, _s1),
-    },
-} */
 
 fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) -> Poll<()> {
+    coroutine layout {
+        field _s0: {async fn body of a()};
+        field _s1: {async fn body of a()};
+        variant_fields = {
+            Unresumed(0): [],
+            Returned (1): [],
+            Panicked (2): [],
+            Suspend0 (3): [_s0],
+            Suspend1 (4): [_s1],
+        }
+        storage_conflicts = BitMatrix(2x2) {(_s0, _s0), (_s1, _s1)}
+    }
     debug _task_context => _2;
+    coroutine debug __awaitee => _s0;
+    coroutine debug __awaitee => _s1;
     let mut _0: std::task::Poll<()>;
     let _3: ();
     let mut _4: {async fn body of a()};
diff --git a/tests/mir-opt/coroutine/coroutine.main-{closure#0}.StateTransform.after.mir b/tests/mir-opt/coroutine/coroutine.main-{closure#0}.StateTransform.after.mir
@@ -1,29 +1,19 @@
 // MIR for `main::{closure#0}` after StateTransform
-/* coroutine_layout = CoroutineLayout {
-    field_tys: {
-        _s0: CoroutineSavedTy {
-            ty: std::string::String,
-            source_info: SourceInfo {
-                span: $DIR/coroutine.rs:19:6: 19:9 (#0),
-                scope: scope[0],
-            },
-            ignore_for_traits: false,
-        },
-    },
-    variant_fields: {
-        Unresumed(0): [],
-        Returned (1): [],
-        Panicked (2): [],
-        Suspend0 (3): [_s0],
-        Suspend1 (4): [_s0],
-    },
-    storage_conflicts: BitMatrix(1x1) {
-        (_s0, _s0),
-    },
-} */
 
 fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:19:5: 19:18}>, _2: String) -> CoroutineState<(&str, String, &Location<'_>), ()> {
+    coroutine layout {
+        field _s0: String;
+        variant_fields = {
+            Unresumed(0): [],
+            Returned (1): [],
+            Panicked (2): [],
+            Suspend0 (3): [_s0],
+            Suspend1 (4): [_s0],
+        }
+        storage_conflicts = BitMatrix(1x1) {(_s0, _s0)}
+    }
     debug arg => (((*_18) as variant#4).0: std::string::String);
+    coroutine debug arg => _s0;
     let mut _0: std::ops::CoroutineState<(&str, std::string::String, &std::panic::Location<'_>), ()>;
     let _3: std::string::String;
     let mut _4: (&str, std::string::String, &std::panic::Location<'_>);
diff --git a/tests/mir-opt/coroutine/coroutine.main-{closure#1}.StateTransform.after.mir b/tests/mir-opt/coroutine/coroutine.main-{closure#1}.StateTransform.after.mir
@@ -1,29 +1,19 @@
 // MIR for `main::{closure#1}` after StateTransform
-/* coroutine_layout = CoroutineLayout {
-    field_tys: {
-        _s0: CoroutineSavedTy {
-            ty: std::string::String,
-            source_info: SourceInfo {
-                span: $DIR/coroutine.rs:26:6: 26:9 (#0),
-                scope: scope[0],
-            },
-            ignore_for_traits: false,
-        },
-    },
-    variant_fields: {
-        Unresumed(0): [],
-        Returned (1): [],
-        Panicked (2): [],
-        Suspend0 (3): [_s0],
-        Suspend1 (4): [_s0],
-    },
-    storage_conflicts: BitMatrix(1x1) {
-        (_s0, _s0),
-    },
-} */
 
 fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:26:5: 26:18}>, _2: String) -> CoroutineState<(&str, String, &Location<'_>), ()> {
+    coroutine layout {
+        field _s0: String;
+        variant_fields = {
+            Unresumed(0): [],
+            Returned (1): [],
+            Panicked (2): [],
+            Suspend0 (3): [_s0],
+            Suspend1 (4): [_s0],
+        }
+        storage_conflicts = BitMatrix(1x1) {(_s0, _s0)}
+    }
     debug arg => (((*_18) as variant#4).0: std::string::String);
+    coroutine debug arg => _s0;
     let mut _0: std::ops::CoroutineState<(&str, std::string::String, &std::panic::Location<'_>), ()>;
     let _3: std::string::String;
     let mut _4: (&str, std::string::String, &std::panic::Location<'_>);
diff --git a/tests/mir-opt/coroutine/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir b/tests/mir-opt/coroutine/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
@@ -1,28 +1,18 @@
 // MIR for `main::{closure#0}` 0 coroutine_resume
-/* coroutine_layout = CoroutineLayout {
-    field_tys: {
-        _s0: CoroutineSavedTy {
-            ty: HasDrop,
-            source_info: SourceInfo {
-                span: $DIR/coroutine_tiny.rs:22:13: 22:15 (#0),
-                scope: scope[0],
-            },
-            ignore_for_traits: false,
-        },
-    },
-    variant_fields: {
-        Unresumed(0): [],
-        Returned (1): [],
-        Panicked (2): [],
-        Suspend0 (3): [_s0],
-    },
-    storage_conflicts: BitMatrix(1x1) {
-        (_s0, _s0),
-    },
-} */
 
 fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13}>, _2: u8) -> CoroutineState<(), ()> {
+    coroutine layout {
+        field _s0: HasDrop;
+        variant_fields = {
+            Unresumed(0): [],
+            Returned (1): [],
+            Panicked (2): [],
+            Suspend0 (3): [_s0],
+        }
+        storage_conflicts = BitMatrix(1x1) {(_s0, _s0)}
+    }
     debug _x => _2;
+    coroutine debug _d => _s0;
     let mut _0: std::ops::CoroutineState<(), ()>;
     let _3: HasDrop;
     let mut _4: !;
