`dangerous_implicit_autorefs` suggestion is wrong

[wyfo]

The following code:

unsafe fn slice_ptr_len_because_of_msrv<T>(slice: *const [T]) -> usize {
    unsafe { (*slice)[..].len() }
}

gives the two following warnings

warning: implicit autoref creates a reference to the dereference of a raw pointer
 --> src/main.rs:2:14
  |
2 |     unsafe { (*slice)[..].len() }
  |              ^^^^^^^^^^^^^^^^^^
  |
  = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
  = note: `#[warn(dangerous_implicit_autorefs)]` on by default
help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
  |
2 |     unsafe { (&(*slice)[..]).len() }
  |              ++            +

warning: implicit autoref creates a reference to the dereference of a raw pointer
 --> src/main.rs:2:14
  |
2 |     unsafe { (*slice)[..].len() }
  |              ^^^^^^^^^^^^
  |
  = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
  |
2 |     unsafe { (&(*slice))[..].len() }
  |              ++        +

I the first warning is quite a duplicate of the second one, and its suggestion is also wrong, as (&(*slice)[..]).len() would still trigger the warning.

See also:

• Implement a lint for implicit autoref of raw pointer dereference - take 2 #123239
• Implement a lint for implicit autoref of raw pointer dereference  #103735 (comment)

[Urgau]

The two warnings are not duplicated. They warn on two different part of the expression.

Applying both suggestions make the warnings disappear.

unsafe fn slice_ptr_len_because_of_msrv<T>(slice: *const [T]) -> usize {
    unsafe { (&(&(*slice))[..]).len() }
}

[wyfo]

I may be wrong, but the way I understand the first warning is that it indicates that the autoref happens between (*slice)[..] and .len() (hence the fix with (&(*slice)[..]).len()), which is wrong.
There is only one place where the autoref happens in the expression, so I think there should be only one warning.
By the way, you can as much additional warning that you want by adding [..].

[Jarcho]

The autoref actually happens on the slice operation (*slice)[..]. This is a call to <[T] as Index<RangeFull>>::index which takes &[T]. The compiler warning twice is definitely wrong since the call to len happens on the result of *Index::index(..) which is a deref of a reference.

[Urgau]

For the compiler, *Index::index(..) does not exist, more precisely in the HIR the output type of (*slice)[..] is [T], there is no implicit or explicit deref.

And because the len function is marked with #[rustc_no_implicit_refs] (and we peel the [..], rule 2. peel place expressions) we then see the deref of a raw pointer and lint on it.

It's unclear to me if it's a bug.

cc @traviscross