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