302 lines · cpp
1// RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify %s2// RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify %s -fexperimental-new-constant-interpreter3// RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify %s -fexperimental-new-constant-interpreter4 5// p1099 'using enum ELABORATED-ENUM-SPECIFIER ;'6 7namespace One {8namespace Bob {9enum A { a, // expected-note{{declared here}}10 b,11 c };12class C;13enum class D : int;14enum class D { d,15 e,16 f };17enum class D : int;18} // namespace Bob19 20using enum Bob::A;21#if __cplusplus < 20200222// expected-warning@-2{{is a C++20 extension}}23#endif24using enum Bob::B; // expected-error{{unknown type name B}}25#if __cplusplus < 20200226// expected-warning@-2{{is a C++20 extension}}27#endif28using enum Bob::C; // expected-error{{'Bob::C' is not an enumerated type}}29#if __cplusplus < 20200230// expected-warning@-2{{is a C++20 extension}}31#endif32auto v = a;33 34A g; // expected-error{{unknown type name 'A'}}35 36int A;37 38using enum Bob::D;39#if __cplusplus < 20200240// expected-warning@-2{{is a C++20 extension}}41#endif42 43void DR2621() {44 using A_t = Bob::A;45 using enum A_t;46#if __cplusplus < 20200247// expected-warning@-2{{is a C++20 extension}}48#endif49 A_t x = a;50}51 52} // namespace One53 54namespace Two {55namespace Kevin {56enum class B { d,57 e,58 f };59}60 61using enum Kevin::B;62#if __cplusplus < 20200263// expected-warning@-2{{is a C++20 extension}}64#endif65auto w = e;66 67} // namespace Two68 69#if __cplusplus >= 20200270// Now only check c++20 onwards71 72namespace Three {73namespace Stuart {74enum class C : int; // expected-note{{declared here}}75}76 77using enum Stuart::C; // expected-error{{is incomplete}}78} // namespace Three79 80namespace Four {81class Dave {82public:83 enum D { a,84 b,85 c };86 87private:88 enum class E { d, // expected-note{{declared private here}}89 e,90 f };91};92 93using enum Dave::D;94using enum Dave::E; // expected-error{{is a private member}}95 96} // namespace Four97 98namespace Five {99enum class A { b,100 c };101class Dave {102public:103 using enum A;104 A f = b;105};106 107} // namespace Five108 109namespace Six {110template <typename T> class TPL;111template <> class TPL<int> {112public:113 enum A { a };114};115 116template <typename T> class USR {117 using enum TPL<T>::B; // expected-error{{cannot name a dependent type}}118 using enum TPL<int>::A;119};120} // namespace Six121 122// Now instantiate things123namespace Seven {124namespace Stuart {125enum class A { a,126 b,127 c };128}129 130static_assert(!int(Stuart::A::a));131constexpr int Bar() {132 using enum Stuart::A;133 return int(b);134}135static_assert(Bar() == 1);136 137template <int I> constexpr int Foo() {138 using enum Stuart::A;139 return int(b) + I;140}141 142static_assert(Foo<10>() == 11);143 144template <int I> struct C {145 using enum Stuart::A;146 static constexpr int V = int(c) + I;147 148 enum class D { d,149 e,150 f };151 using enum D; // expected-error {{using-enum cannot name a dependent type}}152};153 154static_assert(C<2>::V == 4);155 156} // namespace Seven157 158namespace Eight {159enum class Bob : int {};160using enum Bob;161} // namespace Eight162 163namespace Nine {164template <int I> struct C {165 enum class D { i = I };166 enum class E : int; // expected-note{{declared here}}167};168 169using enum C<2>::D;170 171constexpr auto d = i;172static_assert(unsigned(d) == 2);173 174using enum C<2>::E; // expected-error{{instantiation of undefined member}}175} // namespace Nine176 177namespace Ten {178enum class Bob { a };179 180void Foo() {181 extern void a();182}183 184// We don't see the hidden extern a fn!185using enum Bob;186 187auto v = a;188} // namespace Ten189 190namespace Eleven {191enum class Bob { a }; // expected-note{{conflicting declaration}}192 193struct Base {194 enum { a }; // expected-note{{target of using}}195};196 197template <typename B>198class TPLa : B {199 using enum Bob;200 using B::a; // expected-error{{target of using declaration}}201};202 203TPLa<Base> a; // expected-note{{in instantiation}}204 205} // namespace Eleven206 207namespace Twelve {208enum class Bob { a }; // expected-note{{target of using}}209 210struct Base {211 enum { a };212};213 214template <typename B>215class TPLb : B {216 using B::a; // expected-note{{conflicting declaration}}217 using enum Bob; // expected-error{{target of using declaration}}218};219 220TPLb<Base> b;221 222} // namespace Twelve223 224namespace Thirteen {225enum class Bob { a };226class Foo {227 using enum Bob; // expected-note{{previous using-enum}}228 using enum Bob; // expected-error{{redeclaration of using-enum}}229};230 231template <typename B>232class TPLa {233 using enum Bob; // expected-note{{previous using-enum}}234 using enum Bob; // expected-error{{redeclaration of using-enum}}235};236 237TPLa<int> a;238 239} // namespace Thirteen240 241namespace Fourteen {242template<typename T>243int A = T();244 245using enum A<int>; // expected-error {{A is not an enumerated type}}246} // namespace Fourteen247 248namespace GH58057 {249struct Wrap {250enum Things {251 Value1,252 Value2253};254};255 256using enum Wrap::Things;257 258int f() {259 return (Value1 | Value2);260}261}262 263namespace GH59014 {264struct X {265 enum Masks {Mask = 1,Shift = 0};266};267 268void f(int a) {269 using enum X::Masks;270 271 auto u = (Mask);272 auto v = (Mask << Shift);273 void (~(Mask));274}275}276 277namespace GH147495 {278struct S {279 enum class E { A };280 using enum E;281 282 struct S1 {283 using enum E;284 };285 286 struct S2 {287 using E::A;288 };289};290}291 292namespace Redecl {293 enum class A : int { X };294 enum class A : int;295 template <class> struct B {296 using enum A;297 using Z = decltype(X);298 };299 template struct B<int>;300} // namespace Redecl301#endif302