Implement 'using-enum-declaration' with splices.

To implement this, splits 'ActOnUsingEnumDeclaration' into two overloads: One which acts on an identifier, and one which acts directly on an already known type. Closes issue #3.
bloomberg · Mar 16, 2024 · 704c44e · 704c44e
1 parent c25fdbd
commit 704c44e
Show file tree

Hide file tree

Showing 4 changed files with 55 additions and 0 deletions.
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
@@ -4150,6 +4150,11 @@ class Sema final {
                                   SourceLocation EnumLoc,
                                   SourceLocation IdentLoc, IdentifierInfo &II,
                                   CXXScopeSpec *SS = nullptr);
+  Decl *ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS,
+                                  SourceLocation UsingLoc,
+                                  SourceLocation EnumLoc,
+                                  SourceLocation IdentLoc, QualType EnumTy,
+                                  TypeSourceInfo *TSI);
   Decl *ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS,
                               MultiTemplateParamsArg TemplateParams,
                               SourceLocation UsingLoc, UnqualifiedId &Name,

diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp
@@ -806,6 +806,32 @@ Parser::DeclGroupPtrTy Parser::ParseUsingDeclaration(
       return nullptr;
     }
 
+    if (Tok.is(tok::annot_splice)) {
+      SourceLocation SpliceLoc = Tok.getLocation();
+      TypeResult TR = ParseCXXSpliceAsType(/*AllowDependent=*/true,
+                                           /*Complain=*/true);
+      if (TR.isInvalid()) {
+        SkipUntil(tok::semi);
+        return nullptr;
+      }
+      TypeSourceInfo *TSI;
+      QualType EnumTy = Actions.GetTypeFromParser(TR.get(), &TSI);
+      if (EnumTy.isNull()) {
+        SkipUntil(tok::semi);
+        return nullptr;
+      }
+
+      Decl *UED = Actions.ActOnUsingEnumDeclaration(getCurScope(), AS, UsingLoc,
+                                                    UELoc, SpliceLoc, EnumTy,
+                                                    TSI);
+      if (!UED) {
+        SkipUntil(tok::semi);
+        return nullptr;
+      }
+
+      return Actions.ConvertDeclToDeclGroup(UED);
+    }
+
     if (!Tok.is(tok::identifier)) {
       Diag(Tok.getLocation(), diag::err_using_enum_expect_identifier)
           << Tok.is(tok::kw_enum);

diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -12466,6 +12466,16 @@ Decl *Sema::ActOnUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
     return nullptr;
   }
 
+  return ActOnUsingEnumDeclaration(S, AS, UsingLoc, EnumLoc, IdentLoc, EnumTy,
+                                   TSI);
+}
+
+Decl *Sema::ActOnUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
+                                      SourceLocation UsingLoc,
+                                      SourceLocation EnumLoc,
+                                      SourceLocation IdentLoc,
+                                      QualType EnumTy,
+                                      TypeSourceInfo *TSI) {
   auto *Enum = dyn_cast_if_present<EnumDecl>(EnumTy->getAsTagDecl());
   if (!Enum) {
     Diag(IdentLoc, diag::err_using_enum_not_enum) << EnumTy;

diff --git a/clang/test/Reflection/splice-types.cpp b/clang/test/Reflection/splice-types.cpp
@@ -160,6 +160,20 @@ static_assert(static_cast<Enum>([:rEnumCls:]::B) == [:rEnum:]::B);
 // Splicing of a dependent reflection of an enum class.
 template <info R> consteval int bval() { return int([:R:]::B); }
 static_assert(bval<^Enum>() == bval<^EnumCls>());
+
+// using-enum-declaration with a splice.
+namespace {
+using enum [:rEnumCls:];
+static_assert(int(C) == 2);
+}  // namespace
+
+// using-enum-declaration with a qualified-id having a splice as the leading
+// nested-name-specifier.
+namespace {
+constexpr auto rns = ^with_enum_types;
+using enum [:rns:]::EnumCls;
+static_assert(int(B) == 1);
+}  // namespace
 }  // namespace with_enum_types
 
                              // ===================