[AST] Preserve more structure in UsingEnumDecl node.

[sammccall]

Summary

• store NestedNameSpecifier & Loc for the qualifiers This information was entirely missing from the AST.
• expose the location information for enum/qualifier/identifier as typeloc (ElaboratedTypeLoc+EnumTypeLoc for now). This allows many traversals/astmatchers etc to handle these generically along with other references. The decl vs type split can help preserve typedef sugar when https://github.com/llvm/llvm-project/issues/57659 is resolved.
• fix the SourceRange of UsingEnumDecl to include 'using'.

Fixes https://github.com/clangd/clangd/issues/1283

[sammccall]

I just saw this touches the same code as @urnathan's D134283, specifically Sema::ActOnUsingEnumDeclaration.

I'm happy to wait for that to land and then merge, I think these will play nicely together. The changes to the actual UsingEnumDecl class are the main thing I'd like some feedback on, and those won't be affected.

[urnathan]

AFAICT the UsingDecl doesn't capture the NestedNameSpecifier location, is UsingEnumDecl special in some way, or would this information be better placed in BaseUsingDecl? Thanks for spotting the possible mid-air collistion with D134283.

[sammccall]

In D134303#3805687, @urnathan wrote:

AFAICT the UsingDecl doesn't capture the NestedNameSpecifier location

We have NestedNameSpecifierLoc UsingDecl::QualifierLoc already, maybe I'm misunderstanding.

is UsingEnumDecl special in some way, or would this information be better placed in BaseUsingDecl?

It would be possible to unify the two by moving UsingDecl's QualifierLoc into BaseUsingDecl..

I think this comes at the cost of a worse API for UsingEnumDecl: making the qualifier as part of a Typeloc/TypeSourceInfo means that AST consumers with some generic handling for TypeLocs can reuse it. (e.g. the clangd changes in this patch are mostly just testing various things that now work for free).

UsingDecl already has that comparatively awkward API today - it's one of the AST nodes that very often needs to be handled explicitly - unavoidably as "reference to a decl" is not modeled in the AST, and because it may point to an overload set etc anyway.

[martong]

clang/lib/AST/ASTImporter.cpp

4868–4870

This name would be more consistent with getEnumType.

[urnathan]

Does this still apply with the fix for dr2621 landed?

[sammccall]

In D134303#3823620, @urnathan wrote:

Does this still apply with the fix for dr2621 landed?

Not cleanly, as getType already creates the ElaboratedTypeLoc for the qualifier but without the enum keyword. Wrapping it with a second ElaboratedType isn't consistent with how these types are modeled elsewhere in the AST. Plumbing through parameters to make getType() add the elaborated-type-keyword seems disproportionately invasive.
I think probably it's best just to drop the idea that "enum" is part of a tag name (especially since now the name can be a typedef) and keep treating it as an extra SourceLocation instead.

[sammccall]

Rebase on top of using enum parsing changes, store 'enum' location separately.

[sammccall]

ping, +additional potential reviewer

[ilya-biryukov]

Modelling this as a TypeLoc for code reuse reasons gives me a pause too.
However, I think we still accept this as keeping the clients simpler seems like the right trade-off to me.

Putting information about both typedefs and qualifiers explicitly will make the representation of UsingEnumDecl way too complicated for a seemingly simple and niche feature.

clang-tools-extra/clangd/unittests/SelectionTests.cpp

554

Could we also test that checks what happens in presence of typedefs?

namespace enums {
  enum class X { a, b};
  using Y = X;
}

namespace uses {
    using enum enums::Y;
}

[hokein]

it looks good to me, just a few optional nits.

clang/include/clang/AST/DeclCXX.h

3618

nit: we only rename EnumLocation but not the UsingLocation, it is a little wired, I think either we rename both or keep both unchanged.

3623

I think we can probably get rid of the Enum field, since we are storing the EnumType and we can get the EnumDecl by dyn_cast<EnumDecl>(EnumType->getType()->getAsTagDecl())

clang/lib/Sema/SemaDeclCXX.cpp

11857

nit: adding = nullptr initializer

[sammccall]

clang/include/clang/AST/DeclCXX.h

3618

oops, at some point this was matching the use of a TypeLoc vs SourceLocation, but no longer does. Fixed

3623

