// RUN: %clang_cc1 -fsyntax-only -verify -Wswitch-enum -Wcovered-switch-default -triple x86_64-linux-gnu %s
void f (int z) { 
  while (z) { 
    default: z--;            // expected-error {{statement not in switch}}
  } 
}

void foo(int X) {
  switch (X) {
  case 42: ;                 // expected-note {{previous case}}
  case 5000000000LL:         // expected-warning {{overflow}}
  case 42:                   // expected-error {{duplicate case value '42'}}
   ;

  case 100 ... 99: ;         // expected-warning {{empty case range}}

  case 43: ;                 // expected-note {{previous case}}
  case 43 ... 45:  ;         // expected-error {{duplicate case value}}

  case 100 ... 20000:;       // expected-note {{previous case}}
  case 15000 ... 40000000:;  // expected-error {{duplicate case value}}
  }
}

void test3(void) { 
  // empty switch;
  switch (0); // expected-warning {{no case matching constant switch condition '0'}} \
              // expected-warning {{switch statement has empty body}} \
              // expected-note{{put the semicolon on a separate line to silence this warning}}
}

extern int g();

void test4()
{
  int cond;
  switch (cond) {
  case 0 && g():
  case 1 || g():
    break;
  }

  switch(cond)  {
  case g(): // expected-error {{expression is not an integer constant expression}}
  case 0 ... g(): // expected-error {{expression is not an integer constant expression}}
    break;
  }
  
  switch (cond) {
  case 0 && g() ... 1 || g():
    break;
  }
  
  switch (cond) {
  case g() // expected-error {{expression is not an integer constant expression}}
      && 0:
    break;
  }
  
  switch (cond) {
  case 0 ...
      g() // expected-error {{expression is not an integer constant expression}}
      || 1:
    break;
  }
}

void test5(int z) { 
  switch(z) {
    default:  // expected-note {{previous case defined here}}
    default:  // expected-error {{multiple default labels in one switch}}
      break;
  }
} 

void test6() {
  char ch = 'a';
  switch(ch) {
    case 1234:  // expected-warning {{overflow converting case value}}
      break;
  }
}

// PR5606
int f0(int var) {
  switch (va) { // expected-error{{use of undeclared identifier 'va'}}
  case 1:
    break;
  case 2:
    return 1;
  }
  return 2;
}

void test7() {
  enum {
    A = 1,
    B
  } a;
  switch(a) { //expected-warning{{enumeration value 'B' not handled in switch}}
    case A:
      break;
  }
  switch(a) {
    case B:
    case A:
      break;
  }
  switch(a) {
    case A:
    case B:
    case 3: // expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
      break;
  }
  switch(a) {
    case A:
    case B:
    case 3 ... //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
        4: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
      break;
  }
  switch(a) {
    case 1 ... 2:
      break;
  }
  switch(a) {
    case 0 ... 2: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
      break;
  }
  switch(a) {
    case 1 ... 3: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
      break;
  }
  switch(a) {
    case 0 ...  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
      3:  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
      break;
  }

}

void test8() {
  enum {
    A,
    B,
    C = 1
  } a;
  switch(a) {
    case A:
    case B:
     break;
  }
  switch(a) {
    case A:
    case C:
      break;
  }
  switch(a) { //expected-warning{{enumeration value 'B' not handled in switch}}
    case A:
      break;
  }
}

void test9() {
  enum {
    A = 3,
    C = 1
  } a;
  switch(a) {
    case 0: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
    case 1:
    case 2: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
    case 3:
    case 4: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
      break;
  }
}

void test10() {
  enum {
    A = 10,
    C = 2,
    B = 4,
    D = 12
  } a;
  switch(a) {
    case 0 ...  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
	    1:  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
    case 2 ... 4:
    case 5 ...  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}	
	      9:  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
    case 10 ... 12:
    case 13 ...  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
              16: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
      break;
  }
}

void test11() {
  enum {
    A = -1,
    B,
    C
  } a;
  switch(a) { //expected-warning{{enumeration value 'A' not handled in switch}}
    case B:
    case C:
      break;
  }

  switch(a) { //expected-warning{{enumeration value 'A' not explicitly handled in switch}}
    case B:
    case C:
      break;
      
    default:
      break;
  }
}

void test12() {
  enum {
    A = -1,
    B = 4294967286
  } a;
  switch(a) {
    case A:
    case B:
      break;
  }
}

// <rdar://problem/7643909>
typedef enum {
    val1,
    val2,
    val3
} my_type_t;

