src/test/ui/drop/drop_order.rs

   1 // run-pass
   2 // compile-flags: -Z validate-mir
   3 #![feature(let_chains)]
   4
   5 use std::cell::RefCell;
   6 use std::convert::TryInto;
   7
   8 #[derive(Default)]
   9 struct DropOrderCollector(RefCell<Vec<u32>>);
  10
  11 struct LoudDrop<'a>(&'a DropOrderCollector, u32);
  12
  13 impl Drop for LoudDrop<'_> {
  14     fn drop(&mut self) {
  15         println!("{}", self.1);
  16         self.0.0.borrow_mut().push(self.1);
  17     }
  18 }
  19
  20 impl DropOrderCollector {
  21     fn option_loud_drop(&self, n: u32) -> Option<LoudDrop> {
  22         Some(LoudDrop(self, n))
  23     }
  24
  25     fn loud_drop(&self, n: u32) -> LoudDrop {
  26         LoudDrop(self, n)
  27     }
  28
  29     fn print(&self, n: u32) {
  30         println!("{}", n);
  31         self.0.borrow_mut().push(n)
  32     }
  33
  34     fn if_(&self) {
  35         if self.option_loud_drop(1).is_some() {
  36             self.print(2);
  37         }
  38
  39         if self.option_loud_drop(3).is_none() {
  40             unreachable!();
  41         } else if self.option_loud_drop(4).is_some() {
  42             self.print(5);
  43         }
  44
  45         if {
  46             if self.option_loud_drop(6).is_some() && self.option_loud_drop(7).is_some() {
  47                 self.loud_drop(8);
  48                 true
  49             } else {
  50                 false
  51             }
  52         } {
  53             self.print(9);
  54         }
  55     }
  56
  57     fn if_let(&self) {
  58         if let None = self.option_loud_drop(2) {
  59             unreachable!();
  60         } else {
  61             self.print(1);
  62         }
  63
  64         if let Some(_) = self.option_loud_drop(4) {
  65             self.print(3);
  66         }
  67
  68         if let Some(_d) = self.option_loud_drop(6) {
  69             self.print(5);
  70         }
  71     }
  72
  73     fn match_(&self) {
  74         match self.option_loud_drop(2) {
  75             _any => self.print(1),
  76         }
  77
  78         match self.option_loud_drop(4) {
  79             _ => self.print(3),
  80         }
  81
  82         match self.option_loud_drop(6) {
  83             Some(_) => self.print(5),
  84             _ => unreachable!(),
  85         }
  86
  87         match {
  88             let _ = self.loud_drop(7);
  89             let _d = self.loud_drop(9);
  90             self.print(8);
  91             ()
  92         } {
  93             () => self.print(10),
  94         }
  95
  96         match {
  97             match self.option_loud_drop(14) {
  98                 _ => {
  99                     self.print(11);
 100                     self.option_loud_drop(13)
 101                 }
 102             }
 103         } {
 104             _ => self.print(12),
 105         }
 106
 107         match {
 108             loop {
 109                 break match self.option_loud_drop(16) {
 110                     _ => {
 111                         self.print(15);
 112                         self.option_loud_drop(18)
 113                     }
 114                 };
 115             }
 116         } {
 117             _ => self.print(17),
 118         }
 119     }
 120
 121     fn and_chain(&self) {
 122         // issue-103107
 123         if self.option_loud_drop(1).is_some() // 1
 124             && self.option_loud_drop(2).is_some() // 2
 125             && self.option_loud_drop(3).is_some() // 3
 126             && self.option_loud_drop(4).is_some() // 4
 127             && self.option_loud_drop(5).is_some() // 5
 128         {
 129             self.print(6); // 6
 130         }
 131
 132         let _ = self.option_loud_drop(7).is_some() // 1
 133             && self.option_loud_drop(8).is_some() // 2
 134             && self.option_loud_drop(9).is_some(); // 3
 135         self.print(10); // 4
 136
 137         // Test associativity
 138         if self.option_loud_drop(11).is_some() // 1
 139             && (self.option_loud_drop(12).is_some() // 2
 140             && self.option_loud_drop(13).is_some() // 3
 141             && self.option_loud_drop(14).is_some()) // 4
 142             && self.option_loud_drop(15).is_some() // 5
 143         {
 144             self.print(16); // 6
 145         }
 146     }
 147
 148     fn or_chain(&self) {
 149         // issue-103107
 150         if self.option_loud_drop(1).is_none() // 1
 151             || self.option_loud_drop(2).is_none() // 2
 152             || self.option_loud_drop(3).is_none() // 3
 153             || self.option_loud_drop(4).is_none() // 4
 154             || self.option_loud_drop(5).is_some() // 5
 155         {
 156             self.print(6); // 6
 157         }
 158
 159         let _ = self.option_loud_drop(7).is_none() // 1
 160             || self.option_loud_drop(8).is_none() // 2
 161             || self.option_loud_drop(9).is_none(); // 3
 162         self.print(10); // 4
 163
 164         // Test associativity
 165         if self.option_loud_drop(11).is_none() // 1
 166             || (self.option_loud_drop(12).is_none() // 2
 167             || self.option_loud_drop(13).is_none() // 3
 168             || self.option_loud_drop(14).is_none()) // 4
 169             || self.option_loud_drop(15).is_some() // 5
 170         {
 171             self.print(16); // 6
 172         }
 173     }
 174
 175     fn mixed_and_or_chain(&self) {
 176         // issue-103107
 177         if self.option_loud_drop(1).is_none() // 1
 178             || self.option_loud_drop(2).is_none() // 2
 179             || self.option_loud_drop(3).is_some() // 3
 180             && self.option_loud_drop(4).is_some() // 4
 181             && self.option_loud_drop(5).is_none() // 5
 182             || self.option_loud_drop(6).is_none() // 6
 183             || self.option_loud_drop(7).is_some() // 7
 184         {
 185             self.print(8); // 8
 186         }
 187     }
 188
 189     fn let_chain(&self) {
 190         // take the "then" branch
 191         if self.option_loud_drop(1).is_some() // 1
 192             && self.option_loud_drop(2).is_some() // 2
 193             && let Some(_d) = self.option_loud_drop(4) { // 4
 194             self.print(3); // 3
 195         }
 196
 197         // take the "else" branch
 198         if self.option_loud_drop(5).is_some() // 1
 199             && self.option_loud_drop(6).is_some() // 2
 200             && let None = self.option_loud_drop(8) { // 4
 201             unreachable!();
 202         } else {
 203             self.print(7); // 3
 204         }
 205
 206         // let exprs interspersed
 207         if self.option_loud_drop(9).is_some() // 1
 208             && let Some(_d) = self.option_loud_drop(13) // 5
 209             && self.option_loud_drop(10).is_some() // 2
 210             && let Some(_e) = self.option_loud_drop(12) { // 4
 211             self.print(11); // 3
 212         }
 213
 214         // let exprs first
 215         if let Some(_d) = self.option_loud_drop(18) // 5
 216             && let Some(_e) = self.option_loud_drop(17) // 4
 217             && self.option_loud_drop(14).is_some() // 1
 218             && self.option_loud_drop(15).is_some() { // 2
 219                 self.print(16); // 3
 220             }
 221
 222         // let exprs last
 223         if self.option_loud_drop(19).is_some() // 1
 224             && self.option_loud_drop(20).is_some() // 2
 225             && let Some(_d) = self.option_loud_drop(23) // 5
 226             && let Some(_e) = self.option_loud_drop(22) { // 4
 227                 self.print(21); // 3
 228         }
 229     }
 230
 231     fn while_(&self) {
 232         let mut v = self.option_loud_drop(4);
 233         while let Some(_d) = v
 234             && self.option_loud_drop(1).is_some()
 235             && self.option_loud_drop(2).is_some() {
 236             self.print(3);
 237             v = None;
 238         }
 239     }
 240
 241     fn assert_sorted(self) {
 242         assert!(
 243             self.0
 244                 .into_inner()
 245                 .into_iter()
 246                 .enumerate()
 247                 .all(|(idx, item)| idx + 1 == item.try_into().unwrap())
 248         );
 249     }
 250 }
 251
 252 fn main() {
 253     println!("-- if --");
 254     let collector = DropOrderCollector::default();
 255     collector.if_();
 256     collector.assert_sorted();
 257
 258     println!("-- and chain --");
 259     let collector = DropOrderCollector::default();
 260     collector.and_chain();
 261     collector.assert_sorted();
 262
 263     println!("-- or chain --");
 264     let collector = DropOrderCollector::default();
 265     collector.or_chain();
 266     collector.assert_sorted();
 267
 268     println!("-- mixed and/or chain --");
 269     let collector = DropOrderCollector::default();
 270     collector.mixed_and_or_chain();
 271     collector.assert_sorted();
 272
 273     println!("-- if let --");
 274     let collector = DropOrderCollector::default();
 275     collector.if_let();
 276     collector.assert_sorted();
 277
 278     println!("-- match --");
 279     let collector = DropOrderCollector::default();
 280     collector.match_();
 281     collector.assert_sorted();
 282
 283     println!("-- let chain --");
 284     let collector = DropOrderCollector::default();
 285     collector.let_chain();
 286     collector.assert_sorted();
 287
 288     println!("-- while --");
 289     let collector = DropOrderCollector::default();
 290     collector.while_();
 291     collector.assert_sorted();
 292 }