Pull out logic into distinct functions

compiler/rustc_ty_utils/src/layout.rs

@@ -1,3 +1,4 @@
+use hir::def_id::DefId;
 use rustc_hir as hir;
 use rustc_index::bit_set::BitSet;
 use rustc_index::vec::{Idx, IndexVec};
@@ -6,7 +7,7 @@ use rustc_middle::ty::layout::{
     IntegerExt, LayoutCx, LayoutError, LayoutOf, TyAndLayout, MAX_SIMD_LANES,
 };
 use rustc_middle::ty::{
-    self, subst::SubstsRef, EarlyBinder, ReprOptions, Ty, TyCtxt, TypeVisitable,
+    self, subst::SubstsRef, AdtDef, EarlyBinder, ReprOptions, Ty, TyCtxt, TypeVisitable,
 };
 use rustc_session::{DataTypeKind, FieldInfo, SizeKind, VariantInfo};
 use rustc_span::symbol::Symbol;
@@ -815,13 +816,39 @@ fn record_layout_for_printing_outlined<'tcx>(
     };
 
     match *layout.ty.kind() {
-        ty::Adt(ref adt_def, _) => {
+        ty::Adt(adt_def, _) => {
             debug!("print-type-size t: `{:?}` process adt", layout.ty);
             let adt_kind = adt_def.adt_kind();
             let adt_packed = adt_def.repr().pack.is_some();
+            let (variant_infos, opt_discr_size) = variant_info_for_adt(cx, layout, adt_def);
+            record(adt_kind.into(), adt_packed, opt_discr_size, variant_infos);
+        }
 
-            let build_variant_info =
+        ty::Generator(def_id, substs, _) => {
-                |n: Option<Symbol>, flds: &[Symbol], layout: TyAndLayout<'tcx>| {
+            debug!("print-type-size t: `{:?}` record generator", layout.ty);
+            // Generators always have a begin/poisoned/end state with additional suspend points
+            let (variant_infos, opt_discr_size) =
+                variant_info_for_generator(cx, layout, def_id, substs);
+            record(DataTypeKind::Generator, false, opt_discr_size, variant_infos);
+        }
+
+        ty::Closure(..) => {
+            debug!("print-type-size t: `{:?}` record closure", layout.ty);
+            record(DataTypeKind::Closure, false, None, vec![]);
+        }
+
+        _ => {
+            debug!("print-type-size t: `{:?}` skip non-nominal", layout.ty);
+        }
+    };
+}
+
+fn variant_info_for_adt<'tcx>(
+    cx: &LayoutCx<'tcx, TyCtxt<'tcx>>,
+    layout: TyAndLayout<'tcx>,
+    adt_def: AdtDef<'tcx>,
+) -> (Vec<VariantInfo>, Option<Size>) {
+    let build_variant_info = |n: Option<Symbol>, flds: &[Symbol], layout: TyAndLayout<'tcx>| {
         let mut min_size = Size::ZERO;
         let field_info: Vec<_> = flds
             .iter()
@@ -843,11 +870,7 @@ fn record_layout_for_printing_outlined<'tcx>(
             name: n,
             kind: if layout.is_unsized() { SizeKind::Min } else { SizeKind::Exact },
             align: layout.align.abi.bytes(),
-                        size: if min_size.bytes() == 0 {
+            size: if min_size.bytes() == 0 { layout.size.bytes() } else { min_size.bytes() },
-                            layout.size.bytes()
-                        } else {
-                            min_size.bytes()
-                        },
             fields: field_info,
         }
     };
