[squash-before-merge] better #[repr]

Author: aDotInTheVoid

src/librustdoc/json/conversions.rs

@@ -913,7 +913,7 @@ fn maybe_from_hir_attr(
             {
                 Attribute::DocHidden
             } else {
-                Attribute::Other(rustc_hir_pretty::attribute_to_string(&tcx, attr))
+                other_attr(tcx, attr)
             });
         }
     };
@@ -925,22 +925,59 @@ fn maybe_from_hir_attr(
         AK::MustUse { reason, span: _ } => {
             Attribute::MustUse { reason: reason.map(|s| s.to_string()) }
         }
-        AK::Repr { .. } => Attribute::Repr(repr(item_id.as_def_id().expect("reason"), tcx)),
+        AK::Repr { .. } => repr_attr(
+            tcx,
+            item_id.as_def_id().expect("all items that could have #[repr] have a DefId"),
+        ),
         AK::NoMangle(_) => Attribute::NoMangle,
 
-        _ => Attribute::Other(rustc_hir_pretty::attribute_to_string(&tcx, attr)),
+        _ => other_attr(tcx, attr),
     })
 }
 
-fn repr(def_id: DefId, tcx: TyCtxt<'_>) -> AttributeRepr {
+fn other_attr(tcx: TyCtxt<'_>, attr: &hir::Attribute) -> Attribute {
+    let mut s = rustc_hir_pretty::attribute_to_string(&tcx, attr);
+    assert_eq!(s.pop(), Some('\n'));
+    Attribute::Other(s)
+}
+
+fn repr_attr(tcx: TyCtxt<'_>, def_id: DefId) -> Attribute {
     let repr = tcx.adt_def(def_id).repr();
 
     // FIXME: This is wildly insufficient
-    if repr.c() {
-        AttributeRepr::C
+    let kind = if repr.c() {
+        ReprKind::C
     } else if repr.transparent() {
-        AttributeRepr::Transparent
+        ReprKind::Transparent
+    } else if repr.simd() {
+        ReprKind::Simd
     } else {
-        AttributeRepr::Rust
-    }
+        ReprKind::Rust
+    };
+
+    let align = repr.align.map(|a| a.bytes());
+    let packed = repr.pack.map(|p| p.bytes());
+    let int = repr.int.map(format_integer_type);
+
+    Attribute::Repr(AttributeRepr { kind, align, packed, int })
+}
+
+fn format_integer_type(it: rustc_abi::IntegerType) -> String {
+    use rustc_abi::Integer::*;
+    use rustc_abi::IntegerType::*;
+    match it {
+        Pointer(true) => "isize",
+        Pointer(false) => "usize",
+        Fixed(I8, true) => "i8",
+        Fixed(I8, false) => "u8",
+        Fixed(I16, true) => "i16",
+        Fixed(I16, false) => "u16",
+        Fixed(I32, true) => "i32",
+        Fixed(I32, false) => "u32",
+        Fixed(I64, true) => "i64",
+        Fixed(I64, false) => "u64",
+        Fixed(I128, true) => "i128",
+        Fixed(I128, false) => "u128",
+    }
+    .to_owned()
 }

src/rustdoc-json-types/lib.rs

@@ -37,7 +37,7 @@ pub type FxHashMap<K, V> = HashMap<K, V>; // re-export for use in src/librustdoc
 // will instead cause conflicts. See #94591 for more. (This paragraph and the "Latest feature" line
 // are deliberately not in a doc comment, because they need not be in public docs.)
 //
-// Latest feature: Structed Attributes
+// Latest feature: Structured Attributes
 pub const FORMAT_VERSION: u32 = 54;
 
 /// The root of the emitted JSON blob.
@@ -202,14 +202,15 @@ pub struct Item {
     pub inner: ItemEnum,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 /// An attribute, eg `#[repr(C)]`
 ///
 /// This doesn't include:
 /// - `#[doc = "Doc Comment"]` or `/// Doc comment`. These are in [`Item::docs`] instead.
-/// - `#[depricate]`. These are in [`Item::deprecation`] instead.
+/// - `#[deprecated]`. These are in [`Item::deprecation`] instead.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
 pub enum Attribute {
-    /// `#[non_exaustive]`
+    /// `#[non_exhaustive]`
     NonExhaustive,
 
     /// `#[must_use]`
@@ -233,16 +234,29 @@ pub enum Attribute {
     ///
     /// Things here are explicitly *not* covered by the [`FORMAT_VERSION`]
     /// constant, and may change without bumping the format version. If you rely
-    /// on an attibute here, please open an issue about adding a new variant for
+    /// on an attribute here, please open an issue about adding a new variant for
     /// that attr.
     Other(String),
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub enum AttributeRepr {
+pub struct AttributeRepr {
+    pub kind: ReprKind,
+
+    /// Alignment, in bytes.
+    pub align: Option<u64>,
+    pub packed: Option<u64>,
+
+    pub int: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ReprKind {
+    Rust,
     C,
     Transparent,
-    Rust,
+    Simd,
 }
 
 /// A range of source code.
@@ -1386,7 +1400,7 @@ pub struct Static {
 
     /// Is the static `unsafe`?
     ///
-    /// This is only true if it's in an `extern` block, and not explicity marked
+    /// This is only true if it's in an `extern` block, and not explicitly marked
     /// as `safe`.
     ///
     /// ```rust