tests/ui/while_let_on_iterator.rs

   1 // run-rustfix
   2
   3 #![warn(clippy::while_let_on_iterator)]
   4 #![allow(clippy::never_loop, unreachable_code, unused_mut)]
   5 #![feature(or_patterns)]
   6
   7 fn base() {
   8     let mut iter = 1..20;
   9     while let Option::Some(x) = iter.next() {
  10         println!("{}", x);
  11     }
  12
  13     let mut iter = 1..20;
  14     while let Some(x) = iter.next() {
  15         println!("{}", x);
  16     }
  17
  18     let mut iter = 1..20;
  19     while let Some(_) = iter.next() {}
  20
  21     let mut iter = 1..20;
  22     while let None = iter.next() {} // this is fine (if nonsensical)
  23
  24     let mut iter = 1..20;
  25     if let Some(x) = iter.next() {
  26         // also fine
  27         println!("{}", x)
  28     }
  29
  30     // the following shouldn't warn because it can't be written with a for loop
  31     let mut iter = 1u32..20;
  32     while let Some(_) = iter.next() {
  33         println!("next: {:?}", iter.next())
  34     }
  35
  36     // neither can this
  37     let mut iter = 1u32..20;
  38     while let Some(_) = iter.next() {
  39         println!("next: {:?}", iter.next());
  40     }
  41
  42     // or this
  43     let mut iter = 1u32..20;
  44     while let Some(_) = iter.next() {
  45         break;
  46     }
  47     println!("Remaining iter {:?}", iter);
  48
  49     // or this
  50     let mut iter = 1u32..20;
  51     while let Some(_) = iter.next() {
  52         iter = 1..20;
  53     }
  54 }
  55
  56 // Issue #1188
  57 fn refutable() {
  58     let a = [42, 1337];
  59     let mut b = a.iter();
  60
  61     // consume all the 42s
  62     while let Some(&42) = b.next() {}
  63
  64     let a = [(1, 2, 3)];
  65     let mut b = a.iter();
  66
  67     while let Some(&(1, 2, 3)) = b.next() {}
  68
  69     let a = [Some(42)];
  70     let mut b = a.iter();
  71
  72     while let Some(&None) = b.next() {}
  73
  74     /* This gives “refutable pattern in `for` loop binding: `&_` not covered”
  75     for &42 in b {}
  76     for &(1, 2, 3) in b {}
  77     for &Option::None in b.next() {}
  78     // */
  79 }
  80
  81 fn refutable2() {
  82     // Issue 3780
  83     {
  84         let v = vec![1, 2, 3];
  85         let mut it = v.windows(2);
  86         while let Some([x, y]) = it.next() {
  87             println!("x: {}", x);
  88             println!("y: {}", y);
  89         }
  90
  91         let mut it = v.windows(2);
  92         while let Some([x, ..]) = it.next() {
  93             println!("x: {}", x);
  94         }
  95
  96         let mut it = v.windows(2);
  97         while let Some([.., y]) = it.next() {
  98             println!("y: {}", y);
  99         }
 100
 101         let mut it = v.windows(2);
 102         while let Some([..]) = it.next() {}
 103
 104         let v = vec![[1], [2], [3]];
 105         let mut it = v.iter();
 106         while let Some([1]) = it.next() {}
 107
 108         let mut it = v.iter();
 109         while let Some([_x]) = it.next() {}
 110     }
 111
 112     // binding
 113     {
 114         let v = vec![1, 2, 3];
 115         let mut it = v.iter();
 116         while let Some(x @ 1) = it.next() {
 117             println!("{}", x);
 118         }
 119
 120         let v = vec![[1], [2], [3]];
 121         let mut it = v.iter();
 122         while let Some(x @ [_]) = it.next() {
 123             println!("{:?}", x);
 124         }
 125     }
 126
 127     // false negative
 128     {
 129         let v = vec![1, 2, 3];
 130         let mut it = v.iter().map(Some);
 131         while let Some(Some(_) | None) = it.next() {
 132             println!("1");
 133         }
 134     }
 135 }
 136
 137 fn nested_loops() {
 138     let a = [42, 1337];
 139     let mut y = a.iter();
 140     loop {
 141         // x is reused, so don't lint here
 142         while let Some(_) = y.next() {}
 143     }
 144
 145     let mut y = a.iter();
 146     for _ in 0..2 {
 147         while let Some(_) = y.next() {
 148             // y is reused, don't lint
 149         }
 150     }
 151
 152     loop {
 153         let mut y = a.iter();
 154         while let Some(_) = y.next() {
 155             // use a for loop here
 156         }
 157     }
 158 }
 159
 160 fn issue1121() {
 161     use std::collections::HashSet;
 162     let mut values = HashSet::new();
 163     values.insert(1);
 164
 165     while let Some(&value) = values.iter().next() {
 166         values.remove(&value);
 167     }
 168 }
 169
 170 fn issue2965() {
 171     // This should not cause an ICE and suggest:
 172     //
 173     // for _ in values.iter() {}
 174     //
 175     use std::collections::HashSet;
 176     let mut values = HashSet::new();
 177     values.insert(1);
 178
 179     while let Some(..) = values.iter().next() {}
 180 }
 181
 182 fn issue3670() {
 183     let array = [Some(0), None, Some(1)];
 184     let mut iter = array.iter();
 185
 186     while let Some(elem) = iter.next() {
 187         let _ = elem.or_else(|| *iter.next()?);
 188     }
 189 }
 190
 191 fn issue1654() {
 192     // should not lint if the iterator is generated on every iteration
 193     use std::collections::HashSet;
 194     let mut values = HashSet::new();
 195     values.insert(1);
 196
 197     while let Some(..) = values.iter().next() {
 198         values.remove(&1);
 199     }
 200
 201     while let Some(..) = values.iter().map(|x| x + 1).next() {}
 202
 203     let chars = "Hello, World!".char_indices();
 204     while let Some((i, ch)) = chars.clone().next() {
 205         println!("{}: {}", i, ch);
 206     }
 207 }
 208
 209 fn main() {
 210     base();
 211     refutable();
 212     refutable2();
 213     nested_loops();
 214     issue1121();
 215     issue2965();
 216     issue3670();
 217     issue1654();
 218 }