int test13(my_type_t t) {
  switch(t) { // expected-warning{{enumeration value 'val3' not handled in switch}}
  case val1:
    return 1;
  case val2:
    return 2;
  }
  return -1;
}

// <rdar://problem/7658121>
enum {
  EC0 = 0xFFFF0000,
  EC1 = 0xFFFF0001,
};

int test14(int a) {
  switch(a) {
  case EC0: return 0;
  case EC1: return 1;
  }
  return 0;
}

void f1(unsigned x) {
  switch (x) {
  case -1: break;
  default: break;
  }
}

void test15() {
  int i = 0;
  switch (1) { // expected-warning {{no case matching constant switch condition '1'}}
  case 0: i = 0; break;
  case 2: i++; break;
  }
}

void test16() {
  const char c = '5';
  switch (c) { // expected-warning {{no case matching constant switch condition '53'}}
  case '6': return;
  }
}

struct bitfield_member {
  unsigned bf : 1;
};

// PR7359
void test17(int x) {
  switch (x >= 17) { // expected-warning {{switch condition has boolean value}}
  case 0: return;
  }

  switch ((int) (x <= 17)) {
  case 0: return;
  }

  struct bitfield_member bm;
  switch (bm.bf) { // no warning
  case 0:
  case 1:
    return;
  }
}

int test18() {
  enum { A, B } a;
  switch (a) {
  case A: return 0;
  case B: return 1;
  case 7: return 1; // expected-warning {{case value not in enumerated type}}
  default: return 2; // expected-warning {{default label in switch which covers all enumeration values}}
  }
}

// rdar://110822110
typedef enum {
        kOne = 1,
} Ints;
        
void rdar110822110(Ints i)
{
        switch (i) {
                case kOne:
                        break;
                case 2: 	// expected-warning {{case value not in enumerated type 'Ints'}}          
                        break;
                default:	// expected-warning {{default label in switch which covers all enumeration values}}
                        break;
                }
}

// PR9243
#define TEST19MACRO 5
void test19(int i) {
  enum {
    kTest19Enum1 = 7,
    kTest19Enum2 = kTest19Enum1
  };
  const int a = 3;
  switch (i) {
    case 5: // expected-note {{previous case}}
    case TEST19MACRO: // expected-error {{duplicate case value '5'}}

    case 7: // expected-note {{previous case}}
    case kTest19Enum1: // expected-error {{duplicate case value: '7' and 'kTest19Enum1' both equal '7'}} \
                       // expected-note {{previous case}}
    case kTest19Enum1: // expected-error {{duplicate case value 'kTest19Enum1'}} \
                       // expected-note {{previous case}}
    case kTest19Enum2: // expected-error {{duplicate case value: 'kTest19Enum1' and 'kTest19Enum2' both equal '7'}} \
                       // expected-note {{previous case}}
    case (int)kTest19Enum2: //expected-error {{duplicate case value 'kTest19Enum2'}}

    case 3: // expected-note {{previous case}}
    case a: // expected-error {{duplicate case value: '3' and 'a' both equal '3'}} \
            // expected-note {{previous case}}
    case a: // expected-error {{duplicate case value 'a'}}
      break;
  }
}

// Allow the warning 'case value not in enumerated type' to be silenced with
// the following pattern.
//
// If 'case' expression refers to a static const variable of the correct enum
// type, then we count this as a sufficient declaration of intent by the user,
// so we silence the warning.
enum ExtendedEnum1 {
  EE1_a,
  EE1_b
};

enum ExtendedEnum1_unrelated { EE1_misc };

static const enum ExtendedEnum1 EE1_c = 100;
static const enum ExtendedEnum1_unrelated EE1_d = 101;

void switch_on_ExtendedEnum1(enum ExtendedEnum1 e) {
  switch(e) {
  case EE1_a: break;
  case EE1_b: break;
  case EE1_c: break; // no-warning
  case EE1_d: break; // expected-warning {{case value not in enumerated type 'enum ExtendedEnum1'}}
  // expected-warning@-1 {{comparison of different enumeration types in switch statement ('enum ExtendedEnum1' and 'enum ExtendedEnum1_unrelated')}}
  }
}

void PR11778(char c, int n, long long ll) {
  // Do not reject this; we don't have duplicate case values because we
  // check for duplicates in the promoted type.
  switch (c) case 1: case 257: ; // expected-warning {{overflow}}

  switch (n) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}}
  switch ((int)ll) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}}
  switch ((long long)n) case 0x100000001LL: case 1: ;
  switch (ll) case 0x100000001LL: case 1: ;
}