Unnecessary references lint

[obeis]

Close #127724

[rustbot]

r? @Noratrieb

rustbot has assigned @Noratrieb.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

[rustbot]

These commits modify the Cargo.lock file. Unintentional changes to Cargo.lock can be introduced when switching branches and rebasing PRs.

If this was unintentional then you should revert the changes before this PR is merged.
Otherwise, you can ignore this comment.

[compiler-errors]

This lint seems really specific to a single kind of expression, and there are plenty of other cases where unnecessary references are created when the user is trying to create a raw pointer. Unless this can be greatly generalized, it doesn't really seem worth adding this.

[compiler-errors]

r? RalfJung

[obeis]

I agree, and my intention is to generalize this lint to cover all unnecessarily created references. Could you please list other cases that you think should be included? I can update this PR to cover them or create an issue to track these cases and mention that they should be added to the unnecessary_refs lint.

[RalfJung]

Sorry, I am swamped. Happy to discuss which cases the lint shoild fire on, but I can't review the implementation. r? compiler

[SparrowLii]

I know little about lints' impls so r? compiler

[RalfJung]

Do we have some people who are our "linting experts"?

[RalfJung]

This lint seems really specific to a single kind of expression, and there are plenty of other cases where unnecessary references are created when the user is trying to create a raw pointer. Unless this can be greatly generalized, it doesn't really seem worth adding this.

Which examples did you have in mind?

A starting point might be to uplift https://rust-lang.github.io/rust-clippy/master/index.html#borrow_as_ptr from cliippy to rustc, as you mention. It is not clear to me what the difference is between that lint and this one.

[traviscross]

Do we have some people who are our "linting experts"?

cc @Urgau

[Urgau]

Happy to take over the review. If @Nadrieril doesn't want to review it of course.

As for the lint it-self, I join @RalfJung that this is lint is currently clippy::borrow_as_ptr, which will need to be dropped from clippy. Look at 1fee1a4 for the changes needed.

As a drive-by, rustc_hir_pretty should not be necessary, a multi-part suggestion should be used instead, with some span manipulation to get the correct spans.

[Nadrieril]

Much appreciated :) r? @Urgau

[rustbot]

Some changes occurred to the intrinsics. Make sure the CTFE / Miri interpreter
gets adapted for the changes, if necessary.

cc @rust-lang/miri, @RalfJung, @oli-obk, @lcnr

[obeis]

I ran x test on my machine, and everything passed. Why is it failing here, and how can I reproduce those errors locally?

[RalfJung]

Maybe try rebasing over the latest master, CI will test your code merged with that and there might be semantic conflicts.

[rust-log-analyzer]

The job x86_64-gnu-tools failed! Check out the build log: (web) (plain)

Click to see the possible cause of the failure (guessed by this bot)

[RUSTC-TIMING] build_script_build test:false 0.334
error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
  --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
   |
5  | / macro_rules! simd_ty {
6  | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7  | |         #[repr(simd)]
8  | |         #[derive(Copy, Clone, Debug, PartialEq)]
...  |
44 | |                 let self_ptr = &self as *const Self as *const $elem_type;
   | |                                ^^^^^^^^^^^^^^^^^^^^
...  |
51 | | }
   | |_- in this expansion of `simd_ty!`
...
88 |   simd_ty!(u8x2[u8;2]: x0, x1);
   |   ---------------------------- in this macro invocation
   |
   = note: `-D unnecessary-refs` implied by `-D warnings`
   = help: to override `-D warnings` add `#[allow(unnecessary_refs)]`
help: consider using `&raw const` for a safer and more explicit raw pointer
   |
44 -                 let self_ptr = &self as *const Self as *const $elem_type;
44 +                 let self_ptr = &raw const self as *const $elem_type;
   |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
  --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
   |
5  | / macro_rules! simd_ty {
6  | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7  | |         #[repr(simd)]
8  | |         #[derive(Copy, Clone, Debug, PartialEq)]
...  |
44 | |                 let self_ptr = &self as *const Self as *const $elem_type;
   | |                                ^^^^^^^^^^^^^^^^^^^^
...  |
51 | | }
   | |_- in this expansion of `simd_ty!`
...
89 |   simd_ty!(i8x2[i8;2]: x0, x1);
   |   ---------------------------- in this macro invocation
   |
help: consider using `&raw const` for a safer and more explicit raw pointer
   |
44 -                 let self_ptr = &self as *const Self as *const $elem_type;
44 +                 let self_ptr = &raw const self as *const $elem_type;
   |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
  --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
   |
5  | / macro_rules! simd_ty {
6  | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7  | |         #[repr(simd)]
8  | |         #[derive(Copy, Clone, Debug, PartialEq)]
...  |
44 | |                 let self_ptr = &self as *const Self as *const $elem_type;
   | |                                ^^^^^^^^^^^^^^^^^^^^
...  |
51 | | }
   | |_- in this expansion of `simd_ty!`
...
93 |   simd_ty!(u8x4[u8;4]: x0, x1, x2, x3);
   |   ------------------------------------ in this macro invocation
   |
help: consider using `&raw const` for a safer and more explicit raw pointer
   |
44 -                 let self_ptr = &self as *const Self as *const $elem_type;
44 +                 let self_ptr = &raw const self as *const $elem_type;
   |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
  --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
   |
