Daniel Dunbar | a572887 | 2009-12-15 20:14:24 +0000 | [diff] [blame] | 1 | // RUN: %clang_cc1 -fsyntax-only -verify %s |
Chris Lattner | 8a87e57 | 2007-07-23 17:05:23 +0000 | [diff] [blame] | 2 | void f (int z) { |
| 3 | while (z) { |
Chris Lattner | 0471f5b | 2007-08-23 18:29:20 +0000 | [diff] [blame] | 4 | default: z--; // expected-error {{statement not in switch}} |
Chris Lattner | 8a87e57 | 2007-07-23 17:05:23 +0000 | [diff] [blame] | 5 | } |
| 6 | } |
| 7 | |
Chris Lattner | f4021e7 | 2007-08-23 05:46:52 +0000 | [diff] [blame] | 8 | void foo(int X) { |
| 9 | switch (X) { |
Chris Lattner | 5f4a682 | 2008-11-23 23:12:31 +0000 | [diff] [blame] | 10 | case 42: ; // expected-note {{previous case}} |
Chris Lattner | 0471f5b | 2007-08-23 18:29:20 +0000 | [diff] [blame] | 11 | case 5000000000LL: // expected-warning {{overflow}} |
| 12 | case 42: // expected-error {{duplicate case value}} |
Chris Lattner | f4021e7 | 2007-08-23 05:46:52 +0000 | [diff] [blame] | 13 | ; |
Chris Lattner | 6efc4d3 | 2007-08-23 17:48:14 +0000 | [diff] [blame] | 14 | |
Chris Lattner | 0471f5b | 2007-08-23 18:29:20 +0000 | [diff] [blame] | 15 | case 100 ... 99: ; // expected-warning {{empty case range}} |
| 16 | |
Chris Lattner | 5f4a682 | 2008-11-23 23:12:31 +0000 | [diff] [blame] | 17 | case 43: ; // expected-note {{previous case}} |
Chris Lattner | 0471f5b | 2007-08-23 18:29:20 +0000 | [diff] [blame] | 18 | case 43 ... 45: ; // expected-error {{duplicate case value}} |
| 19 | |
Chris Lattner | 5f4a682 | 2008-11-23 23:12:31 +0000 | [diff] [blame] | 20 | case 100 ... 20000:; // expected-note {{previous case}} |
Chris Lattner | 0471f5b | 2007-08-23 18:29:20 +0000 | [diff] [blame] | 21 | case 15000 ... 40000000:; // expected-error {{duplicate case value}} |
Chris Lattner | f4021e7 | 2007-08-23 05:46:52 +0000 | [diff] [blame] | 22 | } |
| 23 | } |
| 24 | |
Chris Lattner | f334850 | 2007-08-23 14:29:07 +0000 | [diff] [blame] | 25 | void test3(void) { |
Chris Lattner | 0471f5b | 2007-08-23 18:29:20 +0000 | [diff] [blame] | 26 | // empty switch; |
John McCall | 0fb9708 | 2010-05-18 03:19:21 +0000 | [diff] [blame] | 27 | switch (0); // expected-warning {{no case matching constant switch condition '0'}} |
Chris Lattner | f334850 | 2007-08-23 14:29:07 +0000 | [diff] [blame] | 28 | } |
| 29 | |
Anders Carlsson | 51fe996 | 2008-11-22 21:04:56 +0000 | [diff] [blame] | 30 | extern int g(); |
| 31 | |
| 32 | void test4() |
| 33 | { |
John McCall | 0fb9708 | 2010-05-18 03:19:21 +0000 | [diff] [blame] | 34 | int cond; |
| 35 | switch (cond) { |
Anders Carlsson | 51fe996 | 2008-11-22 21:04:56 +0000 | [diff] [blame] | 36 | case 0 && g(): |
| 37 | case 1 || g(): |
| 38 | break; |
| 39 | } |
| 40 | |
John McCall | 0fb9708 | 2010-05-18 03:19:21 +0000 | [diff] [blame] | 41 | switch(cond) { |
Anders Carlsson | d3a61d5 | 2008-12-01 02:13:02 +0000 | [diff] [blame] | 42 | case g(): // expected-error {{expression is not an integer constant expression}} |
| 43 | case 0 ... g(): // expected-error {{expression is not an integer constant expression}} |
Anders Carlsson | 51fe996 | 2008-11-22 21:04:56 +0000 | [diff] [blame] | 44 | break; |
| 45 | } |
| 46 | |
John McCall | 0fb9708 | 2010-05-18 03:19:21 +0000 | [diff] [blame] | 47 | switch (cond) { |
Anders Carlsson | 51fe996 | 2008-11-22 21:04:56 +0000 | [diff] [blame] | 48 | case 0 && g() ... 1 || g(): |
| 49 | break; |
| 50 | } |
Anders Carlsson | 6dde0d5 | 2008-11-22 21:50:49 +0000 | [diff] [blame] | 51 | |
John McCall | 0fb9708 | 2010-05-18 03:19:21 +0000 | [diff] [blame] | 52 | switch (cond) { |
Anders Carlsson | d3a61d5 | 2008-12-01 02:13:02 +0000 | [diff] [blame] | 53 | case g() && 0: // expected-error {{expression is not an integer constant expression}} // expected-note {{subexpression not valid in an integer constant expression}} |
Anders Carlsson | 6dde0d5 | 2008-11-22 21:50:49 +0000 | [diff] [blame] | 54 | break; |
| 55 | } |
| 56 | |
John McCall | 0fb9708 | 2010-05-18 03:19:21 +0000 | [diff] [blame] | 57 | switch (cond) { |
Anders Carlsson | d3a61d5 | 2008-12-01 02:13:02 +0000 | [diff] [blame] | 58 | case 0 ... g() || 1: // expected-error {{expression is not an integer constant expression}} // expected-note {{subexpression not valid in an integer constant expression}} |
Anders Carlsson | 6dde0d5 | 2008-11-22 21:50:49 +0000 | [diff] [blame] | 59 | break; |
| 60 | } |
Anders Carlsson | 51fe996 | 2008-11-22 21:04:56 +0000 | [diff] [blame] | 61 | } |
| 62 | |
Chris Lattner | 5f4a682 | 2008-11-23 23:12:31 +0000 | [diff] [blame] | 63 | void test5(int z) { |
| 64 | switch(z) { |
| 65 | default: // expected-note {{previous case defined here}} |
| 66 | default: // expected-error {{multiple default labels in one switch}} |
| 67 | break; |
| 68 | } |
| 69 | } |
| 70 | |
Chris Lattner | 5f04881 | 2009-10-16 16:45:22 +0000 | [diff] [blame] | 71 | void test6() { |
John McCall | 0fb9708 | 2010-05-18 03:19:21 +0000 | [diff] [blame] | 72 | char ch = 'a'; |
Chris Lattner | 5f04881 | 2009-10-16 16:45:22 +0000 | [diff] [blame] | 73 | switch(ch) { |
| 74 | case 1234: // expected-warning {{overflow converting case value}} |
| 75 | break; |
| 76 | } |
| 77 | } |
Douglas Gregor | be724ba | 2009-11-25 06:20:02 +0000 | [diff] [blame] | 78 | |
| 79 | // PR5606 |
Douglas Gregor | 539c5c3 | 2010-01-07 00:31:29 +0000 | [diff] [blame] | 80 | int f0(int var) { // expected-note{{'var' declared here}} |
Douglas Gregor | be724ba | 2009-11-25 06:20:02 +0000 | [diff] [blame] | 81 | switch (va) { // expected-error{{use of undeclared identifier 'va'}} |
| 82 | case 1: |
| 83 | break; |
| 84 | case 2: |
| 85 | return 1; |
| 86 | } |
| 87 | return 2; |
| 88 | } |
Douglas Gregor | ba915af | 2010-02-08 22:24:16 +0000 | [diff] [blame] | 89 | |
| 90 | void test7() { |
| 91 | enum { |
| 92 | A = 1, |
| 93 | B |
| 94 | } a; |
| 95 | switch(a) { //expected-warning{{enumeration value 'B' not handled in switch}} |
| 96 | case A: |
| 97 | break; |
| 98 | } |
| 99 | switch(a) { |
| 100 | case B: |
| 101 | case A: |
| 102 | break; |
| 103 | } |
| 104 | switch(a) { |
| 105 | case A: |
| 106 | case B: |
| 107 | case 3: // expected-warning{{case value not in enumerated type ''}} |
| 108 | break; |
| 109 | } |
| 110 | switch(a) { |
| 111 | case A: |
| 112 | case B: |
| 113 | case 3 ... //expected-warning{{case value not in enumerated type ''}} |
| 114 | 4: //expected-warning{{case value not in enumerated type ''}} |
| 115 | break; |
| 116 | } |
| 117 | switch(a) { |
| 118 | case 1 ... 2: |
| 119 | break; |
| 120 | } |
| 121 | switch(a) { |
| 122 | case 0 ... 2: //expected-warning{{case value not in enumerated type ''}} |
| 123 | break; |
| 124 | } |
| 125 | switch(a) { |
| 126 | case 1 ... 3: //expected-warning{{case value not in enumerated type ''}} |
| 127 | break; |
| 128 | } |
| 129 | switch(a) { |
| 130 | case 0 ... //expected-warning{{case value not in enumerated type ''}} |
| 131 | 3: //expected-warning{{case value not in enumerated type ''}} |
| 132 | break; |
| 133 | } |
| 134 | |
| 135 | } |
| 136 | |
| 137 | void test8() { |
| 138 | enum { |
| 139 | A, |
| 140 | B, |
| 141 | C = 1 |
| 142 | } a; |
| 143 | switch(a) { |
| 144 | case A: |
| 145 | case B: |
| 146 | break; |
| 147 | } |
| 148 | switch(a) { |
| 149 | case A: |
| 150 | case C: |
| 151 | break; |
| 152 | } |
| 153 | switch(a) { //expected-warning{{enumeration value 'B' not handled in switch}} |
| 154 | case A: |
| 155 | break; |
| 156 | } |
| 157 | } |
| 158 | |
| 159 | void test9() { |
| 160 | enum { |
| 161 | A = 3, |
| 162 | C = 1 |
| 163 | } a; |
| 164 | switch(a) { |
| 165 | case 0: //expected-warning{{case value not in enumerated type ''}} |
| 166 | case 1: |
| 167 | case 2: //expected-warning{{case value not in enumerated type ''}} |
| 168 | case 3: |
| 169 | case 4: //expected-warning{{case value not in enumerated type ''}} |
| 170 | break; |
| 171 | } |
| 172 | } |
| 173 | |
| 174 | void test10() { |
| 175 | enum { |
| 176 | A = 10, |
| 177 | C = 2, |
| 178 | B = 4, |
| 179 | D = 12 |
| 180 | } a; |
| 181 | switch(a) { |
| 182 | case 0 ... //expected-warning{{case value not in enumerated type ''}} |
| 183 | 1: //expected-warning{{case value not in enumerated type ''}} |
| 184 | case 2 ... 4: |
| 185 | case 5 ... //expected-warning{{case value not in enumerated type ''}} |
| 186 | 9: //expected-warning{{case value not in enumerated type ''}} |
| 187 | case 10 ... 12: |
| 188 | case 13 ... //expected-warning{{case value not in enumerated type ''}} |
| 189 | 16: //expected-warning{{case value not in enumerated type ''}} |
| 190 | break; |
| 191 | } |
| 192 | } |
| 193 | |
| 194 | void test11() { |
| 195 | enum { |
| 196 | A = -1, |
| 197 | B, |
| 198 | C |
| 199 | } a; |
| 200 | switch(a) { //expected-warning{{enumeration value 'A' not handled in switch}} |
| 201 | case B: |
| 202 | case C: |
| 203 | break; |
| 204 | } |
| 205 | |
| 206 | switch(a) { |
| 207 | case B: |
| 208 | case C: |
| 209 | break; |
| 210 | |
| 211 | default: |
| 212 | break; |
| 213 | } |
| 214 | } |
| 215 | |
| 216 | void test12() { |
| 217 | enum { |
| 218 | A = -1, |
| 219 | B = 4294967286 |
| 220 | } a; |
| 221 | switch(a) { |
| 222 | case A: |
| 223 | case B: |
| 224 | break; |
| 225 | } |
| 226 | } |
Douglas Gregor | 30ab371 | 2010-02-17 23:29:11 +0000 | [diff] [blame] | 227 | |
| 228 | // <rdar://problem/7643909> |
| 229 | typedef enum { |
| 230 | val1, |
| 231 | val2, |
| 232 | val3 |
| 233 | } my_type_t; |
| 234 | |
| 235 | int test13(my_type_t t) { |
| 236 | switch(t) { // expected-warning{{enumeration value 'val3' not handled in switch}} |
| 237 | case val1: |
| 238 | return 1; |
| 239 | case val2: |
| 240 | return 2; |
| 241 | } |
| 242 | return -1; |
| 243 | } |
Douglas Gregor | 2853eac | 2010-02-18 00:56:01 +0000 | [diff] [blame] | 244 | |
| 245 | // <rdar://problem/7658121> |
| 246 | enum { |
| 247 | EC0 = 0xFFFF0000, |
| 248 | EC1 = 0xFFFF0001, |
| 249 | }; |
| 250 | |
| 251 | int test14(int a) { |
| 252 | switch(a) { |
| 253 | case EC0: return 0; |
| 254 | case EC1: return 1; |
| 255 | } |
| 256 | return 0; |
| 257 | } |
Douglas Gregor | f9f627d | 2010-03-01 01:04:55 +0000 | [diff] [blame] | 258 | |
| 259 | void f1(unsigned x) { |
| 260 | switch (x) { |
| 261 | case -1: break; |
| 262 | default: break; |
| 263 | } |
| 264 | } |
John McCall | 0fb9708 | 2010-05-18 03:19:21 +0000 | [diff] [blame] | 265 | |
| 266 | void test15() { |
| 267 | int i = 0; |
| 268 | switch (1) { // expected-warning {{no case matching constant switch condition '1'}} |
| 269 | case 0: i = 0; break; |
| 270 | case 2: i++; break; |
| 271 | } |
| 272 | } |
| 273 | |
| 274 | void test16() { |
| 275 | const char c = '5'; |
| 276 | switch (c) { // expected-warning {{no case matching constant switch condition '53'}} |
| 277 | case '6': return; |
| 278 | } |
| 279 | } |
John McCall | 6907fbe | 2010-06-12 01:56:02 +0000 | [diff] [blame] | 280 | |
| 281 | // PR7359 |
| 282 | void test17(int x) { |
| 283 | switch (x >= 17) { // expected-warning {{switch condition has boolean value}} |
| 284 | case 0: return; |
| 285 | } |
| 286 | |
| 287 | switch ((int) (x <= 17)) { |
| 288 | case 0: return; |
| 289 | } |
| 290 | } |