False positive with use_self and generics

[daboross]

As far as I can tell, the use_self is incorrectly ignoring generic parameters when implementing traits for some types with generics.

Here's my example:

pub trait PhaseTransform<T>: Sized {
    fn transform_from(v: T) -> Self;
}

pub struct IntermediatePhase;

pub struct FinalPhase;

impl PhaseTransform<Vec<IntermediatePhase>> for Vec<FinalPhase> {
    fn transform_from(_: Vec<IntermediatePhase>) -> Self {
        unimplemented!()
    }
}

impl<T> PhaseTransform<Vec<IntermediatePhase>> for Vec<T>
where
    T: PhaseTransform<FinalPhase>,
{
    fn transform_from(intermediates: Vec<IntermediatePhase>) -> Self {
        <Vec<FinalPhase>>::transform_from(intermediates)
            .into_iter()
            .map(PhaseTransform::transform_from)
            .collect()
    }
}

This, as far as I can tell, uses Self as much as possible. But with -W clippy::pedantic, clippy warns of three more places where it thinks I should be able to use Self:

$ cargo clippy -- -W clippy::pedantic
    Checking clippy-false-positive-test v0.1.0 (/home/daboross/clippy-false-positive-test)                                              
warning: unnecessary structure name repetition                                                                                          
  --> src/lib.rs:10:26                                                                                                                  
   |                                                                                                                                    
10 |     fn transform_from(_: Vec<IntermediatePhase>) -> Self {                                                                         
   |                          ^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`                                           
   |                                                                                                                                    
   = note: `-W clippy::use-self` implied by `-W clippy::pedantic`                                                                       
   = help: for further information visit https://rust-lang-nursery.github.io/rust-clippy/v0.0.212/index.html#use_self                   
                                                                                                                                        
warning: unnecessary structure name repetition                                                                                          
  --> src/lib.rs:19:38                                                                                                                  
   |                                                                                                                                    
19 |     fn transform_from(intermediates: Vec<IntermediatePhase>) -> Self {                                                             
   |                                      ^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`                               
   |                                                                                                                                    
   = help: for further information visit https://rust-lang-nursery.github.io/rust-clippy/v0.0.212/index.html#use_self                   
                                                                                                                                        
warning: unnecessary structure name repetition                                                                                          
  --> src/lib.rs:20:10                                                                                                                  
   |                                                                                                                                    
20 |         <Vec<FinalPhase>>::transform_from(intermediates)                                                                           
   |          ^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`                                                                  
   |                                                                                                                                    
   = help: for further information visit https://rust-lang-nursery.github.io/rust-clippy/v0.0.212/index.html#use_self                   
                                                                                                                                        
    Finished dev [unoptimized + debuginfo] target(s) in 0.21s

There are two mistakes: it's treating Vec<IntermediatePhase> as Vec<FinalPhase>, and it's treating Vec<FinalPhase> as Vec<T>.

Hope the example is minimal enough - my original trigger was with a custom trait like this, and it seemed hard to come up with any other reasonable use case which caused this situation.

Clippy version:

$ cargo clippy -V                    
clippy 0.0.212 (b1d0343 2018-10-19)

Related to #1993.

Here is a another example that doesn't involve traits.

#![warn(clippy::use_self)]
#![allow(dead_code)]

struct S<T> {
    t: T
}

impl S<u64> {
    fn foo(_: S<u32>) {
        let _: S<u32>;
    }
}

warning: unnecessary structure name repetition
 --> src/main.rs:9:15
  |
9 |     fn foo(_: S<u32>) {
  |               ^^^^^^ help: use the applicable keyword: `Self`
  |
note: lint level defined here
 --> src/main.rs:1:9
  |
1 | #![warn(clippy::use_self)]
  |         ^^^^^^^^^^^^^^^^
  = help: for further information visit https://rust-lang-nursery.github.io/rust-clippy/v0.0.212/index.html#use_self

warning: unnecessary structure name repetition
  --> src/main.rs:10:16
   |
10 |         let _: S<u32>;
   |                ^^^^^^ help: use the applicable keyword: `Self`
   |
   = help: for further information visit https://rust-lang-nursery.github.io/rust-clippy/v0.0.212/index.html#use_self

Playground

The problem is that the code checks if two paths refer to the same type by comparing the defs but this doesn't account for generics.

https://github.com/rust-lang-nursery/rust-clippy/blob/4c3408c61d1042bf0585de440041ee7edfc5b350/clippy_lints/src/use_self.rs#L221

I couldn't find a way to get the actual type including type parameters for a general path. Maybe someone has a suggestion.

I can see how to handle this for types in function signatures though. I'll submit a PR for that later.

[zroug]

Not involving generics but another false positive:

#![warn(clippy::use_self)]
#![allow(dead_code)]

#[derive(Clone)]
struct S;

impl S {
    fn foo() {
        impl Copy for S {}
    }
}

fn main() {}

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=b33a49bdb926b36be6c2fbad5defe205

warning: unnecessary structure name repetition
 --> src/main.rs:9:23
  |
9 |         impl Copy for S {}
  |                       ^ help: use the applicable keyword: `Self`
  |

With generics, the error also happens with associated types:

#![warn(clippy::use_self)]
#![allow(dead_code)]

struct S<T1, T2> {
    t1: T1,
    t2: T2,
}

impl<T1: Copy, T2: Copy> Iterator for S<T1, T2> {
    type Item = S<T2, T1>;
    fn next(&mut self) -> Option<Self::Item> {
        Some(S {
            t1: self.t2,
            t2: self.t1,
        })
    }
}

fn main() {}

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=42f001263b6139a9333c08290ccd188c

warning: unnecessary structure name repetition
  --> src/main.rs:10:17
   |
10 |     type Item = S<T2, T1>;
   |                 ^^^^^^^^^ help: use the applicable keyword: `Self`
   |

warning: unnecessary structure name repetition
  --> src/main.rs:12:14
   |
12 |         Some(S {
   |              ^ help: use the applicable keyword: `Self`
   |

(Both warnings are wrong.)

[zroug]

I couldn't find a way to get the actual type including type parameters for a general path. Maybe someone has a suggestion.

I don't know how to do that but there is a pull request #1997. There was no activity for a long time but there is a bit of discussion.

[eddyb]

IMO clippy should just use hir_ty_to_ty until a query alternative is provided.
This should be considered an essential operation and clippy should make use of it as much as possible.

It's unnecessary to compare hir::Tys in intricate manners when you can just get a Ty and == it.

[tnielens]

I started working on this based on the recommendation and example committed by @eddyb .