src/tools/clippy/tests/ui/implicit_clone.fixed

   1 // run-rustfix
   2 #![warn(clippy::implicit_clone)]
   3 #![allow(clippy::clone_on_copy, clippy::redundant_clone)]
   4 use std::borrow::Borrow;
   5 use std::ffi::{OsStr, OsString};
   6 use std::path::PathBuf;
   7
   8 fn return_owned_from_slice(slice: &[u32]) -> Vec<u32> {
   9     slice.to_owned()
  10 }
  11
  12 pub fn own_same<T>(v: T) -> T
  13 where
  14     T: ToOwned<Owned = T>,
  15 {
  16     v.to_owned()
  17 }
  18
  19 pub fn own_same_from_ref<T>(v: &T) -> T
  20 where
  21     T: ToOwned<Owned = T>,
  22 {
  23     v.to_owned()
  24 }
  25
  26 pub fn own_different<T, U>(v: T) -> U
  27 where
  28     T: ToOwned<Owned = U>,
  29 {
  30     v.to_owned()
  31 }
  32
  33 #[derive(Copy, Clone)]
  34 struct Kitten;
  35 impl Kitten {
  36     // badly named method
  37     fn to_vec(self) -> Kitten {
  38         Kitten {}
  39     }
  40 }
  41 impl Borrow<BorrowedKitten> for Kitten {
  42     fn borrow(&self) -> &BorrowedKitten {
  43         static VALUE: BorrowedKitten = BorrowedKitten {};
  44         &VALUE
  45     }
  46 }
  47
  48 struct BorrowedKitten;
  49 impl ToOwned for BorrowedKitten {
  50     type Owned = Kitten;
  51     fn to_owned(&self) -> Kitten {
  52         Kitten {}
  53     }
  54 }
  55
  56 mod weird {
  57     #[allow(clippy::ptr_arg)]
  58     pub fn to_vec(v: &Vec<u32>) -> Vec<u32> {
  59         v.clone()
  60     }
  61 }
  62
  63 fn main() {
  64     let vec = vec![5];
  65     let _ = return_owned_from_slice(&vec);
  66     let _ = vec.clone();
  67     let _ = vec.clone();
  68
  69     let vec_ref = &vec;
  70     let _ = return_owned_from_slice(vec_ref);
  71     let _ = vec_ref.clone();
  72     let _ = vec_ref.clone();
  73
  74     // we expect no lint for this
  75     let _ = weird::to_vec(&vec);
  76
  77     // we expect no lints for this
  78     let slice: &[u32] = &[1, 2, 3, 4, 5];
  79     let _ = return_owned_from_slice(slice);
  80     let _ = slice.to_owned();
  81     let _ = slice.to_vec();
  82
  83     let str = "hello world".to_string();
  84     let _ = str.clone();
  85
  86     // testing w/ an arbitrary type
  87     let kitten = Kitten {};
  88     let _ = kitten.clone();
  89     let _ = own_same_from_ref(&kitten);
  90     // this shouln't lint
  91     let _ = kitten.to_vec();
  92
  93     // we expect no lints for this
  94     let borrowed = BorrowedKitten {};
  95     let _ = borrowed.to_owned();
  96
  97     let pathbuf = PathBuf::new();
  98     let _ = pathbuf.clone();
  99     let _ = pathbuf.clone();
 100
 101     let os_string = OsString::from("foo");
 102     let _ = os_string.clone();
 103     let _ = os_string.clone();
 104
 105     // we expect no lints for this
 106     let os_str = OsStr::new("foo");
 107     let _ = os_str.to_owned();
 108     let _ = os_str.to_os_string();
 109
 110     // issue #8227
 111     let pathbuf_ref = &pathbuf;
 112     let pathbuf_ref = &pathbuf_ref;
 113     let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&PathBuf`
 114     let _ = (*pathbuf_ref).clone();
 115     let pathbuf_ref = &pathbuf_ref;
 116     let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&&PathBuf`
 117     let _ = (**pathbuf_ref).clone();
 118 }