src/tools/miri/tests/pass/loop-break-value.rs

   1 #![feature(never_type)]
   2 #![allow(unreachable_code)]
   3
   4 #[allow(unused)]
   5 fn never_returns() {
   6     loop {
   7         break loop {};
   8     }
   9 }
  10
  11 pub fn main() {
  12     let value = 'outer: loop {
  13         if 1 == 1 {
  14             break 13;
  15         } else {
  16             let _never: ! = loop {
  17                 break loop {
  18                     break 'outer panic!();
  19                 };
  20             };
  21         }
  22     };
  23     assert_eq!(value, 13);
  24
  25     let x = [1, 3u32, 5];
  26     let y = [17];
  27     let z = [];
  28     let coerced: &[_] = loop {
  29         match 2 {
  30             1 => break &x,
  31             2 => break &y,
  32             3 => break &z,
  33             _ => (),
  34         }
  35     };
  36     assert_eq!(coerced, &[17u32]);
  37
  38     let trait_unified = loop {
  39         break if true { break Default::default() } else { break [13, 14] };
  40     };
  41     assert_eq!(trait_unified, [0, 0]);
  42
  43     let trait_unified_2 = loop {
  44         if false {
  45             break [String::from("Hello")];
  46         } else {
  47             break Default::default();
  48         };
  49     };
  50     // compare lengths; ptr comparison is not deterministic
  51     assert_eq!(trait_unified_2.len(), 1);
  52     assert_eq!(trait_unified_2[0].len(), 0);
  53
  54     let trait_unified_3 = loop {
  55         break if false { break [String::from("Hello")] } else { ["Yes".into()] };
  56     };
  57     assert_eq!(trait_unified_3, ["Yes"]);
  58
  59     let regular_break = loop {
  60         if true {
  61             break;
  62         } else {
  63             break break Default::default();
  64         }
  65     };
  66     assert_eq!(regular_break, ());
  67
  68     let regular_break_2 = loop {
  69         if true {
  70             break Default::default();
  71         } else {
  72             break;
  73         }
  74     };
  75     assert_eq!(regular_break_2, ());
  76
  77     let regular_break_3 = loop {
  78         break if true {
  79             Default::default()
  80         } else {
  81             break;
  82         };
  83     };
  84     assert_eq!(regular_break_3, ());
  85
  86     let regular_break_4 = loop {
  87         break ();
  88         break;
  89     };
  90     assert_eq!(regular_break_4, ());
  91
  92     let regular_break_5 = loop {
  93         break;
  94         break ();
  95     };
  96     assert_eq!(regular_break_5, ());
  97
  98     let nested_break_value = 'outer2: loop {
  99         let _a: u32 = 'inner: loop {
 100             if true {
 101                 break 'outer2 "hello";
 102             } else {
 103                 break 'inner 17;
 104             }
 105         };
 106         panic!();
 107     };
 108     assert_eq!(nested_break_value, "hello");
 109
 110     let break_from_while_cond = loop {
 111         'inner_loop: while break 'inner_loop {
 112             panic!();
 113         }
 114         break 123;
 115     };
 116     assert_eq!(break_from_while_cond, 123);
 117
 118     let break_from_while_to_outer = 'outer_loop: loop {
 119         while break 'outer_loop 567 {
 120             panic!("from_inner");
 121         }
 122         panic!("from outer");
 123     };
 124     assert_eq!(break_from_while_to_outer, 567);
 125 }