tests/ui/never_type/diverging-fallback-control-flow.rs

   1 // revisions: nofallback fallback
   2 // run-pass
   3
   4 #![allow(dead_code)]
   5 #![allow(unused_assignments)]
   6 #![allow(unused_variables)]
   7 #![allow(unreachable_code)]
   8 // Test various cases where we permit an unconstrained variable
   9 // to fallback based on control-flow. In all of these cases,
  10 // the type variable winds up being the target of both a `!` coercion
  11 // and a coercion from a non-`!` variable, and hence falls back to `()`.
  12 #![cfg_attr(fallback, feature(never_type, never_type_fallback))]
  13
  14 trait UnitDefault {
  15     fn default() -> Self;
  16 }
  17
  18 impl UnitDefault for u32 {
  19     fn default() -> Self {
  20         0
  21     }
  22 }
  23
  24 impl UnitDefault for () {
  25     fn default() -> () {
  26         panic!()
  27     }
  28 }
  29
  30 fn assignment() {
  31     let x;
  32
  33     if true {
  34         x = UnitDefault::default();
  35     } else {
  36         x = return;
  37     }
  38 }
  39
  40 fn assignment_rev() {
  41     let x;
  42
  43     if true {
  44         x = return;
  45     } else {
  46         x = UnitDefault::default();
  47     }
  48 }
  49
  50 fn if_then_else() {
  51     let _x = if true {
  52         UnitDefault::default()
  53     } else {
  54         return;
  55     };
  56 }
  57
  58 fn if_then_else_rev() {
  59     let _x = if true {
  60         return;
  61     } else {
  62         UnitDefault::default()
  63     };
  64 }
  65
  66 fn match_arm() {
  67     let _x = match Ok(UnitDefault::default()) {
  68         Ok(v) => v,
  69         Err(()) => return,
  70     };
  71 }
  72
  73 fn match_arm_rev() {
  74     let _x = match Ok(UnitDefault::default()) {
  75         Err(()) => return,
  76         Ok(v) => v,
  77     };
  78 }
  79
  80 fn loop_break() {
  81     let _x = loop {
  82         if false {
  83             break return;
  84         } else {
  85             break UnitDefault::default();
  86         }
  87     };
  88 }
  89
  90 fn loop_break_rev() {
  91     let _x = loop {
  92         if false {
  93             break return;
  94         } else {
  95             break UnitDefault::default();
  96         }
  97     };
  98 }
  99
 100 fn main() {}