src/tools/clippy/tests/ui/map_clone.rs

   1
   2
   3
   4 #![warn(map_clone)]
   5
   6 #![allow(clone_on_copy, unused)]
   7
   8 use std::ops::Deref;
   9
  10 fn map_clone_iter() {
  11     let x = [1,2,3];
  12     x.iter().map(|y| y.clone());
  13
  14     x.iter().map(|&y| y);
  15
  16     x.iter().map(|y| *y);
  17
  18     x.iter().map(|y| { y.clone() });
  19
  20     x.iter().map(|&y| { y });
  21
  22     x.iter().map(|y| { *y });
  23
  24     x.iter().map(Clone::clone);
  25
  26 }
  27
  28 fn map_clone_option() {
  29     let x = Some(4);
  30     x.as_ref().map(|y| y.clone());
  31
  32     x.as_ref().map(|&y| y);
  33
  34     x.as_ref().map(|y| *y);
  35
  36 }
  37
  38 fn not_linted_option() {
  39     let x = Some(5);
  40
  41     // Not linted: other statements
  42     x.as_ref().map(|y| {
  43         println!("y: {}", y);
  44         y.clone()
  45     });
  46
  47     // Not linted: argument bindings
  48     let x = Some((6, 7));
  49     x.map(|(y, _)| y.clone());
  50
  51     // Not linted: cloning something else
  52     x.map(|y| y.0.clone());
  53
  54     // Not linted: no dereferences
  55     x.map(|y| y);
  56
  57     // Not linted: multiple dereferences
  58     let _: Option<(i32, i32)> = x.as_ref().as_ref().map(|&&x| x);
  59 }
  60
  61 #[derive(Copy, Clone)]
  62 struct Wrapper<T>(T);
  63 impl<T> Wrapper<T> {
  64     fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Wrapper<U> {
  65         Wrapper(f(self.0))
  66     }
  67 }
  68
  69 fn map_clone_other() {
  70     let eight = 8;
  71     let x = Wrapper(&eight);
  72
  73     // Not linted: not a linted type
  74     x.map(|y| y.clone());
  75     x.map(|&y| y);
  76     x.map(|y| *y);
  77 }
  78
  79 #[derive(Copy, Clone)]
  80 struct UnusualDeref;
  81 static NINE: i32 = 9;
  82
  83 impl Deref for UnusualDeref {
  84     type Target = i32;
  85     fn deref(&self) -> &i32 { &NINE }
  86 }
  87
  88 fn map_clone_deref() {
  89     let x = Some(UnusualDeref);
  90     let _: Option<UnusualDeref> = x.as_ref().map(|y| *y);
  91
  92
  93     // Not linted: using deref conversion
  94     let _: Option<i32> = x.map(|y| *y);
  95
  96     // Not linted: using regular deref but also deref conversion
  97     let _: Option<i32> = x.as_ref().map(|y| **y);
  98 }
  99
 100 // stuff that used to be a false positive
 101 fn former_false_positive() {
 102     vec![1].iter_mut().map(|x| *x); // #443
 103 }
 104
 105 fn main() { }