clang/test/SemaCXX/switch.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
   2
   3 void test() {
   4   bool x = true;
   5   switch (x) { // expected-warning {{bool}}
   6     case 0:
   7       break;
   8   }
   9
  10   int n = 3;
  11   switch (n && true) { // expected-warning {{bool}}
  12     case 1:
  13       break;
  14   }
  15 }
  16
  17 // PR5518
  18 struct A {
  19   operator int(); // expected-note{{conversion to integral type}}
  20 };
  21
  22 void x() {
  23   switch(A()) {
  24   }
  25 }
  26
  27 enum E { e1, e2 };
  28 struct B : A {
  29   operator E() const; // expected-note{{conversion to enumeration type}}
  30 };
  31
  32 void x2() {
  33   switch (B()) { // expected-error{{multiple conversions}}
  34   }
  35 }
  36
  37 struct C; // expected-note{{forward declaration}}
  38
  39 void x3(C &c) {
  40   switch (c) { // expected-error{{incomplete class type}}
  41   }
  42 }
  43
  44 namespace test3 {
  45   enum En { A, B, C };
  46   template <En how> void foo() {
  47     int x = 0, y = 5;
  48
  49     switch (how) { //expected-warning {{no case matching constant switch condition '2'}}
  50     case A: x *= y; break;
  51     case B: x += y; break;
  52     // No case for C, but it's okay because we have a constant condition.
  53     }
  54   }
  55
  56   template void foo<A>();
  57   template void foo<B>();
  58   template void foo<C>(); //expected-note {{in instantiation}}
  59 }
  60
  61 // PR9304 and rdar://9045501
  62 void click_check_header_sizes() {
  63   switch (0 == 8) {  // expected-warning {{switch condition has boolean value}}
  64   case 0: ;
  65   }
  66 }
  67
  68 void local_class(int n) {
  69   for (;;) switch (n) {
  70   case 0:
  71     struct S {
  72       void f() {
  73         case 1: // expected-error {{'case' statement not in switch statement}}
  74         break; // expected-error {{'break' statement not in loop or switch statement}}
  75         default: // expected-error {{'default' statement not in switch statement}}
  76         continue; // expected-error {{'continue' statement not in loop statement}}
  77       }
  78     };
  79     S().f();
  80     []{
  81       case 2: // expected-error {{'case' statement not in switch statement}}
  82       break; // expected-error {{'break' statement not in loop or switch statement}}
  83       default: // expected-error {{'default' statement not in switch statement}}
  84       continue; // expected-error {{'continue' statement not in loop statement}}
  85     }();
  86   }
  87 }
  88
  89 namespace Conversion {
  90   struct S {
  91     explicit operator int(); // expected-note {{conversion}}
  92   };
  93   template<typename T> void f(T t) {
  94     switch (t) { // expected-error {{explicit conversion}}
  95     case 0:
  96       return;
  97     default:
  98       break;
  99     }
 100   }
 101   template void f(S); // expected-note {{instantiation of}}
 102 }
 103
 104 // rdar://29230764
 105 namespace OpaqueEnumWarnings {
 106
 107 enum Opaque : int;
 108 enum class OpaqueClass : int;
 109
 110 enum class Defined : int;
 111 enum class Defined : int { a };
 112
 113 void test(Opaque o, OpaqueClass oc, Defined d) {
 114   // Don't warn that case value is not present in opaque enums.
 115   switch (o) {
 116   case (Opaque)1:
 117     break;
 118   }
 119   switch (oc) {
 120   case (OpaqueClass)1:
 121     break;
 122   }
 123
 124   switch (d) {
 125   case Defined::a:
 126     break;
 127   case (Defined)2: // expected-warning {{case value not in enumerated type 'OpaqueEnumWarnings::Defined'}}
 128     break;
 129   }
 130 }
 131
 132 }
 133
 134 namespace EmptyEnum {
 135
 136 enum Empty : int {};
 137 void test(Empty e) {
 138   switch (e) {
 139   case (Empty)0:
 140     break;
 141   }
 142   switch (e) {
 143   default:
 144     break;
 145   }
 146 }
 147
 148 } // namespace EmptyEnum