]>
Commit | Line | Data |
---|---|---|
b7449926 | 1 | // run-pass |
c34b1796 AL |
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 | } |