tests/ui/unnecessary_clone.rs

   1 #![warn(clippy::clone_on_ref_ptr)]
   2 #![allow(unused)]
   3
   4 use std::cell::RefCell;
   5 use std::collections::HashSet;
   6 use std::collections::VecDeque;
   7 use std::rc::{self, Rc};
   8 use std::sync::{self, Arc};
   9
  10 trait SomeTrait {}
  11 struct SomeImpl;
  12 impl SomeTrait for SomeImpl {}
  13
  14 fn main() {}
  15
  16 fn clone_on_copy() {
  17     42.clone();
  18
  19     vec![1].clone(); // ok, not a Copy type
  20     Some(vec![1]).clone(); // ok, not a Copy type
  21     (&42).clone();
  22
  23     let rc = RefCell::new(0);
  24     rc.borrow().clone();
  25
  26     // Issue #4348
  27     let mut x = 43;
  28     let _ = &x.clone(); // ok, getting a ref
  29     'a'.clone().make_ascii_uppercase(); // ok, clone and then mutate
  30 }
  31
  32 fn clone_on_ref_ptr() {
  33     let rc = Rc::new(true);
  34     let arc = Arc::new(true);
  35
  36     let rcweak = Rc::downgrade(&rc);
  37     let arc_weak = Arc::downgrade(&arc);
  38
  39     rc.clone();
  40     Rc::clone(&rc);
  41
  42     arc.clone();
  43     Arc::clone(&arc);
  44
  45     rcweak.clone();
  46     rc::Weak::clone(&rcweak);
  47
  48     arc_weak.clone();
  49     sync::Weak::clone(&arc_weak);
  50
  51     let x = Arc::new(SomeImpl);
  52     let _: Arc<dyn SomeTrait> = x.clone();
  53 }
  54
  55 fn clone_on_copy_generic<T: Copy>(t: T) {
  56     t.clone();
  57
  58     Some(t).clone();
  59 }
  60
  61 fn clone_on_double_ref() {
  62     let x = vec![1];
  63     let y = &&x;
  64     let z: &Vec<_> = y.clone();
  65
  66     println!("{:p} {:p}", *y, z);
  67 }
  68
  69 fn iter_clone_collect() {
  70     let v = [1, 2, 3, 4, 5];
  71     let v2: Vec<isize> = v.iter().cloned().collect();
  72     let v3: HashSet<isize> = v.iter().cloned().collect();
  73     let v4: VecDeque<isize> = v.iter().cloned().collect();
  74
  75     // Handle macro expansion in suggestion
  76     let _: Vec<isize> = vec![1, 2, 3].iter().cloned().collect();
  77
  78     // Issue #3704
  79     unsafe {
  80         let _: Vec<u8> = std::ffi::CStr::from_ptr(std::ptr::null())
  81             .to_bytes()
  82             .iter()
  83             .cloned()
  84             .collect();
  85     }
  86 }
  87
  88 mod many_derefs {
  89     struct A;
  90     struct B;
  91     struct C;
  92     struct D;
  93     #[derive(Copy, Clone)]
  94     struct E;
  95
  96     macro_rules! impl_deref {
  97         ($src:ident, $dst:ident) => {
  98             impl std::ops::Deref for $src {
  99                 type Target = $dst;
 100                 fn deref(&self) -> &Self::Target {
 101                     &$dst
 102                 }
 103             }
 104         };
 105     }
 106
 107     impl_deref!(A, B);
 108     impl_deref!(B, C);
 109     impl_deref!(C, D);
 110     impl std::ops::Deref for D {
 111         type Target = &'static E;
 112         fn deref(&self) -> &Self::Target {
 113             &&E
 114         }
 115     }
 116
 117     fn go1() {
 118         let a = A;
 119         let _: E = a.clone();
 120         let _: E = *****a;
 121     }
 122 }