5  | / macro_rules! simd_ty {
6  | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7  | |         #[repr(simd)]
8  | |         #[derive(Copy, Clone, Debug, PartialEq)]
...  |
44 | |                 let self_ptr = &self as *const Self as *const $elem_type;
   | |                                ^^^^^^^^^^^^^^^^^^^^
...  |
51 | | }
   | |_- in this expansion of `simd_ty!`
...
94 |   simd_ty!(u16x2[u16;2]: x0, x1);
   |   ------------------------------ in this macro invocation
   |
help: consider using `&raw const` for a safer and more explicit raw pointer
   |
44 -                 let self_ptr = &self as *const Self as *const $elem_type;
44 +                 let self_ptr = &raw const self as *const $elem_type;
   |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
  --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
   |
5  | / macro_rules! simd_ty {
6  | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7  | |         #[repr(simd)]
8  | |         #[derive(Copy, Clone, Debug, PartialEq)]
...  |
44 | |                 let self_ptr = &self as *const Self as *const $elem_type;
   | |                                ^^^^^^^^^^^^^^^^^^^^
...  |
51 | | }
   | |_- in this expansion of `simd_ty!`
...
96 |   simd_ty!(i8x4[i8;4]: x0, x1, x2, x3);
   |   ------------------------------------ in this macro invocation
   |
help: consider using `&raw const` for a safer and more explicit raw pointer
   |
44 -                 let self_ptr = &self as *const Self as *const $elem_type;
44 +                 let self_ptr = &raw const self as *const $elem_type;
   |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
  --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
   |
5  | / macro_rules! simd_ty {
6  | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7  | |         #[repr(simd)]
8  | |         #[derive(Copy, Clone, Debug, PartialEq)]
...  |
44 | |                 let self_ptr = &self as *const Self as *const $elem_type;
   | |                                ^^^^^^^^^^^^^^^^^^^^
...  |
51 | | }
   | |_- in this expansion of `simd_ty!`
...
97 |   simd_ty!(i16x2[i16;2]: x0, x1);
   |   ------------------------------ in this macro invocation
   |
help: consider using `&raw const` for a safer and more explicit raw pointer
   |
44 -                 let self_ptr = &self as *const Self as *const $elem_type;
44 +                 let self_ptr = &raw const self as *const $elem_type;
   |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
101 | / simd_ty!(
102 | |     u8x8[u8;8]:
103 | |     x0,
104 | |     x1,
...   |
110 | |     x7
111 | | );
    | |_- in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
112 |   simd_ty!(u16x4[u16;4]: x0, x1, x2, x3);
    |   -------------------------------------- in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
113 |   simd_ty!(u32x2[u32;2]: x0, x1);
    |   ------------------------------ in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
114 |   simd_ty!(u64x1[u64;1]: x1);
    |   -------------------------- in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
116 | / simd_ty!(
117 | |     i8x8[i8;8]:
118 | |     x0,
119 | |     x1,
...   |
125 | |     x7
126 | | );
    | |_- in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
127 |   simd_ty!(i16x4[i16;4]: x0, x1, x2, x3);
    |   -------------------------------------- in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
128 |   simd_ty!(i32x2[i32;2]: x0, x1);
    |   ------------------------------ in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
129 |   simd_ty!(i64x1[i64;1]: x1);
    |   -------------------------- in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
131 |   simd_ty!(f32x2[f32;2]: x0, x1);
    |   ------------------------------ in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
132 |   simd_ty!(f64x1[f64;1]: x1);
    |   -------------------------- in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
136 | / simd_ty!(
137 | |     u8x16[u8;16]:
138 | |     x0,
139 | |     x1,
...   |
153 | |     x15
154 | | );
    | |_- in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
155 | / simd_ty!(
156 | |     u16x8[u16;8]:
157 | |     x0,
158 | |     x1,
...   |
164 | |     x7
165 | | );
    | |_- in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
166 |   simd_ty!(u32x4[u32;4]: x0, x1, x2, x3);
    |   -------------------------------------- in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`
...
167 |   simd_ty!(u64x2[u64;2]: x0, x1);
    |   ------------------------------ in this macro invocation
    |
help: consider using `&raw const` for a safer and more explicit raw pointer
    |
44  -                 let self_ptr = &self as *const Self as *const $elem_type;
44  +                 let self_ptr = &raw const self as *const $elem_type;
    |

error: creating a intermediate reference implies aliasing requirements even when immediately casting to raw pointers
   --> library/core/src/../../stdarch/crates/core_arch/src/simd.rs:44:32
    |
5   | / macro_rules! simd_ty {
6   | |     ($id:ident [$elem_type:ty ; $len:literal]: $($param_name:ident),*) => {
7   | |         #[repr(simd)]
8   | |         #[derive(Copy, Clone, Debug, PartialEq)]
...   |
44  | |                 let self_ptr = &self as *const Self as *const $elem_type;
    | |                                ^^^^^^^^^^^^^^^^^^^^
...   |
51  | | }
    | |_- in this expansion of `simd_ty!`

[bors]

☔ The latest upstream changes (presumably #139012) made this pull request unmergeable. Please resolve the merge conflicts.

[obeis]

My PR is currently blocked because the stdarch bump is waiting on a bootstrap bump, see this.