@@ -855,23 +878,12 @@ fn record_layout_for_printing_outlined<'tcx>(
     match layout.variants {
         Variants::Single { index } => {
             if !adt_def.variants().is_empty() && layout.fields != FieldsShape::Primitive {
-                        debug!(
+                debug!("print-type-size `{:#?}` variant {}", layout, adt_def.variant(index).name);
-                            "print-type-size `{:#?}` variant {}",
-                            layout,
-                            adt_def.variant(index).name
-                        );
                 let variant_def = &adt_def.variant(index);
                 let fields: Vec<_> = variant_def.fields.iter().map(|f| f.name).collect();
-                        record(
+                (vec![build_variant_info(Some(variant_def.name), &fields, layout)], None)
-                            adt_kind.into(),
-                            adt_packed,
-                            None,
-                            vec![build_variant_info(Some(variant_def.name), &fields, layout)],
-                        );
             } else {
-                        // (This case arises for *empty* enums; so give it
+                (vec![], None)
-                        // zero variants.)
-                        record(adt_kind.into(), adt_packed, None, vec![]);
             }
         }
 
@@ -885,35 +897,33 @@ fn record_layout_for_printing_outlined<'tcx>(
                 .variants()
                 .iter_enumerated()
                 .map(|(i, variant_def)| {
-                            let fields: Vec<_> =
+                    let fields: Vec<_> = variant_def.fields.iter().map(|f| f.name).collect();
-                                variant_def.fields.iter().map(|f| f.name).collect();
+                    build_variant_info(Some(variant_def.name), &fields, layout.for_variant(cx, i))
-                            build_variant_info(
-                                Some(variant_def.name),
-                                &fields,
-                                layout.for_variant(cx, i),
-                            )
                 })
                 .collect();
-                    record(
+
-                        adt_kind.into(),
+            (
-                        adt_packed,
+                variant_infos,
                 match tag_encoding {
                     TagEncoding::Direct => Some(tag.size(cx)),
                     _ => None,
                 },
-                        variant_infos,
+            )
-                    );
         }
     }
 }
 
-        ty::Generator(def_id, substs, _) => {
+fn variant_info_for_generator<'tcx>(
-            debug!("print-type-size t: `{:?}` record generator", layout.ty);
+    cx: &LayoutCx<'tcx, TyCtxt<'tcx>>,
-            // Generators always have a begin/poisoned/end state with additional suspend points
+    layout: TyAndLayout<'tcx>,
-            match layout.variants {
+    def_id: DefId,
-                Variants::Multiple { tag, ref tag_encoding, .. } => {
+    substs: ty::SubstsRef<'tcx>,
-                    let (generator, state_specific_names) =
+) -> (Vec<VariantInfo>, Option<Size>) {
-                        cx.tcx.generator_layout_and_saved_local_names(def_id);
+    let Variants::Multiple { tag, ref tag_encoding, .. } = layout.variants else {
+        return (vec![], None);
+    };
+
+    let (generator, state_specific_names) = cx.tcx.generator_layout_and_saved_local_names(def_id);
     let upvar_names = cx.tcx.closure_saved_names_of_captured_variables(def_id);
 
     let mut upvars_size = Size::ZERO;
@@ -950,14 +960,9 @@ fn record_layout_for_printing_outlined<'tcx>(
                     // The struct is as large as the last field's end
                     variant_size = variant_size.max(offset + field_layout.size);
                     FieldInfo {
-                                        name: state_specific_names
+                        name: state_specific_names.get(*local).copied().flatten().unwrap_or(
-                                            .get(*local)
+                            Symbol::intern(&format!(".generator_field{}", local.as_usize())),
-                                            .copied()
+                        ),
-                                            .flatten()
-                                            .unwrap_or(Symbol::intern(&format!(
-                                                ".generator_field{}",
-                                                local.as_usize()
-                                            ))),
                         offset: offset.bytes(),
                         size: field_layout.size.bytes(),
                         align: field_layout.align.abi.bytes(),
@@ -978,9 +983,7 @@ fn record_layout_for_printing_outlined<'tcx>(
             };
 
             VariantInfo {
-                                name: Some(Symbol::intern(&ty::GeneratorSubsts::variant_name(
+                name: Some(Symbol::intern(&ty::GeneratorSubsts::variant_name(variant_idx))),
-                                    variant_idx,
-                                ))),
                 kind: SizeKind::Exact,
                 size: variant_size.bytes(),
                 align: variant_layout.align.abi.bytes(),
@@ -988,33 +991,11 @@ fn record_layout_for_printing_outlined<'tcx>(
             }
         })
         .collect();
-                    record(
+    (
-                        DataTypeKind::Generator,
+        variant_infos,
-                        false,
         match tag_encoding {
             TagEncoding::Direct => Some(tag.size(cx)),
             _ => None,
         },
-                        variant_infos,
+    )
-                    );
-                }
-                _ => {
-                    // This should never happen, but I would rather not panic.
-                    record(DataTypeKind::Generator, false, None, vec![]);
-                    return;
-                }
-            }
-        }
-
-        ty::Closure(..) => {
-            debug!("print-type-size t: `{:?}` record closure", layout.ty);
-            record(DataTypeKind::Closure, false, None, vec![]);
-            return;
-        }
-
-        _ => {
-            debug!("print-type-size t: `{:?}` skip non-nominal", layout.ty);
-            return;
-        }
-    };
 }