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

   1 // run-rustfix
   2
   3 #![feature(lint_reasons)]
   4 #![warn(clippy::let_unit_value)]
   5 #![allow(unused, clippy::no_effect, clippy::needless_late_init, path_statements)]
   6
   7 macro_rules! let_and_return {
   8     ($n:expr) => {{
   9         let ret = $n;
  10     }};
  11 }
  12
  13 fn main() {
  14     let _x = println!("x");
  15     let _y = 1; // this is fine
  16     let _z = ((), 1); // this as well
  17     if true {
  18         let _a = ();
  19     }
  20
  21     consume_units_with_for_loop(); // should be fine as well
  22
  23     multiline_sugg();
  24
  25     let_and_return!(()) // should be fine
  26 }
  27
  28 // Related to issue #1964
  29 fn consume_units_with_for_loop() {
  30     // `for_let_unit` lint should not be triggered by consuming them using for loop.
  31     let v = vec![(), (), ()];
  32     let mut count = 0;
  33     for _ in v {
  34         count += 1;
  35     }
  36     assert_eq!(count, 3);
  37
  38     // Same for consuming from some other Iterator<Item = ()>.
  39     let (tx, rx) = ::std::sync::mpsc::channel();
  40     tx.send(()).unwrap();
  41     drop(tx);
  42
  43     count = 0;
  44     for _ in rx.iter() {
  45         count += 1;
  46     }
  47     assert_eq!(count, 1);
  48 }
  49
  50 fn multiline_sugg() {
  51     let v: Vec<u8> = vec![2];
  52
  53     let _ = v
  54         .into_iter()
  55         .map(|i| i * 2)
  56         .filter(|i| i % 2 == 0)
  57         .map(|_| ())
  58         .next()
  59         .unwrap();
  60 }
  61
  62 #[derive(Copy, Clone)]
  63 pub struct ContainsUnit(()); // should be fine
  64
  65 fn _returns_generic() {
  66     fn f<T>() -> T {
  67         unimplemented!()
  68     }
  69     fn f2<T, U>(_: T) -> U {
  70         unimplemented!()
  71     }
  72     fn f3<T>(x: T) -> T {
  73         x
  74     }
  75     fn f5<T: Default>(x: bool) -> Option<T> {
  76         x.then(|| T::default())
  77     }
  78
  79     let _: () = f(); // Ok
  80     let x: () = f(); // Lint.
  81
  82     let _: () = f2(0i32); // Ok
  83     let x: () = f2(0i32); // Lint.
  84
  85     let _: () = f3(()); // Lint
  86     let x: () = f3(()); // Lint
  87
  88     // Should lint:
  89     // fn f4<T>(mut x: Vec<T>) -> T {
  90     //    x.pop().unwrap()
  91     // }
  92     // let _: () = f4(vec![()]);
  93     // let x: () = f4(vec![()]);
  94
  95     // Ok
  96     let _: () = {
  97         let x = 5;
  98         f2(x)
  99     };
 100
 101     let _: () = if true { f() } else { f2(0) }; // Ok
 102     let x: () = if true { f() } else { f2(0) }; // Lint
 103
 104     // Ok
 105     let _: () = match Some(0) {
 106         None => f2(1),
 107         Some(0) => f(),
 108         Some(1) => f2(3),
 109         Some(_) => f2('x'),
 110     };
 111
 112     // Lint
 113     let _: () = match Some(0) {
 114         None => f2(1),
 115         Some(0) => f(),
 116         Some(1) => f2(3),
 117         Some(_) => (),
 118     };
 119
 120     let _: () = f5(true).unwrap();
 121
 122     #[allow(clippy::let_unit_value)]
 123     {
 124         let x = f();
 125         let y;
 126         let z;
 127         match 0 {
 128             0 => {
 129                 y = f();
 130                 z = f();
 131             },
 132             1 => {
 133                 println!("test");
 134                 y = f();
 135                 z = f3(());
 136             },
 137             _ => panic!(),
 138         }
 139
 140         let x1;
 141         let x2;
 142         if true {
 143             x1 = f();
 144             x2 = x1;
 145         } else {
 146             x2 = f();
 147             x1 = x2;
 148         }
 149
 150         let opt;
 151         match f5(true) {
 152             Some(x) => opt = x,
 153             None => panic!(),
 154         };
 155
 156         #[warn(clippy::let_unit_value)]
 157         {
 158             let _: () = x;
 159             let _: () = y;
 160             let _: () = z;
 161             let _: () = x1;
 162             let _: () = x2;
 163             let _: () = opt;
 164         }
 165     }
 166
 167     let () = f();
 168 }
 169
 170 fn attributes() {
 171     fn f() {}
 172
 173     #[allow(clippy::let_unit_value)]
 174     let _ = f();
 175     #[expect(clippy::let_unit_value)]
 176     let _ = f();
 177 }