Good point. Did this an added an assert in create().

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : ConstDeclVisitor<Visitor> {
     void VisitUsingDecl(const UsingDecl *D) {
       // "using ns::identifier;" is a non-declaration reference.
       Refs.push_back(ReferenceLoc{
           D->getQualifierLoc(), D->getLocation(), /*IsDecl=*/false,
           explicitReferenceTargets(DynTypedNode::create(*D),
                                    DeclRelation::Underlying, Resolver)});
     }
 
+    void VisitUsingEnumDecl(const UsingEnumDecl *D) {
+      // "using enum ns::E" is a non-declaration reference.
+      // The reference is covered by the embedded typeloc.
+      // Don't use the default VisitNamedDecl, which would report a declaration.
+    }
+
     void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
       // For namespace alias, "namespace Foo = Target;", we add two references.
       // Add a declaration reference for Foo.
       VisitNamedDecl(D);
       // Add a non-declaration reference for Target.
       Refs.push_back(ReferenceLoc{D->getQualifierLoc(),
                                   D->getTargetNameLoc(),
                                   /*IsDecl=*/false,

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
        {R"cpp(
           namespace ns { int global; }
           void foo() {
             using $0^ns::$1^global;
           }
         )cpp",
         "0: targets = {ns}\n"
         "1: targets = {ns::global}, qualifier = 'ns::'\n"},
+       // Using enum declarations.
+       {R"cpp(
+          namespace ns { enum class A {}; }
+          void foo() {
+            using enum $0^ns::$1^A;
+          }
+        )cpp",
+        "0: targets = {ns}\n"
+        "1: targets = {ns::A}, qualifier = 'ns::'\n"},
        // Simple types.
        {R"cpp(
          struct Struct { int a; };
          using Typedef = int;
          void foo() {
            $0^Struct $1^x;
            $2^Typedef $3^y;
            static_cast<$4^Struct*>(0);

clang-tools-extra/clangd/unittests/SelectionTests.cpp

Case Cases[] = {
       {R"cpp(
         /*error-ok*/
         void func() [[{^]])cpp",
        "CompoundStmt"},
       {R"cpp(
         void func() { [[__^func__]]; }
         )cpp",
        "PredefinedExpr"},
+
+      {R"cpp(
+        namespace ns { enum class A {}; };
+        using enum ns::[[^A]];
+        )cpp",
+       "EnumTypeLoc"},
+      {R"cpp(
+        namespace ns { enum class A {}; };
+        using enum [[^ns::]]A;
+        )cpp",
+       "NestedNameSpecifierLoc"},
+      {R"cpp(
+        namespace ns { enum class A {}; };
+        [[using ^enum ns::A]];
+        )cpp",
+       "UsingEnumDecl"},
+      {R"cpp(
+        namespace ns { enum class A {}; };
+        [[^using enum ns::A]];
+        )cpp",
+       "UsingEnumDecl"},
   };
 
   for (const Case &C : Cases) {
     trace::TestTracer Tracer;
     Annotations Test(C.Code);
 
     TestTU TU;
     TU.Code = std::string(Test.code());
 
     TU.ExtraArgs.push_back("-xobjective-c++");
+    TU.ExtraArgs.push_back("-std=c++20");
 
     auto AST = TU.build();
     auto T = makeSelectionTree(C.Code, AST);
     EXPECT_EQ("TranslationUnitDecl", nodeKind(&T.root())) << C.Code;
 
     if (Test.ranges().empty()) {
       // If no [[range]] is marked in the example, there should be no selection.
       EXPECT_FALSE(T.commonAncestor()) << C.Code << "\n" << T;

clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp

)cpp",
         using $Primitive_decl[[MyTypedef]] = int;
         enum $Enum_decl[[MyEnum]] : $Primitive[[MyTypedef]] {};
       )cpp",
       // Enum base specifier
       R"cpp(
         typedef int $Primitive_decl[[MyTypedef]];
         enum $Enum_decl[[MyEnum]] : $Primitive[[MyTypedef]] {};
       )cpp",
