diff --git a/clang-tools-extra/clangd/FindTarget.cpp b/clang-tools-extra/clangd/FindTarget.cpp --- a/clang-tools-extra/clangd/FindTarget.cpp +++ b/clang-tools-extra/clangd/FindTarget.cpp @@ -626,6 +626,12 @@ 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. diff --git a/clang-tools-extra/clangd/unittests/FindTargetTests.cpp b/clang-tools-extra/clangd/unittests/FindTargetTests.cpp --- a/clang-tools-extra/clangd/unittests/FindTargetTests.cpp +++ b/clang-tools-extra/clangd/unittests/FindTargetTests.cpp @@ -1252,6 +1252,15 @@ )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; }; diff --git a/clang-tools-extra/clangd/unittests/SelectionTests.cpp b/clang-tools-extra/clangd/unittests/SelectionTests.cpp --- a/clang-tools-extra/clangd/unittests/SelectionTests.cpp +++ b/clang-tools-extra/clangd/unittests/SelectionTests.cpp @@ -531,6 +531,27 @@ 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) { @@ -541,6 +562,7 @@ 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); diff --git a/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp b/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp --- a/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp +++ b/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp @@ -828,6 +828,14 @@ 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]](); diff --git a/clang/include/clang/AST/DeclCXX.h b/clang/include/clang/AST/DeclCXX.h --- a/clang/include/clang/AST/DeclCXX.h +++ b/clang/include/clang/AST/DeclCXX.h @@ -3614,17 +3614,19 @@ class UsingEnumDecl : public BaseUsingDecl, public Mergeable { /// 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; @@ -3637,15 +3639,32 @@ 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()) + 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); diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h --- a/clang/include/clang/AST/RecursiveASTVisitor.h +++ b/clang/include/clang/AST/RecursiveASTVisitor.h @@ -1724,7 +1724,8 @@ TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo())); }) -DEF_TRAVERSE_DECL(UsingEnumDecl, {}) +DEF_TRAVERSE_DECL(UsingEnumDecl, + { TRY_TO(TraverseTypeLoc(D->getEnumTypeLoc())); }) DEF_TRAVERSE_DECL(UsingPackDecl, {}) diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -6111,7 +6111,8 @@ 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 Expansions); diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp --- a/clang/lib/AST/ASTImporter.cpp +++ b/clang/lib/AST/ASTImporter.cpp @@ -4866,13 +4866,16 @@ 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); diff --git a/clang/lib/AST/DeclCXX.cpp b/clang/lib/AST/DeclCXX.cpp --- a/clang/lib/AST/DeclCXX.cpp +++ b/clang/lib/AST/DeclCXX.cpp @@ -3091,18 +3091,23 @@ 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() {} diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -11854,8 +11854,14 @@ 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) @@ -11864,17 +11870,21 @@ return nullptr; } - auto *Enum = dyn_cast_if_present(TypeRep.get()->getAsTagDecl()); + auto *Enum = dyn_cast_if_present(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); @@ -12566,6 +12576,7 @@ SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation NameLoc, + TypeSourceInfo *EnumType, EnumDecl *ED) { bool Invalid = false; @@ -12592,7 +12603,7 @@ Invalid = true; UsingEnumDecl *UD = UsingEnumDecl::Create(Context, CurContext, UsingLoc, - EnumLoc, NameLoc, ED); + EnumLoc, NameLoc, EnumType, ED); UD->setAccess(AS); CurContext->addDecl(UD); diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -3225,9 +3225,11 @@ 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()); diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp --- a/clang/lib/Serialization/ASTReaderDecl.cpp +++ b/clang/lib/Serialization/ASTReaderDecl.cpp @@ -1772,6 +1772,7 @@ VisitNamedDecl(D); D->setUsingLoc(readSourceLocation()); D->setEnumLoc(readSourceLocation()); + D->setEnumType(Record.readTypeSourceInfo()); D->Enum = readDeclAs(); D->FirstUsingShadow.setPointer(readDeclAs()); if (auto *Pattern = readDeclAs()) diff --git a/clang/lib/Serialization/ASTWriterDecl.cpp b/clang/lib/Serialization/ASTWriterDecl.cpp --- a/clang/lib/Serialization/ASTWriterDecl.cpp +++ b/clang/lib/Serialization/ASTWriterDecl.cpp @@ -1293,6 +1293,7 @@ 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)); diff --git a/clang/test/AST/ast-dump-using-enum.cpp b/clang/test/AST/ast-dump-using-enum.cpp --- a/clang/test/AST/ast-dump-using-enum.cpp +++ b/clang/test/AST/ast-dump-using-enum.cpp @@ -21,7 +21,7 @@ // 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' diff --git a/clang/unittests/Tooling/RecursiveASTVisitorTestTypeLocVisitor.cpp b/clang/unittests/Tooling/RecursiveASTVisitorTestTypeLocVisitor.cpp --- a/clang/unittests/Tooling/RecursiveASTVisitorTestTypeLocVisitor.cpp +++ b/clang/unittests/Tooling/RecursiveASTVisitorTestTypeLocVisitor.cpp @@ -88,4 +88,12 @@ 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