compiler: BackendRepr::inherent_align -> required_align

Change inherent_align's name to reflect its purpose and simplify returns
from Option<AbiAndPrefAlign> to Option<Align> because every site was
mapping away the "preferred" alignment anyways.

Author: workingjubilee

compiler/rustc_abi/src/layout.rs

@@ -377,7 +377,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
         let abi = match common_non_zst_abi_and_align {
             Err(AbiMismatch) | Ok(None) => BackendRepr::Memory { sized: true },
             Ok(Some((abi, _))) => {
-                if abi.inherent_align(dl).map(|a| a.abi) != Some(align.abi) {
+                if abi.required_align(dl) != Some(align.abi) {
                     // Mismatched alignment (e.g. union is #[repr(packed)]): disable opt
                     BackendRepr::Memory { sized: true }
                 } else {

compiler/rustc_abi/src/lib.rs

@@ -1462,16 +1462,18 @@ impl BackendRepr {
         matches!(*self, BackendRepr::Scalar(s) if s.is_bool())
     }
 
-    /// Returns the fixed alignment of this ABI, if any is mandated.
-    pub fn inherent_align<C: HasDataLayout>(&self, cx: &C) -> Option<AbiAndPrefAlign> {
-        Some(match *self {
-            BackendRepr::Scalar(s) => s.align(cx),
-            BackendRepr::ScalarPair(s1, s2) => s1.align(cx).max(s2.align(cx)),
+    /// fixed alignment of this repr, if any is mandated
+    ///
+    /// NOTE: returning None is not an error! not all types have set alignments
+    pub fn required_align<C: HasDataLayout>(&self, cx: &C) -> Option<Align> {
+        match *self {
+            BackendRepr::Scalar(s) => Some(s.align(cx).abi),
+            BackendRepr::ScalarPair(s1, s2) => Some(s1.align(cx).max(s2.align(cx)).abi),
             BackendRepr::Vector { element, count } => {
-                cx.data_layout().vector_align(element.size(cx) * count)
+                Some(cx.data_layout().vector_align(element.size(cx) * count).abi)
             }
-            BackendRepr::Uninhabited | BackendRepr::Memory { .. } => return None,
-        })
+            BackendRepr::Uninhabited | BackendRepr::Memory { .. } => None,
+        }
     }
 
     /// Returns the fixed size of this ABI, if any is mandated.
@@ -1484,12 +1486,12 @@ impl BackendRepr {
             BackendRepr::ScalarPair(s1, s2) => {
                 // May have some padding between the pair.
                 let field2_offset = s1.size(cx).align_to(s2.align(cx).abi);
-                (field2_offset + s2.size(cx)).align_to(self.inherent_align(cx)?.abi)
+                (field2_offset + s2.size(cx)).align_to(self.required_align(cx)?)
             }
             BackendRepr::Vector { element, count } => {
                 // No padding in vectors, except possibly for trailing padding
                 // to make the size a multiple of align (e.g. for vectors of size 3).
-                (element.size(cx) * count).align_to(self.inherent_align(cx)?.abi)
+                (element.size(cx) * count).align_to(self.required_align(cx)?)
             }
             BackendRepr::Uninhabited | BackendRepr::Memory { .. } => return None,
         })

compiler/rustc_ty_utils/src/layout/invariant.rs

@@ -66,7 +66,7 @@ pub(super) fn layout_sanity_check<'tcx>(cx: &LayoutCx<'tcx>, layout: &TyAndLayou
 
     fn check_layout_abi<'tcx>(cx: &LayoutCx<'tcx>, layout: &TyAndLayout<'tcx>) {
         // Verify the ABI mandated alignment and size.
-        let align = layout.backend_repr.inherent_align(cx).map(|align| align.abi);
+        let align = layout.backend_repr.required_align(cx);
         let size = layout.backend_repr.inherent_size(cx);
         let Some((align, size)) = align.zip(size) else {
             assert_matches!(