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