Don't print alignment in error message

Author: 21aslade

compiler/rustc_const_eval/src/util/alignment.rs

@@ -3,21 +3,14 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::{self, TyCtxt};
 use tracing::debug;
 
-/// The actual and expected alignment for a place.
-pub struct Disalignment {
-    pub actual: Align,
-    // Unsized types may not have an expected alignment
-    pub expected: Option<Align>,
-}
-
-/// Returns a [`Disalignment`] if this place is allowed to be less aligned
+/// Returns the packed alignment if this place is allowed to be less aligned
 /// than its type normally requires (because it is within a packed struct).
 pub fn is_disaligned<'tcx, L>(
     tcx: TyCtxt<'tcx>,
     local_decls: &L,
     typing_env: ty::TypingEnv<'tcx>,
     place: Place<'tcx>,
-) -> Option<Disalignment>
+) -> Option<Align>
 where
     L: HasLocalDecls<'tcx>,
 {
@@ -31,29 +24,27 @@ where
     let unsized_tail = || tcx.struct_tail_for_codegen(ty, typing_env);
     match tcx.layout_of(typing_env.as_query_input(ty)) {
         Ok(layout)
-            if (layout.is_sized() || matches!(unsized_tail().kind(), ty::Slice(..) | ty::Str)) =>
+            if layout.align.abi <= pack
+                && (layout.is_sized()
+                    || matches!(unsized_tail().kind(), ty::Slice(..) | ty::Str)) =>
         {
             // If the packed alignment is greater or equal to the field alignment, the type won't be
             // further disaligned.
             // However we need to ensure the field is sized; for unsized fields, `layout.align` is
             // just an approximation -- except when the unsized tail is a slice, where the alignment
             // is fully determined by the type.
-            if layout.align.abi <= pack {
-                debug!(
-                    "is_disaligned({:?}) - align = {}, packed = {}; not disaligned",
-                    place,
-                    layout.align.bytes(),
-                    pack.bytes()
-                );
-                None
-            } else {
-                Some(Disalignment { actual: pack, expected: Some(layout.align.abi) })
-            }
+            debug!(
+                "is_disaligned({:?}) - align = {}, packed = {}; not disaligned",
+                place,
+                layout.align.bytes(),
+                pack.bytes()
+            );
+            None
         }
         _ => {
             // We cannot figure out the layout. Conservatively assume that this is disaligned.
             debug!("is_disaligned({:?}) - true", place);
-            Some(Disalignment { actual: pack, expected: None })
+            Some(pack)
         }
     }
 }

compiler/rustc_mir_transform/messages.ftl

@@ -70,10 +70,7 @@ mir_transform_tail_expr_local = {$is_generated_name ->
     }
 
 mir_transform_unaligned_packed_ref = reference to packed field is unaligned
-    .note = this field is only {$actual}-byte aligned, but its type requires {$expected ->
-        [0] more
-        *[other] {$expected}-byte
-    } alignment
+    .note = this field is only {$actual}-byte aligned, but its type requires more alignment
     .note_ub = creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
     .help = copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 

compiler/rustc_mir_transform/src/check_packed_ref.rs

