clang/test/SemaCXX/cxx20-using-enum.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify %s
   2 // RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify %s
   3
   4 // p1099 'using enum ELABORATED-ENUM-SPECIFIER ;'
   5
   6 namespace One {
   7 namespace Bob {
   8 enum A { a, // expected-note{{declared here}}
   9          b,
  10          c };
  11 class C; // expected-note{{previous use}}
  12 enum class D : int;
  13 enum class D { d,
  14                e,
  15                f };
  16 enum class D : int;
  17 } // namespace Bob
  18
  19 using enum Bob::A;
  20 #if __cplusplus < 202002
  21 // expected-warning@-2{{is a C++20 extension}}
  22 #endif
  23 using enum Bob::B; // expected-error{{no enum named 'B'}}
  24 #if __cplusplus < 202002
  25 // expected-warning@-2{{is a C++20 extension}}
  26 #endif
  27 using enum Bob::C; // expected-error{{tag type that does not match}}
  28 #if __cplusplus < 202002
  29 // expected-warning@-2{{is a C++20 extension}}
  30 #endif
  31 auto v = a;
  32
  33 A g; // expected-error{{unknown type name 'A'}}
  34
  35 int A;
  36
  37 using enum Bob::D;
  38 #if __cplusplus < 202002
  39 // expected-warning@-2{{is a C++20 extension}}
  40 #endif
  41 } // namespace One
  42
  43 namespace Two {
  44 namespace Kevin {
  45 enum class B { d,
  46                e,
  47                f };
  48 }
  49
  50 using enum Kevin::B;
  51 #if __cplusplus < 202002
  52 // expected-warning@-2{{is a C++20 extension}}
  53 #endif
  54 auto w = e;
  55
  56 } // namespace Two
  57
  58 #if __cplusplus >= 202002
  59 // Now only check c++20 onwards
  60
  61 namespace Three {
  62 namespace Stuart {
  63 enum class C : int; // expected-note{{declared here}}
  64 }
  65
  66 using enum Stuart::C; // expected-error{{is incomplete}}
  67 } // namespace Three
  68
  69 namespace Four {
  70 class Dave {
  71 public:
  72   enum D { a,
  73            b,
  74            c };
  75
  76 private:
  77   enum class E { d, // expected-note{{declared private here}}
  78                  e,
  79                  f };
  80 };
  81
  82 using enum Dave::D;
  83 using enum Dave::E; // expected-error{{is a private member}}
  84
  85 } // namespace Four
  86
  87 namespace Five {
  88 enum class A { b,
  89                c };
  90 class Dave {
  91 public:
  92   using enum A;
  93   A f = b;
  94 };
  95
  96 } // namespace Five
  97
  98 namespace Six {
  99 template <typename T> class TPL;
 100 template <> class TPL<int> {
 101 public:
 102   enum A { a };
 103 };
 104
 105 template <typename T> class USR {
 106   using enum TPL<T>::B; // expected-error{{cannot name a dependent type}}
 107   using enum TPL<int>::A;
 108 };
 109 } // namespace Six
 110
 111 // Now instantiate things
 112 namespace Seven {
 113 namespace Stuart {
 114 enum class A { a,
 115                b,
 116                c };
 117 }
 118
 119 static_assert(!int(Stuart::A::a));
 120 constexpr int Bar() {
 121   using enum Stuart::A;
 122   return int(b);
 123 }
 124 static_assert(Bar() == 1);
 125
 126 template <int I> constexpr int Foo() {
 127   using enum Stuart::A;
 128   return int(b) + I;
 129 }
 130
 131 static_assert(Foo<10>() == 11);
 132
 133 template <int I> struct C {
 134   using enum Stuart::A;
 135   static constexpr int V = int(c) + I;
 136
 137   enum class D { d,
 138                  e,
 139                  f };
 140   using enum D;
 141
 142   static constexpr int W = int(f) + I;
 143 };
 144
 145 static_assert(C<2>::V == 4);
 146 static_assert(C<20>::W == 22);
 147
 148 } // namespace Seven
 149
 150 namespace Eight {
 151 enum class Bob : int {};
 152 using enum Bob;
 153 } // namespace Eight
 154
 155 namespace Nine {
 156 template <int I> struct C {
 157   enum class D { i = I };
 158   enum class E : int; // expected-note{{declared here}}
 159 };
 160
 161 using enum C<2>::D;
 162
 163 constexpr auto d = i;
 164 static_assert(unsigned(d) == 2);
 165
 166 using enum C<2>::E; // expected-error{{instantiation of undefined member}}
 167 } // namespace Nine
 168
 169 namespace Ten {
 170 enum class Bob { a };
 171
 172 void Foo() {
 173   extern void a();
 174 }
 175
 176 // We don't see the hidden extern a fn!
 177 using enum Bob;
 178
 179 auto v = a;
 180 } // namespace Ten
 181
 182 namespace Eleven {
 183 enum class Bob { a }; // expected-note{{conflicting declaration}}
 184
 185 struct Base {
 186   enum { a }; // expected-note{{target of using}}
 187 };
 188
 189 template <typename B>
 190 class TPLa : B {
 191   using enum Bob;
 192   using B::a; // expected-error{{target of using declaration}}
 193 };
 194
 195 TPLa<Base> a; // expected-note{{in instantiation}}
 196
 197 } // namespace Eleven
 198
 199 namespace Twelve {
 200 enum class Bob { a }; // expected-note{{target of using}}
 201
 202 struct Base {
 203   enum { a };
 204 };
 205
 206 template <typename B>
 207 class TPLb : B {
 208   using B::a;     // expected-note{{conflicting declaration}}
 209   using enum Bob; // expected-error{{target of using declaration}}
 210 };
 211
 212 TPLb<Base> b;
 213
 214 } // namespace Twelve
 215
 216 namespace Thirteen {
 217 enum class Bob { a };
 218 class Foo {
 219   using enum Bob; // expected-note{{previous using-enum}}
 220   using enum Bob; // expected-error{{redeclaration of using-enum}}
 221 };
 222
 223 template <typename B>
 224 class TPLa {
 225   using enum Bob; // expected-note{{previous using-enum}}
 226   using enum Bob; // expected-error{{redeclaration of using-enum}}
 227 };
 228
 229 TPLa<int> a;
 230
 231 } // namespace Thirteen
 232
 233 #endif