+      // Using enum
+      R"cpp(
+      enum class $Enum_decl[[Color]] { $EnumConstant_decl_readonly[[Black]] };
+      namespace $Namespace_decl[[ns]] {
+        using enum $Enum[[Color]];
+        $Enum[[Color]] $Variable_decl[[ModelT]] = $EnumConstant[[Black]];
+      }
+      )cpp",
       // Issue 1096
       R"cpp(
         void $Function_decl[[Foo]]();
         // Use <: :> digraphs for deprecated attribute to avoid conflict with annotation syntax
         <:<:deprecated:>:> void $Function_decl_deprecated[[Foo]](int* $Parameter_decl[[x]]);
         void $Function_decl[[Foo]](int $Parameter_decl[[x]]);
         template <typename $TemplateParameter_decl[[T]]>
         void $Function_decl[[Bar]]($TemplateParameter[[T]] $Parameter_decl[[x]]) {

clang/include/clang/AST/DeclCXX.h

 /// For example:
 /// \code
 ///    using enum SomeEnumTag ;
 /// \endcode
 
 class UsingEnumDecl : public BaseUsingDecl, public Mergeable<UsingEnumDecl> {
   /// The source location of the 'using' keyword itself.
   SourceLocation UsingLocation;
-
-  /// Location of the 'enum' keyword.
-  SourceLocation EnumLocation;
+  /// The source location of the 'enum' keyword.
+  SourceLocation EnumLoc;
+  /// 'qual::SomeEnum' as an EnumType, possibly with Elaborated/Typedef sugar.
+  TypeSourceInfo *EnumType;
 
   /// The enum
   EnumDecl *Enum;
 
   UsingEnumDecl(DeclContext *DC, DeclarationName DN, SourceLocation UL,
-                SourceLocation EL, SourceLocation NL, EnumDecl *ED)
-      : BaseUsingDecl(UsingEnum, DC, NL, DN), UsingLocation(UL),
-        EnumLocation(EL), Enum(ED) {}
+                SourceLocation EL, SourceLocation NL, TypeSourceInfo *EnumType,
+                EnumDecl *ED)
+      : BaseUsingDecl(UsingEnum, DC, NL, DN), UsingLocation(UL), EnumLoc(EL),
+        EnumType(EnumType), Enum(ED) {}
 
   void anchor() override;
 
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
   /// The source location of the 'using' keyword.
   SourceLocation getUsingLoc() const { return UsingLocation; }
   void setUsingLoc(SourceLocation L) { UsingLocation = L; }
 
   /// The source location of the 'enum' keyword.
-  SourceLocation getEnumLoc() const { return EnumLocation; }
-  void setEnumLoc(SourceLocation L) { EnumLocation = L; }
+  SourceLocation getEnumLoc() const { return EnumLoc; }
+  void setEnumLoc(SourceLocation L) { EnumLoc = L; }
+  NestedNameSpecifier *getQualifier() const {
+    return getQualifierLoc().getNestedNameSpecifier();
+  }
+  NestedNameSpecifierLoc getQualifierLoc() const {
+    if (auto ETL = EnumType->getTypeLoc().getAs<ElaboratedTypeLoc>())
+      return ETL.getQualifierLoc();
+    return NestedNameSpecifierLoc();
+  }
+  // Returns the "qualifier::Name" part as a TypeLoc.
+  TypeLoc getEnumTypeLoc() const {
+    return EnumType->getTypeLoc();
+  }
+  TypeSourceInfo *getEnumType() const {
+    return EnumType;
+  }
+  void setEnumType(TypeSourceInfo *TSI) { EnumType = TSI; }
 
 public:
   EnumDecl *getEnumDecl() const { return Enum; }
 
   static UsingEnumDecl *Create(ASTContext &C, DeclContext *DC,
                                SourceLocation UsingL, SourceLocation EnumL,
-                               SourceLocation NameL, EnumDecl *ED);
+                               SourceLocation NameL, TypeSourceInfo *EnumType,
+                               EnumDecl *ED);
 
   static UsingEnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   SourceRange getSourceRange() const override LLVM_READONLY;
 
   /// Retrieves the canonical declaration of this declaration.
   UsingEnumDecl *getCanonicalDecl() override {
     return cast<UsingEnumDecl>(getFirstDecl());

clang/include/clang/AST/RecursiveASTVisitor.h

DEF_TRAVERSE_DECL(ObjCPropertyDecl, {
   ShouldVisitChildren = false;
 })
 
 DEF_TRAVERSE_DECL(UsingDecl, {
   TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
   TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
 })
 
-DEF_TRAVERSE_DECL(UsingEnumDecl, {})
+DEF_TRAVERSE_DECL(UsingEnumDecl,
+                  { TRY_TO(TraverseTypeLoc(D->getEnumTypeLoc())); })
 
 DEF_TRAVERSE_DECL(UsingPackDecl, {})
 
 DEF_TRAVERSE_DECL(UsingDirectiveDecl, {
   TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
 })
 
 DEF_TRAVERSE_DECL(UsingShadowDecl, {})

clang/include/clang/Sema/Sema.h

NamedDecl *BuildUsingDeclaration(
       Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
       bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
       DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
       const ParsedAttributesView &AttrList, bool IsInstantiation,
       bool IsUsingIfExists);
   NamedDecl *BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
                                        SourceLocation UsingLoc,
                                        SourceLocation EnumLoc,
-                                       SourceLocation NameLoc, EnumDecl *ED);
+                                       SourceLocation NameLoc,
+                                       TypeSourceInfo *EnumType, EnumDecl *ED);
   NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
                                 ArrayRef<NamedDecl *> Expansions);
 
   bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);
 
   /// Given a derived-class using shadow declaration for a constructor and the
   /// correspnding base class constructor, find or create the implicit
   /// synthesized derived class constructor to use for this initialization.