@@ -1,4 +1,3 @@
-use rustc_abi::Align;
 use rustc_middle::mir::visit::{PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::span_bug;
@@ -39,8 +38,7 @@ impl<'tcx> Visitor<'tcx> for PackedRefChecker<'_, 'tcx> {
 
     fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, _location: Location) {
         if context.is_borrow()
-            && let Some(disalign) =
-                util::is_disaligned(self.tcx, self.body, self.typing_env, *place)
+            && let Some(pack) = util::is_disaligned(self.tcx, self.body, self.typing_env, *place)
         {
             let def_id = self.body.source.instance.def_id();
             if let Some(impl_def_id) = self.tcx.trait_impl_of_assoc(def_id)
@@ -53,8 +51,7 @@ impl<'tcx> Visitor<'tcx> for PackedRefChecker<'_, 'tcx> {
             } else {
                 self.tcx.dcx().emit_err(errors::UnalignedPackedRef {
                     span: self.source_info.span,
-                    actual: disalign.actual.bytes(),
-                    expected: disalign.expected.map(Align::bytes).unwrap_or(0),
+                    actual: pack.bytes(),
                 });
             }
         }

compiler/rustc_mir_transform/src/errors.rs

@@ -100,7 +100,6 @@ pub(crate) struct UnalignedPackedRef {
     #[primary_span]
     pub span: Span,
     pub actual: u64,
-    pub expected: u64,
 }
 
 #[derive(Diagnostic)]

tests/ui/binding/issue-53114-safety-checks.stderr

@@ -4,7 +4,7 @@ error[E0793]: reference to packed field is unaligned
 LL |     let _ = &p.b;
    |             ^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -14,7 +14,7 @@ error[E0793]: reference to packed field is unaligned
 LL |     let (_,) = (&p.b,);
    |                 ^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -56,7 +56,7 @@ error[E0793]: reference to packed field is unaligned
 LL |     let _: _ = &p.b;
    |                ^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -66,7 +66,7 @@ error[E0793]: reference to packed field is unaligned
 LL |     let (_,): _ = (&p.b,);
    |                    ^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -108,7 +108,7 @@ error[E0793]: reference to packed field is unaligned
 LL |     match &p.b  { _ => { } }
    |           ^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -118,7 +118,7 @@ error[E0793]: reference to packed field is unaligned
 LL |     match (&p.b,)  { (_,) => { } }
    |            ^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 

tests/ui/closures/2229_closure_analysis/diagnostics/repr_packed.stderr

@@ -4,7 +4,7 @@ error[E0793]: reference to packed field is unaligned
 LL |         println!("{}", foo.x);
    |                        ^^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)

tests/ui/lint/unaligned_references.current.stderr

@@ -4,7 +4,7 @@ error[E0793]: reference to packed field is unaligned
 LL |             &self.x;
    |             ^^^^^^^
    |
-   = note: this field is only 2-byte aligned, but its type requires 4-byte alignment
+   = note: this field is only 2-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -24,7 +24,7 @@ error[E0793]: reference to packed field is unaligned
 LL |     println!("{:?}", &*foo.0);
    |                        ^^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -44,7 +44,7 @@ error[E0793]: reference to packed field is unaligned
 LL |         let _ = &good.ptr;
    |                 ^^^^^^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -54,7 +54,7 @@ error[E0793]: reference to packed field is unaligned
 LL |         let _ = &good.data;
    |                 ^^^^^^^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -64,7 +64,7 @@ error[E0793]: reference to packed field is unaligned
 LL |         let _ = &good.data as *const _;
    |                 ^^^^^^^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -74,7 +74,7 @@ error[E0793]: reference to packed field is unaligned
 LL |         let _: *const _ = &good.data;
    |                           ^^^^^^^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -84,7 +84,7 @@ error[E0793]: reference to packed field is unaligned
 LL |         let _ = good.data.clone();
    |                 ^^^^^^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -94,7 +94,7 @@ error[E0793]: reference to packed field is unaligned
 LL |         let _ = &good.data2[0];
    |                 ^^^^^^^^^^^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 8-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -104,7 +104,7 @@ error[E0793]: reference to packed field is unaligned
 LL |         let _ = &packed2.x;
    |                 ^^^^^^^^^^
    |
-   = note: this field is only 2-byte aligned, but its type requires 4-byte alignment
+   = note: this field is only 2-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -114,7 +114,7 @@ error[E0793]: reference to packed field is unaligned
 LL |         let _ref = &m1.1.a;
    |                    ^^^^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 2-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
@@ -124,7 +124,7 @@ error[E0793]: reference to packed field is unaligned
 LL |         let _ref = &m2.1.a;
    |                    ^^^^^^^
    |
-   = note: this field is only 1-byte aligned, but its type requires 2-byte alignment
+   = note: this field is only 1-byte aligned, but its type requires more alignment
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)