tests/ui/for-loop-while/loop-break-value.rs

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