Rename #[rustc_dump_layout]'s abi option to backend_repr

Moreover, dereference `ty_layout.align` for `#[rustc_dump_layout(align)]`
to render `align: Align($N bytes)` instead of `align: AbiAlign { abi: Align($N bytes) }`
which contains the same amount of information but it more concise and legible.

Author: fmease

compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs

@@ -86,15 +86,21 @@ impl<S: Stage> CombineAttributeParser<S> for RustcDumpLayoutParser {
                 return vec![];
             };
             let kind = match ident.name {
-                sym::abi => RustcDumpLayoutKind::Abi,
                 sym::align => RustcDumpLayoutKind::Align,
-                sym::size => RustcDumpLayoutKind::Size,
-                sym::homogeneous_aggregate => RustcDumpLayoutKind::HomogenousAggregate,
+                sym::backend_repr => RustcDumpLayoutKind::BackendRepr,
                 sym::debug => RustcDumpLayoutKind::Debug,
+                sym::homogeneous_aggregate => RustcDumpLayoutKind::HomogenousAggregate,
+                sym::size => RustcDumpLayoutKind::Size,
                 _ => {
                     cx.adcx().expected_specific_argument(
                         ident.span,
-                        &[sym::abi, sym::align, sym::size, sym::homogeneous_aggregate, sym::debug],
+                        &[
+                            sym::align,
+                            sym::backend_repr,
+                            sym::debug,
+                            sym::homogeneous_aggregate,
+                            sym::size,
+                        ],
                     );
                     continue;
                 }

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -758,11 +758,11 @@ impl IntoDiagArg for CrateType {
 
 #[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
 pub enum RustcDumpLayoutKind {
-    Abi,
     Align,
-    Size,
-    HomogenousAggregate,
+    BackendRepr,
     Debug,
+    HomogenousAggregate,
+    Size,
 }
 
 #[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute, PartialEq, Eq)]

compiler/rustc_passes/src/layout_test.rs

@@ -70,20 +70,21 @@ fn dump_layout_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId, kinds: &[RustcDumpLa
         Ok(ty_layout) => {
             for kind in kinds {
                 let message = match kind {
-                    // FIXME: this never was about ABI and now this dump arg is confusing
-                    RustcDumpLayoutKind::Abi => format!("abi: {:?}", ty_layout.backend_repr),
-                    RustcDumpLayoutKind::Align => format!("align: {:?}", ty_layout.align),
-                    RustcDumpLayoutKind::Size => format!("size: {:?}", ty_layout.size),
-                    RustcDumpLayoutKind::HomogenousAggregate => {
-                        let data =
-                            ty_layout.homogeneous_aggregate(&UnwrapLayoutCx { tcx, typing_env });
-                        format!("homogeneous_aggregate: {data:?}")
+                    RustcDumpLayoutKind::Align => format!("align: {:?}", *ty_layout.align),
+                    RustcDumpLayoutKind::BackendRepr => {
+                        format!("backend_repr: {:?}", ty_layout.backend_repr)
                     }
                     RustcDumpLayoutKind::Debug => {
                         let normalized_ty = tcx.normalize_erasing_regions(typing_env, ty);
                         // FIXME: using the `Debug` impl here isn't ideal.
                         format!("layout_of({normalized_ty}) = {:#?}", *ty_layout)
                     }
+                    RustcDumpLayoutKind::HomogenousAggregate => {
+                        let data =
+                            ty_layout.homogeneous_aggregate(&UnwrapLayoutCx { tcx, typing_env });
+                        format!("homogeneous_aggregate: {data:?}")
+                    }
+                    RustcDumpLayoutKind::Size => format!("size: {:?}", ty_layout.size),
                 };
                 tcx.dcx().span_err(span, message);
             }

compiler/rustc_span/src/symbol.rs

@@ -505,6 +505,7 @@ symbols! {
         avx512f,
         await_macro,
         backchain,
+        backend_repr,
         bang,
         begin_panic,
         bench,

src/doc/unstable-book/src/language-features/rustc-attrs.md

@@ -13,16 +13,16 @@ The `rustc_attrs` feature allows debugging rustc type layouts by using
 with `cargo check`) as an alternative to `rustc -Z print-type-sizes`
 that is way more verbose.
 
-Options provided by `#[rustc_dump_layout(...)]` are `abi`, `align`, `debug`,
-`homogeneous_aggregate` and `size`.
+Options provided by `#[rustc_dump_layout(...)]` are `backend_repr`, `align`,
+`debug`, `homogeneous_aggregate` and `size`.
 Note that it only works on sized types without generics.
 
 ## Examples
 
 ```rust,compile_fail
 #![feature(rustc_attrs)]
 
-#[rustc_dump_layout(abi, size)]
+#[rustc_dump_layout(backend_repr, size)]
 pub enum X {
     Y(u8, u8, u8),
     Z(isize),
@@ -32,7 +32,7 @@ pub enum X {
 When that is compiled, the compiler will error with something like
 
 ```text
-error: abi: Aggregate { sized: true }
+error: backend_repr: Aggregate { sized: true }
  --> src/lib.rs:4:1
   |
 4 | / pub enum T {

tests/ui/layout/enum-scalar-pair-int-ptr.rs

@@ -8,17 +8,17 @@
 #![feature(never_type)]
 #![crate_type = "lib"]
 
-#[rustc_dump_layout(abi)]
-enum ScalarPairPointerWithInt { //~ERROR: abi: ScalarPair
+#[rustc_dump_layout(backend_repr)]
+enum ScalarPairPointerWithInt { //~ERROR: backend_repr: ScalarPair
     A(usize),
     B(Box<()>),
 }
 
 // Negative test--ensure that pointers are not commoned with integers
 // of a different size. (Assumes that no target has 8 bit pointers, which
 // feels pretty safe.)
-#[rustc_dump_layout(abi)]
-enum NotScalarPairPointerWithSmallerInt { //~ERROR: abi: Memory
+#[rustc_dump_layout(backend_repr)]
+enum NotScalarPairPointerWithSmallerInt { //~ERROR: backend_repr: Memory
     A(u8),
     B(Box<()>),
 }

tests/ui/layout/enum-scalar-pair-int-ptr.stderr

@@ -1,10 +1,10 @@
-error: abi: ScalarPair(Initialized { value: Int(I?, false), valid_range: $VALID_RANGE }, Initialized { value: Pointer(AddressSpace(0)), valid_range: $VALID_RANGE })
+error: backend_repr: ScalarPair(Initialized { value: Int(I?, false), valid_range: $VALID_RANGE }, Initialized { value: Pointer(AddressSpace(0)), valid_range: $VALID_RANGE })
   --> $DIR/enum-scalar-pair-int-ptr.rs:12:1
    |
 LL | enum ScalarPairPointerWithInt {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: abi: Memory { sized: true }
+error: backend_repr: Memory { sized: true }
   --> $DIR/enum-scalar-pair-int-ptr.rs:21:1
    |
 LL | enum NotScalarPairPointerWithSmallerInt {

tests/ui/layout/enum.rs

@@ -6,7 +6,7 @@
 #![crate_type = "lib"]
 
 #[rustc_dump_layout(align)]
-enum UninhabitedVariantAlign { //~ERROR: abi: Align(2 bytes)
+enum UninhabitedVariantAlign { //~ERROR: align: Align(2 bytes)
     A([u8; 32]),
     B([u16; 0], !), // make sure alignment in uninhabited fields is respected
 }
@@ -17,8 +17,8 @@ enum UninhabitedVariantSpace { //~ERROR: size: Size(16 bytes)
     B([u8; 15], !), // make sure there is space being reserved for this field.
 }
 
-#[rustc_dump_layout(abi)]
-enum ScalarPairDifferingSign { //~ERROR: abi: ScalarPair
+#[rustc_dump_layout(backend_repr)]
+enum ScalarPairDifferingSign { //~ERROR: backend_repr: ScalarPair
     A(u8),
     B(i8),
 }

tests/ui/layout/enum.stderr

@@ -1,4 +1,4 @@
-error: align: AbiAlign { abi: Align(2 bytes) }
+error: align: Align(2 bytes)
   --> $DIR/enum.rs:9:1
    |
 LL | enum UninhabitedVariantAlign {
@@ -10,7 +10,7 @@ error: size: Size(16 bytes)
 LL | enum UninhabitedVariantSpace {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: abi: ScalarPair(Initialized { value: Int(I8, false), valid_range: 0..=1 }, Initialized { value: Int(I8, false), valid_range: 0..=255 })
+error: backend_repr: ScalarPair(Initialized { value: Int(I8, false), valid_range: 0..=1 }, Initialized { value: Int(I8, false), valid_range: 0..=255 })
   --> $DIR/enum.rs:21:1
    |
 LL | enum ScalarPairDifferingSign {

tests/ui/layout/struct.rs

@@ -5,8 +5,8 @@
 #![feature(never_type)]
 #![crate_type = "lib"]
 
-#[rustc_dump_layout(abi)]
-struct AlignedZstPreventsScalar(i16, [i32; 0]); //~ERROR: abi: Memory
+#[rustc_dump_layout(backend_repr)]
+struct AlignedZstPreventsScalar(i16, [i32; 0]); //~ERROR: backend_repr: Memory
 
-#[rustc_dump_layout(abi)]
-struct AlignedZstButStillScalar(i32, [i16; 0]); //~ERROR: abi: Scalar
+#[rustc_dump_layout(backend_repr)]
+struct AlignedZstButStillScalar(i32, [i16; 0]); //~ERROR: backend_repr: Scalar