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

error[E0793]: reference to packed field is unaligned
  --> $DIR/repr_packed.rs:21:24
   |
LL |         println!("{}", foo.x);
   |                        ^^^^^
   |
   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
   = 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)

error: aborting due to previous error

For more information about this error, try `rustc --explain E0793`.
make unaligned_reference a hard error 2022-09-30 07:54:30 -05:00			`error[E0793]: reference to packed field is unaligned`
make unaligned_references lint deny-by-default 2022-03-27 11:42:19 -05:00			`--> $DIR/repr_packed.rs:21:24`
2229: Handle capturing a reference into a repr packed struct RFC 1240 states that it is unsafe to capture references into a packed-struct. This PR ensures that when a closure captures a precise path, we aren't violating this safety constraint. To acheive so we restrict the capture precision to the struct itself. An interesting edge case: ```rust struct Foo(String); let foo: Foo; let c = \|\| { println!("{}", foo.0); let x = foo.0; } ``` Given how closures get desugared today, foo.0 will be moved into the closure, making the `println!`, safe. However this can be very subtle and also will be unsafe if the closure gets inline. Closes: https://github.com/rust-lang/project-rfc-2229/issues/33 2021-03-06 20:47:53 -06:00			`\|`
			`LL \| println!("{}", foo.x);`
			`\| ^^^^^`
			`\|`
improve error notes for packed struct reference diagnostic 2023-04-28 20:28:56 -05:00			`= note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses`
			`= note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)`
give more help in the unaligned_references lint 2021-12-09 11:45:00 -06:00			= 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)
Mention first and last macro in backtrace 2022-06-20 21:25:52 -05:00			= 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)
2229: Handle capturing a reference into a repr packed struct RFC 1240 states that it is unsafe to capture references into a packed-struct. This PR ensures that when a closure captures a precise path, we aren't violating this safety constraint. To acheive so we restrict the capture precision to the struct itself. An interesting edge case: ```rust struct Foo(String); let foo: Foo; let c = \|\| { println!("{}", foo.0); let x = foo.0; } ``` Given how closures get desugared today, foo.0 will be moved into the closure, making the `println!`, safe. However this can be very subtle and also will be unsafe if the closure gets inline. Closes: https://github.com/rust-lang/project-rfc-2229/issues/33 2021-03-06 20:47:53 -06:00
make unaligned_references lint deny-by-default 2022-03-27 11:42:19 -05:00			`error: aborting due to previous error`
2229: Handle capturing a reference into a repr packed struct RFC 1240 states that it is unsafe to capture references into a packed-struct. This PR ensures that when a closure captures a precise path, we aren't violating this safety constraint. To acheive so we restrict the capture precision to the struct itself. An interesting edge case: ```rust struct Foo(String); let foo: Foo; let c = \|\| { println!("{}", foo.0); let x = foo.0; } ``` Given how closures get desugared today, foo.0 will be moved into the closure, making the `println!`, safe. However this can be very subtle and also will be unsafe if the closure gets inline. Closes: https://github.com/rust-lang/project-rfc-2229/issues/33 2021-03-06 20:47:53 -06:00
make unaligned_reference a hard error 2022-09-30 07:54:30 -05:00			For more information about this error, try `rustc --explain E0793`.