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
  27 fn clone_on_ref_ptr() {
  28     let rc = Rc::new(true);
  29     let arc = Arc::new(true);
  30
  31     let rcweak = Rc::downgrade(&rc);
  32     let arc_weak = Arc::downgrade(&arc);
  33
  34     rc.clone();
  35     Rc::clone(&rc);
  36
  37     arc.clone();
  38     Arc::clone(&arc);
  39
  40     rcweak.clone();
  41     rc::Weak::clone(&rcweak);
  42
  43     arc_weak.clone();
  44     sync::Weak::clone(&arc_weak);
  45
  46     let x = Arc::new(SomeImpl);
  47     let _: Arc<dyn SomeTrait> = x.clone();
  48 }
  49
  50 fn clone_on_copy_generic<T: Copy>(t: T) {
  51     t.clone();
  52
  53     Some(t).clone();
  54 }
  55
  56 fn clone_on_double_ref() {
  57     let x = vec![1];
  58     let y = &&x;
  59     let z: &Vec<_> = y.clone();
  60
  61     println!("{:p} {:p}", *y, z);
  62 }
  63
  64 fn iter_clone_collect() {
  65     let v = [1, 2, 3, 4, 5];
  66     let v2: Vec<isize> = v.iter().cloned().collect();
  67     let v3: HashSet<isize> = v.iter().cloned().collect();
  68     let v4: VecDeque<isize> = v.iter().cloned().collect();
  69
  70     // Handle macro expansion in suggestion
  71     let _: Vec<isize> = vec![1, 2, 3].iter().cloned().collect();
  72
  73     // Issue #3704
  74     unsafe {
  75         let _: Vec<u8> = std::ffi::CStr::from_ptr(std::ptr::null())
  76             .to_bytes()
  77             .iter()
  78             .cloned()
  79             .collect();
  80     }
  81 }
  82
  83 mod many_derefs {
  84     struct A;
  85     struct B;
  86     struct C;
  87     struct D;
  88     #[derive(Copy, Clone)]
  89     struct E;
  90
  91     macro_rules! impl_deref {
  92         ($src:ident, $dst:ident) => {
  93             impl std::ops::Deref for $src {
  94                 type Target = $dst;
  95                 fn deref(&self) -> &Self::Target {
  96                     &$dst
  97                 }
  98             }
  99         };
 100     }
 101
 102     impl_deref!(A, B);
 103     impl_deref!(B, C);
 104     impl_deref!(C, D);
 105     impl std::ops::Deref for D {
 106         type Target = &'static E;
 107         fn deref(&self) -> &Self::Target {
 108             &&E
 109         }
 110     }
 111
 112     fn go1() {
 113         let a = A;
 114         let _: E = a.clone();
 115         let _: E = *****a;
 116     }
 117 }