lint unnecessary derefs

[birkenfeld]

I've seen uses of &*s where s is a String; this can be reduced to &s when calling a function that accepts &str.

Similarly, in the AST, I've seen (in clippy and racer) &**x or &*x where just x or &x is fine; call syntax will autoderef a &P<T> to a &T.

However, I don't really know yet how to do this in a general way.

[llogiq]

I do have some instances of this in shadow.rs; however, I only added those because rustc would not compile it otherwise. Even knowing the general rules of auto-deref, I am not convinced I understand all the strange corner cases.

So unless we use a blacklist (same old, same old 😄), we'll have a real hard time trying to avert false positives.

[birkenfeld]

Yeah, as far as I understand it, the adjustment is done for function arguments and method/field lookup. But inner types are not adjusted, so once you have Option<P<...>> you need to do the dance manually.

This would have to check function arguments against the parameter types, and we'll have to find if rustc provides an API that does the "is type A compatible with type B after adjusting" check. If it doesn't, this is going to be hard :)

[llogiq]

Agreed, you either end up building your own types at runtime (hard) or rewriting most of the type adjustment logic (probably harder).

[fpoli]

Even just supporting the case &*s where s is a String would be very useful. For new Rust users it's usually difficult to use the various string types correctly, and String is probably one of the most common types that implement a custom Deref.

[lengyijun]

I wonder if &*String => &String is really good?
&*String always return &str
&String return &str or &String

[fpoli]

I wonder if &*String => &String is really good?
&*String always return &str
&String return &str or &String

That's a good point. The lint could be reported only if &*String expression is in the place of a method argument that requires &str.

[lengyijun]

let mut v=vec![];
// they are different!
v.push(s);
v.push(&**s); 

We need to ignore function with generic type.