src/test/ui/structs-enums/discrim-explicit-23030.rs

   1 // run-pass
   2 // Issue 23030: Workaround overflowing discriminant
   3 // with explicit assignments.
   4
   5 // See also compile-fail/overflow-discrim.rs, which shows what
   6 // happens if you leave the OhNo explicit cases out here.
   7
   8 use std::{i8,u8,i16,u16,i32,u32,i64,u64,isize,usize};
   9
  10 fn f_i8() {
  11     #[repr(i8)]
  12     enum A {
  13         Ok = i8::MAX - 1,
  14         Ok2,
  15         OhNo = i8::MIN,
  16         NotTheEnd = -1,
  17         Zero,
  18     }
  19
  20     let _x = (A::Ok, A::Ok2, A::OhNo);
  21     let z = (A::NotTheEnd, A::Zero).1 as i8;
  22     assert_eq!(z, 0);
  23 }
  24
  25 fn f_u8() {
  26     #[repr(u8)]
  27     enum A {
  28         Ok = u8::MAX - 1,
  29         Ok2,
  30         OhNo = u8::MIN,
  31     }
  32
  33     let _x = (A::Ok, A::Ok2, A::OhNo);
  34 }
  35
  36 fn f_i16() {
  37     #[repr(i16)]
  38     enum A {
  39         Ok = i16::MAX - 1,
  40         Ok2,
  41         OhNo = i16::MIN,
  42         NotTheEnd = -1,
  43         Zero,
  44     }
  45
  46     let _x = (A::Ok, A::Ok2, A::OhNo);
  47     let z = (A::NotTheEnd, A::Zero).1 as i16;
  48     assert_eq!(z, 0);
  49 }
  50
  51 fn f_u16() {
  52     #[repr(u16)]
  53     enum A {
  54         Ok = u16::MAX - 1,
  55         Ok2,
  56         OhNo = u16::MIN,
  57     }
  58
  59     let _x = (A::Ok, A::Ok2, A::OhNo);
  60 }
  61
  62 fn f_i32() {
  63     #[repr(i32)]
  64     enum A {
  65         Ok = i32::MAX - 1,
  66         Ok2,
  67         OhNo = i32::MIN,
  68         NotTheEnd = -1,
  69         Zero,
  70     }
  71
  72     let _x = (A::Ok, A::Ok2, A::OhNo);
  73     let z = (A::NotTheEnd, A::Zero).1 as i32;
  74     assert_eq!(z, 0);
  75 }
  76
  77 fn f_u32() {
  78     #[repr(u32)]
  79     enum A {
  80         Ok = u32::MAX - 1,
  81         Ok2,
  82         OhNo = u32::MIN,
  83     }
  84
  85     let _x = (A::Ok, A::Ok2, A::OhNo);
  86 }
  87
  88 fn f_i64() {
  89     #[repr(i64)]
  90     enum A {
  91         Ok = i64::MAX - 1,
  92         Ok2,
  93         OhNo = i64::MIN,
  94         NotTheEnd = -1,
  95         Zero,
  96     }
  97
  98     let _x = (A::Ok, A::Ok2, A::OhNo);
  99     let z = (A::NotTheEnd, A::Zero).1 as i64;
 100     assert_eq!(z, 0);
 101 }
 102
 103 fn f_u64() {
 104     #[repr(u64)]
 105     enum A {
 106         Ok = u64::MAX - 1,
 107         Ok2,
 108         OhNo = u64::MIN,
 109     }
 110
 111     let _x = (A::Ok, A::Ok2, A::OhNo);
 112 }
 113
 114 fn f_isize() {
 115     #[repr(isize)]
 116     enum A {
 117         Ok = isize::MAX - 1,
 118         Ok2,
 119         OhNo = isize::MIN,
 120         NotTheEnd = -1,
 121         Zero,
 122     }
 123
 124     let _x = (A::Ok, A::Ok2, A::OhNo);
 125     let z = (A::NotTheEnd, A::Zero).1 as isize;
 126     assert_eq!(z, 0);
 127 }
 128
 129 fn f_usize() {
 130     #[repr(usize)]
 131     enum A {
 132         Ok = usize::MAX - 1,
 133         Ok2,
 134         OhNo = usize::MIN,
 135     }
 136
 137     let _x = (A::Ok, A::Ok2, A::OhNo);
 138 }
 139
 140 fn main() {
 141     f_i8(); f_u8();
 142     f_i16(); f_u16();
 143     f_i32(); f_u32();
 144     f_i64(); f_u64();
 145
 146     f_isize(); f_usize();
 147 }