Add new lint: cloned_ref_to_slice_refs

[asdfish]

Added lint for catching &[foo.clone()] where foo is a reference and suggests std::slice::from_ref(foo).

changelog: new lint: [cloned_ref_to_slice_refs]

[rustbot]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @blyxyas (or someone else) some time within the next two weeks.

Please see the contribution instructions for more information. Namely, in order to ensure the minimum review times lag, PR authors and assigned reviewers should ensure that the review label (S-waiting-on-review and S-waiting-on-author) stays updated, invoking these commands when appropriate:

• @rustbot author: the review is finished, PR author should check the comments and take action accordingly
• @rustbot review: the author is ready for a review, this PR will be queued again in the reviewer's queue

[samueltardieu]

Thanks for your PR. Here is a first cursory review.

[blyxyas]

I'll have to reroll this one, I'm having capacity problems right now.

r? clippy

[samueltardieu]

The following code will trigger a false positive, as the suggested fix would take a reference on x which would be alive when x is pushed to:

fn main() {
    let mut x = String::from("Hello");
    let r = &[x.clone()];
    x.push('!');
    println!("r = `{}', x = `{x}'", r[0]);
}

The lint should trigger only when the receiver of .clone() is immutable, as it is reasonable to assume that .clone() would build an identical copy from a practical point of view.

Also, the commits should be (squashed and) rebased onto master, as some changes in the MSRV handling have happened since and the code won't compile as-is.

[llogiq]

Can you please squash your commits? Also I think there are utility functions to detect interior mutability, which would allow us to remove this particular false-positive. But I'm ok with doing that in a followup PR.

[asdfish]

I'm unsure if the lint should even differenciate between clones that have interior mutability.

These two do the same thing.

fn increment(list: &[Arc<Mutex<i32>>]) {
    list.iter().for_each(|i| *i.lock().unwrap() += 1);
}

{
    let x = Arc::new(Mutex::new(1));
    let list = std::slice::from_ref(&x);
    increment(list);
}
{
    let x = Arc::new(Mutex::new(1));
    let list = &[x.clone()]; // same thing but with reference counting overhead
    increment(list);
}

[llogiq]

I am completely unconcerned about Rc or Arc here, more about the possibility that a custom type with interior mutability might be used and modified later so that the clone becomes observable because unless cloned, the original value gets modified.

[llogiq]

That said, let's merge this, we can do interior mutability detection in a follow-up PR.