Avoid an AsRef-motivated unnecessary clone

What it does

Although a perk of "AsRef" is that it enables callers to provide either T or &T as input to a function, the resolution to a non-reference type seems suboptimal if a caller clones the input argument to make this invocation possible.

A linter could identify if a calling function clones an object to provide it as an argument to an "AsRef" method - very similarly to the existing "redundant clone" lint.

Categories (optional)

• Kind: Seems like possibly perf, or style?

What is the advantage of the recommended code over the original code

• Avoids unnecessary clone.
• Instructs callers on the different usages of AsRef, a known "tricky area" for Rust newbies.

Drawbacks

None... that I know of?

Example

fn is_hello<T: AsRef<str>>(s: T) {
   assert_eq!("hello", s.as_ref());
}

let s = "hello".to_string();
is_hello(s.clone());
is_hello(s);

Could be written as:

fn is_hello<T: AsRef<str>>(s: T) {
   assert_eq!("hello", s.as_ref());
}

let s = "hello".to_string();
is_hello(&s);
is_hello(s);

Start by examining the existing "redundant clone" lint and compare its behavior with the AsRef example in this issue. Define how calls that clone an argument for an AsRef method should be detected, what recommendation should be shown, and add coverage demonstrating both the cloned and borrowed forms.