src/test/ui/lint/unaligned_references.stderr - toolchain/rustc - Git at Google

 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:22:17
    |
 LL |         let _ = &good.ptr;
    |                 ^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/unaligned_references.rs:1:9
    |
 LL | #![deny(unaligned_references)]
    |         ^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:24:17
    |
 LL |         let _ = &good.data;
    |                 ^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:27:17
    |
 LL |         let _ = &good.data as *const _;
    |                 ^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:29:27
    |
 LL |         let _: *const _ = &good.data;
    |                           ^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:32:17
    |
 LL |         let _ = good.data.clone();
    |                 ^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:35:17
    |
 LL |         let _ = &good.data2[0];
    |                 ^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:45:17
    |
 LL |         let _ = &packed2.x;
    |                 ^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:90:20
    |
 LL |         let _ref = &m1.1.a;
    |                    ^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:100:20
    |
 LL |         let _ref = &m2.1.a;
    |                    ^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 error: aborting due to 9 previous errors

 Future incompatibility report: Future breakage diagnostic:
 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:22:17
    |
 LL |         let _ = &good.ptr;
    |                 ^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/unaligned_references.rs:1:9
    |
 LL | #![deny(unaligned_references)]
    |         ^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 Future breakage diagnostic:
 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:24:17
    |
 LL |         let _ = &good.data;
    |                 ^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/unaligned_references.rs:1:9
    |
 LL | #![deny(unaligned_references)]
    |         ^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 Future breakage diagnostic:
 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:27:17
    |
 LL |         let _ = &good.data as *const _;
    |                 ^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/unaligned_references.rs:1:9
    |
 LL | #![deny(unaligned_references)]
    |         ^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 Future breakage diagnostic:
 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:29:27
    |
 LL |         let _: *const _ = &good.data;
    |                           ^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/unaligned_references.rs:1:9
    |
 LL | #![deny(unaligned_references)]
    |         ^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 Future breakage diagnostic:
 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:32:17
    |
 LL |         let _ = good.data.clone();
    |                 ^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/unaligned_references.rs:1:9
    |
 LL | #![deny(unaligned_references)]
    |         ^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 Future breakage diagnostic:
 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:35:17
    |
 LL |         let _ = &good.data2[0];
    |                 ^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/unaligned_references.rs:1:9
    |
 LL | #![deny(unaligned_references)]
    |         ^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 Future breakage diagnostic:
 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:45:17
    |
 LL |         let _ = &packed2.x;
    |                 ^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/unaligned_references.rs:1:9
    |
 LL | #![deny(unaligned_references)]
    |         ^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 Future breakage diagnostic:
 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:90:20
    |
 LL |         let _ref = &m1.1.a;
    |                    ^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/unaligned_references.rs:1:9
    |
 LL | #![deny(unaligned_references)]
    |         ^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)

 Future breakage diagnostic:
 error: reference to packed field is unaligned
   --> $DIR/unaligned_references.rs:100:20
    |
 LL |         let _ref = &m2.1.a;
    |                    ^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/unaligned_references.rs:1:9
    |
 LL | #![deny(unaligned_references)]
    |         ^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
    = note: fields of packed structs are not properly aligned, and 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)
	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:22:17
	\|
	LL \| let _ = &good.ptr;
	\| ^^^^^^^^^
	\|
	note: the lint level is defined here
	--> $DIR/unaligned_references.rs:1:9
	\|
	LL \| #![deny(unaligned_references)]
	\| ^^^^^^^^^^^^^^^^^^^^
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:24:17
	\|
	LL \| let _ = &good.data;
	\| ^^^^^^^^^^
	\|
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:27:17
	\|
	LL \| let _ = &good.data as *const _;
	\| ^^^^^^^^^^
	\|
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:29:27
	\|
	LL \| let _: *const _ = &good.data;
	\| ^^^^^^^^^^
	\|
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:32:17
	\|
	LL \| let _ = good.data.clone();
	\| ^^^^^^^^^^^^^^^^^
	\|
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:35:17
	\|
	LL \| let _ = &good.data2[0];
	\| ^^^^^^^^^^^^^^
	\|
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:45:17
	\|
	LL \| let _ = &packed2.x;
	\| ^^^^^^^^^^
	\|
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:90:20
	\|
	LL \| let _ref = &m1.1.a;
	\| ^^^^^^^
	\|
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:100:20
	\|
	LL \| let _ref = &m2.1.a;
	\| ^^^^^^^
	\|
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	error: aborting due to 9 previous errors

	Future incompatibility report: Future breakage diagnostic:
	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:22:17
	\|
	LL \| let _ = &good.ptr;
	\| ^^^^^^^^^
	\|
	note: the lint level is defined here
	--> $DIR/unaligned_references.rs:1:9
	\|
	LL \| #![deny(unaligned_references)]
	\| ^^^^^^^^^^^^^^^^^^^^
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	Future breakage diagnostic:
	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:24:17
	\|
	LL \| let _ = &good.data;
	\| ^^^^^^^^^^
	\|
	note: the lint level is defined here
	--> $DIR/unaligned_references.rs:1:9
	\|
	LL \| #![deny(unaligned_references)]
	\| ^^^^^^^^^^^^^^^^^^^^
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	Future breakage diagnostic:
	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:27:17
	\|
	LL \| let _ = &good.data as *const _;
	\| ^^^^^^^^^^
	\|
	note: the lint level is defined here
	--> $DIR/unaligned_references.rs:1:9
	\|
	LL \| #![deny(unaligned_references)]
	\| ^^^^^^^^^^^^^^^^^^^^
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	Future breakage diagnostic:
	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:29:27
	\|
	LL \| let _: *const _ = &good.data;
	\| ^^^^^^^^^^
	\|
	note: the lint level is defined here
	--> $DIR/unaligned_references.rs:1:9
	\|
	LL \| #![deny(unaligned_references)]
	\| ^^^^^^^^^^^^^^^^^^^^
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	Future breakage diagnostic:
	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:32:17
	\|
	LL \| let _ = good.data.clone();
	\| ^^^^^^^^^^^^^^^^^
	\|
	note: the lint level is defined here
	--> $DIR/unaligned_references.rs:1:9
	\|
	LL \| #![deny(unaligned_references)]
	\| ^^^^^^^^^^^^^^^^^^^^
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	Future breakage diagnostic:
	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:35:17
	\|
	LL \| let _ = &good.data2[0];
	\| ^^^^^^^^^^^^^^
	\|
	note: the lint level is defined here
	--> $DIR/unaligned_references.rs:1:9
	\|
	LL \| #![deny(unaligned_references)]
	\| ^^^^^^^^^^^^^^^^^^^^
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	Future breakage diagnostic:
	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:45:17
	\|
	LL \| let _ = &packed2.x;
	\| ^^^^^^^^^^
	\|
	note: the lint level is defined here
	--> $DIR/unaligned_references.rs:1:9
	\|
	LL \| #![deny(unaligned_references)]
	\| ^^^^^^^^^^^^^^^^^^^^
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	Future breakage diagnostic:
	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:90:20
	\|
	LL \| let _ref = &m1.1.a;
	\| ^^^^^^^
	\|
	note: the lint level is defined here
	--> $DIR/unaligned_references.rs:1:9
	\|
	LL \| #![deny(unaligned_references)]
	\| ^^^^^^^^^^^^^^^^^^^^
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)

	Future breakage diagnostic:
	error: reference to packed field is unaligned
	--> $DIR/unaligned_references.rs:100:20
	\|
	LL \| let _ref = &m2.1.a;
	\| ^^^^^^^
	\|
	note: the lint level is defined here
	--> $DIR/unaligned_references.rs:1:9
	\|
	LL \| #![deny(unaligned_references)]
	\| ^^^^^^^^^^^^^^^^^^^^
	= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
	= note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
	= note: fields of packed structs are not properly aligned, and 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)