clang/lib/AST/ASTImporter.cpp

ExpectedDecl ASTNodeImporter::VisitUsingEnumDecl(UsingEnumDecl *D) {
   NamedDecl *ToD = nullptr;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
     return std::move(Err);
   if (ToD)
     return ToD;
 
   Error Err = Error::success();
   auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
   auto ToEnumLoc = importChecked(Err, D->getEnumLoc());
+  auto ToNameLoc = importChecked(Err, D->getLocation());
+  auto ToEnumType = importChecked(Err, D->getEnumType());
   auto ToEnumDecl = importChecked(Err, D->getEnumDecl());
   if (Err)
     return std::move(Err);
 
   UsingEnumDecl *ToUsingEnum;
   if (GetImportedOrCreateDecl(ToUsingEnum, D, Importer.getToContext(), DC,
-                              ToUsingLoc, ToEnumLoc, Loc, ToEnumDecl))
+                              ToUsingLoc, ToEnumLoc, ToNameLoc, ToEnumType,
+                              ToEnumDecl))
     return ToUsingEnum;
 
   ToUsingEnum->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToUsingEnum);
 
   if (UsingEnumDecl *FromPattern =
           Importer.getFromContext().getInstantiatedFromUsingEnumDecl(D)) {
     if (Expected<UsingEnumDecl *> ToPatternOrErr = import(FromPattern))

clang/lib/AST/DeclCXX.cpp

SourceRange UsingDecl::getSourceRange() const {
   SourceLocation Begin = isAccessDeclaration()
     ? getQualifierLoc().getBeginLoc() : UsingLocation;
   return SourceRange(Begin, getNameInfo().getEndLoc());
 }
 
 void UsingEnumDecl::anchor() {}
 
 UsingEnumDecl *UsingEnumDecl::Create(ASTContext &C, DeclContext *DC,
-                                     SourceLocation UL, SourceLocation EL,
-                                     SourceLocation NL, EnumDecl *Enum) {
-  return new (C, DC) UsingEnumDecl(DC, Enum->getDeclName(), UL, EL, NL, Enum);
+                                     SourceLocation UL,
+                                     SourceLocation EL,
+                                     SourceLocation NL,
+                                     TypeSourceInfo *EnumType,
+                                     EnumDecl *Enum) {
+  return new (C, DC)
+      UsingEnumDecl(DC, Enum->getDeclName(), UL, EL, NL, EnumType, Enum);
 }
 
 UsingEnumDecl *UsingEnumDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) UsingEnumDecl(nullptr, DeclarationName(), SourceLocation(),
-                                   SourceLocation(), SourceLocation(), nullptr);
+  return new (C, ID)
+      UsingEnumDecl(nullptr, DeclarationName(), SourceLocation(),
+                    SourceLocation(), SourceLocation(), nullptr, nullptr);
 }
 
 SourceRange UsingEnumDecl::getSourceRange() const {
-  return SourceRange(EnumLocation, getLocation());
+  return SourceRange(UsingLocation, EnumType->getTypeLoc().getEndLoc());
 }
 
 void UsingPackDecl::anchor() {}
 
 UsingPackDecl *UsingPackDecl::Create(ASTContext &C, DeclContext *DC,
                                      NamedDecl *InstantiatedFrom,
                                      ArrayRef<NamedDecl *> UsingDecls) {
   size_t Extra = additionalSizeToAlloc<NamedDecl *>(UsingDecls.size());

clang/lib/Sema/SemaDeclCXX.cpp

 }
 
 Decl *Sema::ActOnUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
                                       SourceLocation UsingLoc,
                                       SourceLocation EnumLoc,
                                       SourceLocation IdentLoc,
                                       IdentifierInfo &II, CXXScopeSpec *SS) {
   assert(!SS->isInvalid() && "ScopeSpec is invalid");
-  ParsedType TypeRep = getTypeName(II, IdentLoc, S, SS);
-  if (!TypeRep) {
+  TypeSourceInfo *TSI;
+  QualType EnumTy = GetTypeFromParser(
+      getTypeName(II, IdentLoc, S, SS, /*isClassName=*/false,
+                  /*HasTrailingDot=*/false,
+                  /*ObjectType=*/nullptr, /*IsCtorOrDtorName=*/false,
+                  /*WantNontrivialTypeSourceInfo=*/true),
+      &TSI);
+  if (EnumTy.isNull()) {
     Diag(IdentLoc, SS && isDependentScopeSpecifier(*SS)
                        ? diag::err_using_enum_is_dependent
                        : diag::err_unknown_typename)
         << II.getName()
         << SourceRange(SS ? SS->getBeginLoc() : IdentLoc, IdentLoc);
     return nullptr;
   }
 
-  auto *Enum = dyn_cast_if_present<EnumDecl>(TypeRep.get()->getAsTagDecl());
+  auto *Enum = dyn_cast_if_present<EnumDecl>(EnumTy->getAsTagDecl());
   if (!Enum) {
-    Diag(IdentLoc, diag::err_using_enum_not_enum) << TypeRep.get();
+    Diag(IdentLoc, diag::err_using_enum_not_enum) << EnumTy;
     return nullptr;
   }
 
   if (auto *Def = Enum->getDefinition())
     Enum = Def;
 
+  if (TSI == nullptr)
+    TSI = Context.getTrivialTypeSourceInfo(EnumTy, IdentLoc);
+
   auto *UD =
-      BuildUsingEnumDeclaration(S, AS, UsingLoc, EnumLoc, IdentLoc, Enum);
+      BuildUsingEnumDeclaration(S, AS, UsingLoc, EnumLoc, IdentLoc, TSI, Enum);
+
   if (UD)
     PushOnScopeChains(UD, S, /*AddToContext*/ false);
 
   return UD;
 }
 
 /// Determine whether a using declaration considers the given
 /// declarations as "equivalent", e.g., if they are redeclarations of
NamedDecl *Sema::BuildUsingDeclaration(
 
   return UD;
 }
 
 NamedDecl *Sema::BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
                                            SourceLocation UsingLoc,
                                            SourceLocation EnumLoc,
                                            SourceLocation NameLoc,
+                                           TypeSourceInfo *EnumType,
                                            EnumDecl *ED) {
   bool Invalid = false;
 
   if (CurContext->getRedeclContext()->isRecord()) {
     /// In class scope, check if this is a duplicate, for better a diagnostic.
     DeclarationNameInfo UsingEnumName(ED->getDeclName(), NameLoc);
     LookupResult Previous(*this, UsingEnumName, LookupUsingDeclName,
                           ForVisibleRedeclaration);
for (NamedDecl *D : Previous)
           break;
         }
   }
 
   if (RequireCompleteEnumDecl(ED, NameLoc))
     Invalid = true;
 
   UsingEnumDecl *UD = UsingEnumDecl::Create(Context, CurContext, UsingLoc,
-                                            EnumLoc, NameLoc, ED);
+                                            EnumLoc, NameLoc, EnumType, ED);
   UD->setAccess(AS);
   CurContext->addDecl(UD);
 
   if (Invalid) {
     UD->setInvalidDecl();
     return UD;
   }
 

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

 Decl *TemplateDeclInstantiator::VisitUsingEnumDecl(UsingEnumDecl *D) {
   // Cannot be a dependent type, but still could be an instantiation
   EnumDecl *EnumD = cast_or_null<EnumDecl>(SemaRef.FindInstantiatedDecl(
       D->getLocation(), D->getEnumDecl(), TemplateArgs));
 
   if (SemaRef.RequireCompleteEnumDecl(EnumD, EnumD->getLocation()))
     return nullptr;
 
+  TypeSourceInfo *TSI = SemaRef.SubstType(D->getEnumType(), TemplateArgs,
+                                          D->getLocation(), D->getDeclName());
   UsingEnumDecl *NewUD =
       UsingEnumDecl::Create(SemaRef.Context, Owner, D->getUsingLoc(),
-                            D->getEnumLoc(), D->getLocation(), EnumD);
+                            D->getEnumLoc(), D->getLocation(), TSI, EnumD);
 
   SemaRef.Context.setInstantiatedFromUsingEnumDecl(NewUD, D);
   NewUD->setAccess(D->getAccess());
   Owner->addDecl(NewUD);
 
   // Don't process the shadow decls for an invalid decl.
   if (NewUD->isInvalidDecl())
     return NewUD;

