[clang] Support C++20's using ENUM_ID::IDENTIFIER

[AntonBikineev]

Summary

This change merely allows nested-name-specifiers for enums in using
declarations but doesn't add support for the "using-enum-declaration"
syntax proposed in P1099.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def note_ambiguous_inherited_constructor_using : Note<
   "inherited from base class %0 here">;
 def note_using_decl_class_member_workaround : Note<
   "use %select{an alias declaration|a typedef declaration|a reference|"
   "a const variable|a constexpr variable}0 instead">;
 def err_using_decl_can_not_refer_to_namespace : Error<
   "using declaration cannot refer to a namespace">;
 def err_using_decl_can_not_refer_to_scoped_enum : Error<
-  "using declaration cannot refer to a scoped enumerator">;
+  "using declaration cannot refer to a scoped enumerator before C++20">;
 def err_using_decl_constructor : Error<
   "using declaration cannot refer to a constructor">;
 def warn_cxx98_compat_using_decl_constructor : Warning<
   "inheriting constructors are incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_using_decl_destructor : Error<
   "using declaration cannot refer to a destructor">;
 def err_using_decl_template_id : Error<

clang/lib/Sema/SemaDeclCXX.cpp

     Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
       << SS.getRange();
     return BuildInvalid();
   }
 
   // C++14 [namespace.udecl]p7:
   // A using-declaration shall not name a scoped enumerator.
   if (auto *ED = R.getAsSingle<EnumConstantDecl>()) {
-    if (cast<EnumDecl>(ED->getDeclContext())->isScoped()) {
+    if (!LangOpts.CPlusPlus20 &&
+        cast<EnumDecl>(ED->getDeclContext())->isScoped()) {
       Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_scoped_enum)
         << SS.getRange();
       return BuildInvalid();
     }
   }
 
   UsingDecl *UD = BuildValid();
 

                                    const DeclarationNameInfo &NameInfo,
                                    SourceLocation NameLoc) {
   DeclContext *NamedContext = computeDeclContext(SS);
 
   if (!CurContext->isRecord()) {
     // C++03 [namespace.udecl]p3:
     // C++0x [namespace.udecl]p8:
     //   A using-declaration for a class member shall be a member-declaration.
+    // C++20 [namespace.udecl]p7:
+    //   A using-declaration that names a class member other than an enumerator
+    //   shall be a member-declaration.
 
     // If we weren't able to compute a valid scope, it might validly be a
-    // dependent class scope or a dependent enumeration unscoped scope. If
-    // we have a 'typename' keyword, the scope must resolve to a class type.
+    // dependent class scope or a dependent scoped/unscoped enumeration scope.
+    // If we have a 'typename' keyword, the scope must resolve to a class type.
     if ((HasTypename && !NamedContext) ||
         (NamedContext && NamedContext->getRedeclContext()->isRecord())) {
       auto *RD = NamedContext
                      ? cast<CXXRecordDecl>(NamedContext->getRedeclContext())
                      : nullptr;
       if (RD && RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), RD))
         RD = nullptr;
 

     // nested-name-specifier does not refer to a base class, which is
     // still possible in some cases.
 
     // Otherwise we have to conservatively report that things might be
     // okay.
     return false;
   }
 
-  if (!NamedContext->isRecord()) {
+  bool IsCXX20ScopedEnum = LangOpts.CPlusPlus20 &&
+                           NamedContext->getDeclKind() == Decl::Enum &&
+                           cast<EnumDecl>(NamedContext)->isScoped();
+
+  if (!NamedContext->isRecord() && !IsCXX20ScopedEnum) {
     // Ideally this would point at the last name in the specifier,
     // but we don't have that level of source info.
     Diag(SS.getRange().getBegin(),
          diag::err_using_decl_nested_name_specifier_is_not_class)
       << SS.getScopeRep() << SS.getRange();
     return true;
   }
 
   if (!NamedContext->isDependentContext() &&
       RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
     return true;
 
   if (getLangOpts().CPlusPlus11) {
     // C++11 [namespace.udecl]p3:
     //   In a using-declaration used as a member-declaration, the
     //   nested-name-specifier shall name a base class of the class
     //   being defined.
 
+    // C++20 [namespace.udecl]p3:
+    //   In a using-declaration used as a member-declaration, each
+    //   using-declarator shall either name an enumerator or have a
+    //   nested-name-specifier naming a base class of the class being defined.
+    if (IsCXX20ScopedEnum)
+      return false;
+
     if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
                                  cast<CXXRecordDecl>(NamedContext))) {
       if (CurContext == NamedContext) {
         Diag(NameLoc,
              diag::err_using_decl_nested_name_specifier_is_current_class)
           << SS.getRange();
         return true;
       }

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

+// RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify %s
+
+enum class E {
+  e1,
+  e2
+};
+
+void foo() {
+  using E::e1;
+  auto a = e1;
+}
+
+namespace N {
+using E::e2;
+constexpr auto a = e2;
+} // namespace N
+
+struct C {
+  using E::e1;
+  E e = e1;
+};
+
+namespace N1 {
+enum class E {
+  e1,
+};
+using E::e1;
+auto a = e1;
+} // namespace N1
+
+enum class E1 {
+  e1 // expected-note{{conflicting declaration}}
+};
+enum class E2 {
+  e1 // expected-note{{target of using declaration}}
+};
+using E1::e1;
+using E2::e1; // expected-error{{target of using declaration conflicts with declaration already in scope}}

clang/test/SemaCXX/enum-scoped.cpp

namespace PR18044 {
   int E::e = 0; // expected-error {{does not refer into a class}}
   void E::f() {} // expected-error {{does not refer into a class}}
   struct E::S {}; // expected-error {{no struct named 'S'}}
   struct T : E::S {}; // expected-error {{expected class name}}
   enum E::E {}; // expected-error {{no enum named 'E'}}
   int E::*p; // expected-error {{does not point into a class}}
   using E::f; // expected-error {{no member named 'f'}}
 
-  using E::a; // expected-error {{using declaration cannot refer to a scoped enumerator}}
+  using E::a; // expected-error {{using declaration cannot refer to a scoped enumerator before C++20}}
   E b = a; // expected-error {{undeclared}}
 }
 
 namespace test11 {
   enum class E { a };
   typedef E E2;
   E2 f1() { return E::a; }
 
   bool f() { return !f1(); } // expected-error {{invalid argument type 'test11::E2' (aka 'test11::E') to unary expression}}
 }
 
 namespace PR35586 {
   enum C { R, G, B };
   enum B { F = (enum C) -1, T}; // this should compile cleanly, it used to assert.
 };