clang/lib/Serialization/ASTReaderDecl.cpp

if (auto *Pattern = readDeclAs<NamedDecl>())
     Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
   mergeMergeable(D);
 }
 
 void ASTDeclReader::VisitUsingEnumDecl(UsingEnumDecl *D) {
   VisitNamedDecl(D);
   D->setUsingLoc(readSourceLocation());
   D->setEnumLoc(readSourceLocation());
+  D->setEnumType(Record.readTypeSourceInfo());
   D->Enum = readDeclAs<EnumDecl>();
   D->FirstUsingShadow.setPointer(readDeclAs<UsingShadowDecl>());
   if (auto *Pattern = readDeclAs<UsingEnumDecl>())
     Reader.getContext().setInstantiatedFromUsingEnumDecl(D, Pattern);
   mergeMergeable(D);
 }
 
 void ASTDeclReader::VisitUsingPackDecl(UsingPackDecl *D) {

clang/lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
   Record.AddDeclRef(Context.getInstantiatedFromUsingDecl(D));
   Code = serialization::DECL_USING;
 }
 
 void ASTDeclWriter::VisitUsingEnumDecl(UsingEnumDecl *D) {
   VisitNamedDecl(D);
   Record.AddSourceLocation(D->getUsingLoc());
   Record.AddSourceLocation(D->getEnumLoc());
+  Record.AddTypeSourceInfo(D->getEnumType());
   Record.AddDeclRef(D->getEnumDecl());
   Record.AddDeclRef(D->FirstUsingShadow.getPointer());
   Record.AddDeclRef(Context.getInstantiatedFromUsingEnumDecl(D));
   Code = serialization::DECL_USING_ENUM;
 }
 
 void ASTDeclWriter::VisitUsingPackDecl(UsingPackDecl *D) {
   Record.push_back(D->NumExpansions);

clang/test/AST/ast-dump-using-enum.cpp

 using enum Bob::Foo;
 
 // CHECK-LABEL: Dumping Bob::Foo
 // CHECK-NEXT: EnumDecl {{.*}} class Foo 'int'
 // CHECK-NEXT: |-EnumConstantDecl {{.*}} Foo_a 'Bob::Foo'
 // CHECK-NEXT: `-EnumConstantDecl {{.*}} Foo_b 'Bob::Foo'
 
 // CHECK-LABEL: Dumping Foo:
-// CHECK-NEXT: UsingEnumDecl {{.*}} Enum {{.*}} 'Foo'
+// CHECK-NEXT: UsingEnumDecl {{.*}} <{{.*}}:16:1, col:17> {{.*}} Enum {{.*}} 'Foo'
 
 // CHECK-LABEL: Dumping Foo_a:
 // CHECK-NEXT: UsingShadowDecl {{.*}} implicit EnumConstant {{.*}} 'Foo_a' 'Bob::Foo'
 
 // CHECK-LABEL: Dumping Foo_b:
 // CHECK-NEXT: UsingShadowDecl {{.*}} implicit EnumConstant {{.*}} 'Foo_b' 'Bob::Foo'

clang/unittests/Tooling/RecursiveASTVisitorTestTypeLocVisitor.cpp

TEST(RecursiveASTVisitor, VisitInvalidType) {
   //Visitor.ExpectMatch("typeof(struct F *) []", 1, 1);
   // Even if the full type is invalid, it should still find sub types
   //Visitor.ExpectMatch("struct F", 1, 19);
   EXPECT_FALSE(Visitor.runOver(
       "__typeof__(struct F*) var[invalid];\n",
       TypeLocVisitor::Lang_C));
 }
 
+TEST(RecursiveASTVisitor, VisitsUsingEnumType) {
+  TypeLocVisitor Visitor;
+  Visitor.ExpectMatch("::A", 2, 12);
+  EXPECT_TRUE(Visitor.runOver("enum class A {}; \n"
+                              "using enum ::A;\n",
+                              TypeLocVisitor::Lang_CXX2a));
+}
+
 } // end anonymous namespace