Author: Haojian Wu Date: 2022-04-12T11:51:00+02:00 New Revision: 95f0f69f1ff8eff34a00a47a236c2f91a2392c70
URL: https://github.com/llvm/llvm-project/commit/95f0f69f1ff8eff34a00a47a236c2f91a2392c70 DIFF: https://github.com/llvm/llvm-project/commit/95f0f69f1ff8eff34a00a47a236c2f91a2392c70.diff LOG: Revert "[AST] Add a new TemplateKind for template decls found via a using decl." It breaks arm build, there is no free bit for the extra UsingShadowDecl in TemplateName::StorageType. Reverting it to build the buildbot back until we comeup with a fix. This reverts commit 5a5be4044f0bceb71bb6a81f6955704691b389ed. Added: Modified: clang-tools-extra/clangd/DumpAST.cpp clang-tools-extra/clangd/SemanticHighlighting.cpp clang/include/clang/AST/PropertiesBase.td clang/include/clang/AST/TemplateName.h clang/include/clang/AST/TextNodeDumper.h clang/lib/AST/ASTContext.cpp clang/lib/AST/ASTImporter.cpp clang/lib/AST/ASTStructuralEquivalence.cpp clang/lib/AST/ItaniumMangle.cpp clang/lib/AST/ODRHash.cpp clang/lib/AST/TemplateName.cpp clang/lib/AST/TextNodeDumper.cpp clang/lib/AST/Type.cpp clang/lib/Sema/SemaDecl.cpp clang/lib/Sema/SemaDeclCXX.cpp clang/lib/Sema/SemaTemplate.cpp clang/test/CXX/temp/temp.deduct.guide/p3.cpp clang/tools/libclang/CIndex.cpp clang/unittests/AST/ASTImporterTest.cpp clang/unittests/AST/CMakeLists.txt Removed: clang/test/AST/ast-dump-using-template.cpp clang/unittests/AST/TemplateNameTest.cpp ################################################################################ diff --git a/clang-tools-extra/clangd/DumpAST.cpp b/clang-tools-extra/clangd/DumpAST.cpp index 8f640ad821f8c..4c36de88aea1f 100644 --- a/clang-tools-extra/clangd/DumpAST.cpp +++ b/clang-tools-extra/clangd/DumpAST.cpp @@ -184,7 +184,6 @@ class DumpVisitor : public RecursiveASTVisitor<DumpVisitor> { TEMPLATE_KIND(DependentTemplate); TEMPLATE_KIND(SubstTemplateTemplateParm); TEMPLATE_KIND(SubstTemplateTemplateParmPack); - TEMPLATE_KIND(UsingTemplate); #undef TEMPLATE_KIND } llvm_unreachable("Unhandled NameKind enum"); diff --git a/clang-tools-extra/clangd/SemanticHighlighting.cpp b/clang-tools-extra/clangd/SemanticHighlighting.cpp index 2bc5928fe1b84..862cfc8edf0aa 100644 --- a/clang-tools-extra/clangd/SemanticHighlighting.cpp +++ b/clang-tools-extra/clangd/SemanticHighlighting.cpp @@ -762,7 +762,6 @@ class CollectExtraHighlightings case TemplateName::QualifiedTemplate: case TemplateName::SubstTemplateTemplateParm: case TemplateName::SubstTemplateTemplateParmPack: - case TemplateName::UsingTemplate: // Names that could be resolved to a TemplateDecl are handled elsewhere. break; } diff --git a/clang/include/clang/AST/PropertiesBase.td b/clang/include/clang/AST/PropertiesBase.td index 0ab18b6d59c3d..3da7fd9030aac 100644 --- a/clang/include/clang/AST/PropertiesBase.td +++ b/clang/include/clang/AST/PropertiesBase.td @@ -620,16 +620,6 @@ let Class = PropertyTypeCase<TemplateName, "Template"> in { return TemplateName(declaration); }]>; } - -let Class = PropertyTypeCase<TemplateName, "UsingTemplate"> in { - def : Property<"foundDecl", UsingShadowDeclRef> { - let Read = [{ node.getAsUsingShadowDecl() }]; - } - def : Creator<[{ - return TemplateName(foundDecl); - }]>; -} - let Class = PropertyTypeCase<TemplateName, "OverloadedTemplate"> in { def : Property<"overloads", Array<NamedDeclRef>> { let Read = [{ node.getAsOverloadedTemplate()->decls() }]; diff --git a/clang/include/clang/AST/TemplateName.h b/clang/include/clang/AST/TemplateName.h index 8b706082f1ee9..26c64d0e277ff 100644 --- a/clang/include/clang/AST/TemplateName.h +++ b/clang/include/clang/AST/TemplateName.h @@ -39,7 +39,6 @@ class SubstTemplateTemplateParmStorage; class TemplateArgument; class TemplateDecl; class TemplateTemplateParmDecl; -class UsingShadowDecl; /// Implementation class used to describe either a set of overloaded /// template names or an already-substituted template template parameter pack. @@ -191,8 +190,7 @@ class SubstTemplateTemplateParmPackStorage class TemplateName { using StorageType = llvm::PointerUnion<TemplateDecl *, UncommonTemplateNameStorage *, - QualifiedTemplateName *, DependentTemplateName *, - UsingShadowDecl *>; + QualifiedTemplateName *, DependentTemplateName *>; StorageType Storage; @@ -226,11 +224,7 @@ class TemplateName { /// A template template parameter pack that has been substituted for /// a template template argument pack, but has not yet been expanded into /// individual arguments. - SubstTemplateTemplateParmPack, - - /// A template name that refers to a template declaration found through a - /// specific using shadow declaration. - UsingTemplate, + SubstTemplateTemplateParmPack }; TemplateName() = default; @@ -241,7 +235,6 @@ class TemplateName { explicit TemplateName(SubstTemplateTemplateParmPackStorage *Storage); explicit TemplateName(QualifiedTemplateName *Qual); explicit TemplateName(DependentTemplateName *Dep); - explicit TemplateName(UsingShadowDecl *Using); /// Determine whether this template name is NULL. bool isNull() const; @@ -294,13 +287,6 @@ class TemplateName { /// structure, if any. DependentTemplateName *getAsDependentTemplateName() const; - /// Retrieve the using shadow declaration through which the underlying - /// template declaration is introduced. - /// - /// The underlying template declaration is not stored in the template name, it - /// can be retrieved via the using shadow declaration. - UsingShadowDecl *getAsUsingShadowDecl() const; - TemplateName getUnderlying() const; /// Get the template name to substitute when this template name is used as a diff --git a/clang/include/clang/AST/TextNodeDumper.h b/clang/include/clang/AST/TextNodeDumper.h index 0ecb8a23dfb36..41bbf2ec593aa 100644 --- a/clang/include/clang/AST/TextNodeDumper.h +++ b/clang/include/clang/AST/TextNodeDumper.h @@ -317,8 +317,6 @@ class TextNodeDumper void VisitTagType(const TagType *T); void VisitTemplateTypeParmType(const TemplateTypeParmType *T); void VisitAutoType(const AutoType *T); - void VisitDeducedTemplateSpecializationType( - const DeducedTemplateSpecializationType *T); void VisitTemplateSpecializationType(const TemplateSpecializationType *T); void VisitInjectedClassNameType(const InjectedClassNameType *T); void VisitObjCInterfaceType(const ObjCInterfaceType *T); diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index f6bb7574bf71f..036f970897180 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -6125,9 +6125,6 @@ ASTContext::getNameForTemplate(TemplateName Name, return DeclarationNameInfo(subst->getParameterPack()->getDeclName(), NameLoc); } - case TemplateName::UsingTemplate: - return DeclarationNameInfo(Name.getAsUsingShadowDecl()->getDeclName(), - NameLoc); } llvm_unreachable("bad template name kind!"); @@ -6136,7 +6133,6 @@ ASTContext::getNameForTemplate(TemplateName Name, TemplateName ASTContext::getCanonicalTemplateName(const TemplateName &Name) const { switch (Name.getKind()) { - case TemplateName::UsingTemplate: case TemplateName::QualifiedTemplate: case TemplateName::Template: { TemplateDecl *Template = Name.getAsTemplateDecl(); diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp index 22c0dbe7093e1..b368dbf1d5ce9 100644 --- a/clang/lib/AST/ASTImporter.cpp +++ b/clang/lib/AST/ASTImporter.cpp @@ -9193,12 +9193,6 @@ Expected<TemplateName> ASTImporter::Import(TemplateName From) { return ToContext.getSubstTemplateTemplateParmPack( cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr); } - case TemplateName::UsingTemplate: { - auto UsingOrError = Import(From.getAsUsingShadowDecl()); - if (!UsingOrError) - return UsingOrError.takeError(); - return TemplateName(cast<UsingShadowDecl>(*UsingOrError)); - } } llvm_unreachable("Invalid template name kind"); diff --git a/clang/lib/AST/ASTStructuralEquivalence.cpp b/clang/lib/AST/ASTStructuralEquivalence.cpp index 05f3470a179d2..d4d20dde75e33 100644 --- a/clang/lib/AST/ASTStructuralEquivalence.cpp +++ b/clang/lib/AST/ASTStructuralEquivalence.cpp @@ -517,7 +517,6 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, case TemplateName::Template: case TemplateName::QualifiedTemplate: case TemplateName::SubstTemplateTemplateParm: - case TemplateName::UsingTemplate: // It is sufficient to check value of getAsTemplateDecl. break; diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp index adab764487c7b..50e110ec1f57e 100644 --- a/clang/lib/AST/ItaniumMangle.cpp +++ b/clang/lib/AST/ItaniumMangle.cpp @@ -2207,7 +2207,6 @@ void CXXNameMangler::mangleType(TemplateName TN) { TD = TN.getAsQualifiedTemplateName()->getTemplateDecl(); goto HaveDecl; - case TemplateName::UsingTemplate: case TemplateName::Template: TD = TN.getAsTemplateDecl(); goto HaveDecl; @@ -2384,12 +2383,6 @@ bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(QualType Ty, Out << "_SUBSTPACK_"; break; } - case TemplateName::UsingTemplate: { - TemplateDecl *TD = TN.getAsTemplateDecl(); - assert(TD && !isa<TemplateTemplateParmDecl>(TD)); - mangleSourceNameWithAbiTags(TD); - break; - } } // Note: we don't pass in the template name here. We are mangling the diff --git a/clang/lib/AST/ODRHash.cpp b/clang/lib/AST/ODRHash.cpp index 04cbb09356d7b..735bcff8f1137 100644 --- a/clang/lib/AST/ODRHash.cpp +++ b/clang/lib/AST/ODRHash.cpp @@ -150,7 +150,6 @@ void ODRHash::AddTemplateName(TemplateName Name) { case TemplateName::DependentTemplate: case TemplateName::SubstTemplateTemplateParm: case TemplateName::SubstTemplateTemplateParmPack: - case TemplateName::UsingTemplate: break; } } diff --git a/clang/lib/AST/TemplateName.cpp b/clang/lib/AST/TemplateName.cpp index b887db8a80d9c..a6d8a7fe7b3dd 100644 --- a/clang/lib/AST/TemplateName.cpp +++ b/clang/lib/AST/TemplateName.cpp @@ -13,7 +13,6 @@ #include "clang/AST/TemplateName.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclBase.h" -#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/DependenceFlags.h" #include "clang/AST/NestedNameSpecifier.h" @@ -77,7 +76,6 @@ TemplateName::TemplateName(SubstTemplateTemplateParmPackStorage *Storage) : Storage(Storage) {} TemplateName::TemplateName(QualifiedTemplateName *Qual) : Storage(Qual) {} TemplateName::TemplateName(DependentTemplateName *Dep) : Storage(Dep) {} -TemplateName::TemplateName(UsingShadowDecl *Using) : Storage(Using) {} bool TemplateName::isNull() const { return Storage.isNull(); } @@ -88,8 +86,6 @@ TemplateName::NameKind TemplateName::getKind() const { return DependentTemplate; if (Storage.is<QualifiedTemplateName *>()) return QualifiedTemplate; - if (Storage.is<UsingShadowDecl *>()) - return UsingTemplate; UncommonTemplateNameStorage *uncommon = Storage.get<UncommonTemplateNameStorage*>(); @@ -112,9 +108,6 @@ TemplateDecl *TemplateName::getAsTemplateDecl() const { if (SubstTemplateTemplateParmStorage *sub = getAsSubstTemplateTemplateParm()) return sub->getReplacement().getAsTemplateDecl(); - if (UsingShadowDecl *USD = getAsUsingShadowDecl()) - return cast<TemplateDecl>(USD->getTargetDecl()); - return nullptr; } @@ -160,10 +153,6 @@ DependentTemplateName *TemplateName::getAsDependentTemplateName() const { return Storage.dyn_cast<DependentTemplateName *>(); } -UsingShadowDecl *TemplateName::getAsUsingShadowDecl() const { - return Storage.dyn_cast<UsingShadowDecl *>(); -} - TemplateName TemplateName::getNameToSubstitute() const { TemplateDecl *Decl = getAsTemplateDecl(); @@ -233,20 +222,7 @@ bool TemplateName::containsUnexpandedParameterPack() const { void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy, Qualified Qual) const { - TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>(); - if (getKind() == TemplateName::UsingTemplate) { - // After `namespace ns { using std::vector }`, what is the fully-qualified - // name of the UsingTemplateName `vector` within ns? - // - // - ns::vector (the qualified name of the using-shadow decl) - // - std::vector (the qualifier name of the underlying template decl) - // - // Similar to the UsingType behavior, std::vector is much more common, and - // provides more information in practice, we print the underlying template - // decl of the using-shadow decl. - Template = getAsTemplateDecl(); - } - if (Template) + if (TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>()) if (Policy.CleanUglifiedParameters && isa<TemplateTemplateParmDecl>(Template) && Template->getIdentifier()) OS << Template->getIdentifier()->deuglifiedName(); @@ -286,7 +262,6 @@ void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy, else if (AssumedTemplateStorage *Assumed = getAsAssumedTemplateName()) { Assumed->getDeclName().print(OS, Policy); } else { - assert(getKind() == TemplateName::OverloadedTemplate); OverloadedTemplateStorage *OTS = getAsOverloadedTemplate(); (*OTS->begin())->printName(OS); } diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp index 9131dfbdca778..ba8b7b692d588 100644 --- a/clang/lib/AST/TextNodeDumper.cpp +++ b/clang/lib/AST/TextNodeDumper.cpp @@ -900,17 +900,12 @@ void TextNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) { } void TextNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) { - if (TA.getAsTemplate().getKind() == TemplateName::UsingTemplate) - OS << " using"; OS << " template "; TA.getAsTemplate().dump(OS); } void TextNodeDumper::VisitTemplateExpansionTemplateArgument( const TemplateArgument &TA) { - if (TA.getAsTemplateOrTemplatePattern().getKind() == - TemplateName::UsingTemplate) - OS << " using"; OS << " template expansion "; TA.getAsTemplateOrTemplatePattern().dump(OS); } @@ -1580,18 +1575,10 @@ void TextNodeDumper::VisitAutoType(const AutoType *T) { } } -void TextNodeDumper::VisitDeducedTemplateSpecializationType( - const DeducedTemplateSpecializationType *T) { - if (T->getTemplateName().getKind() == TemplateName::UsingTemplate) - OS << " using"; -} - void TextNodeDumper::VisitTemplateSpecializationType( const TemplateSpecializationType *T) { if (T->isTypeAlias()) OS << " alias"; - if (T->getTemplateName().getKind() == TemplateName::UsingTemplate) - OS << " using"; OS << " "; T->getTemplateName().dump(OS); } diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp index bb9900ea6eea4..936550ddc54ce 100644 --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -3686,8 +3686,7 @@ TemplateSpecializationType::TemplateSpecializationType( "Use DependentTemplateSpecializationType for dependent template-name"); assert((T.getKind() == TemplateName::Template || T.getKind() == TemplateName::SubstTemplateTemplateParm || - T.getKind() == TemplateName::SubstTemplateTemplateParmPack || - T.getKind() == TemplateName::UsingTemplate) && + T.getKind() == TemplateName::SubstTemplateTemplateParmPack) && "Unexpected template name for TemplateSpecializationType"); auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1); diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 6a6f69126d56e..cd9e6d56a5aee 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -504,11 +504,9 @@ ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, FoundUsingShadow = nullptr; } else if (AllowDeducedTemplate) { if (auto *TD = getAsTypeTemplateDecl(IIDecl)) { - assert(!FoundUsingShadow || FoundUsingShadow->getTargetDecl() == TD); - TemplateName Template = - FoundUsingShadow ? TemplateName(FoundUsingShadow) : TemplateName(TD); - T = Context.getDeducedTemplateSpecializationType(Template, QualType(), - false); + // FIXME: TemplateName should include FoundUsingShadow sugar. + T = Context.getDeducedTemplateSpecializationType(TemplateName(TD), + QualType(), false); // Don't wrap in a further UsingType. FoundUsingShadow = nullptr; } @@ -1109,20 +1107,12 @@ Sema::NameClassification Sema::ClassifyName(Scope *S, CXXScopeSpec &SS, IsFunctionTemplate = isa<FunctionTemplateDecl>(TD); IsVarTemplate = isa<VarTemplateDecl>(TD); - UsingShadowDecl *FoundUsingShadow = - dyn_cast<UsingShadowDecl>(*Result.begin()); - - if (SS.isNotEmpty()) { - // FIXME: support using shadow-declaration in qualified template name. + if (SS.isNotEmpty()) Template = Context.getQualifiedTemplateName(SS.getScopeRep(), /*TemplateKeyword=*/false, TD); - } else { - assert(!FoundUsingShadow || - TD == cast<TemplateDecl>(FoundUsingShadow->getTargetDecl())); - Template = FoundUsingShadow ? TemplateName(FoundUsingShadow) - : TemplateName(TD); - } + else + Template = TemplateName(TD); } else { // All results were non-template functions. This is a function template // name. diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index 10546de0eec9a..4d3a4ba019adf 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -11023,8 +11023,6 @@ void Sema::CheckDeductionGuideDeclarator(Declarator &D, QualType &R, TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName(); bool TemplateMatches = Context.hasSameTemplateName(SpecifiedName, GuidedTemplate); - // FIXME: We should consider other template kinds (using, qualified), - // otherwise we will emit bogus diagnostics. if (SpecifiedName.getKind() == TemplateName::Template && TemplateMatches) AcceptableReturnType = true; else { diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index e7195edc9a268..bf65f115116f1 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -11,13 +11,11 @@ #include "TreeTransform.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" -#include "clang/AST/Decl.h" #include "clang/AST/DeclFriend.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/RecursiveASTVisitor.h" -#include "clang/AST/TemplateName.h" #include "clang/AST/TypeVisitor.h" #include "clang/Basic/Builtins.h" #include "clang/Basic/LangOptions.h" @@ -225,7 +223,6 @@ TemplateNameKind Sema::isTemplateName(Scope *S, return TNK_Non_template; NamedDecl *D = nullptr; - UsingShadowDecl *FoundUsingShadow = dyn_cast<UsingShadowDecl>(*R.begin()); if (R.isAmbiguous()) { // If we got an ambiguity involving a non-function template, treat this // as a template name, and pick an arbitrary template for error recovery. @@ -236,7 +233,6 @@ TemplateNameKind Sema::isTemplateName(Scope *S, AnyFunctionTemplates = true; else { D = FoundTemplate; - FoundUsingShadow = dyn_cast<UsingShadowDecl>(FoundD); break; } } @@ -287,14 +283,10 @@ TemplateNameKind Sema::isTemplateName(Scope *S, if (SS.isSet() && !SS.isInvalid()) { NestedNameSpecifier *Qualifier = SS.getScopeRep(); - // FIXME: store the using TemplateName in QualifiedTemplateName if - // the TD is referred via a using-declaration. - Template = - Context.getQualifiedTemplateName(Qualifier, hasTemplateKeyword, TD); + Template = Context.getQualifiedTemplateName(Qualifier, + hasTemplateKeyword, TD); } else { - Template = - FoundUsingShadow ? TemplateName(FoundUsingShadow) : TemplateName(TD); - assert(!FoundUsingShadow || FoundUsingShadow->getTargetDecl() == TD); + Template = TemplateName(TD); } if (isa<FunctionTemplateDecl>(TD)) { diff --git a/clang/test/AST/ast-dump-using-template.cpp b/clang/test/AST/ast-dump-using-template.cpp deleted file mode 100644 index fbce09d116ed0..0000000000000 --- a/clang/test/AST/ast-dump-using-template.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c++17 -ast-dump %s | FileCheck -strict-whitespace %s - -// Tests to verify we construct correct using template names. -// TemplateNames are not dumped, so the sugar here isn't obvious. However -// the "using" on the TemplateSpecializationTypes shows that the -// UsingTemplateName is present. -namespace ns { -template<typename T> class S { - public: - S(T); -}; -} -using ns::S; - -// TemplateName in TemplateSpecializationType. -template<typename T> -using A = S<T>; -// CHECK: TypeAliasDecl -// CHECK-NEXT: `-TemplateSpecializationType {{.*}} 'S<T>' dependent using S - -// TemplateName in TemplateArgument. -template <template <typename> class T> class X {}; -using B = X<S>; -// CHECK: TypeAliasDecl -// CHECK-NEXT: `-TemplateSpecializationType {{.*}} 'X<ns::S>' sugar X -// CHECK-NEXT: |-TemplateArgument using template S -// CHECK-NEXT: `-RecordType {{.*}} 'X<ns::S>' -// CHECK-NEXT: `-ClassTemplateSpecialization {{.*}} 'X' - -// TemplateName in DeducedTemplateSpecializationType. -S DeducedTemplateSpecializationT(123); -using C = decltype(DeducedTemplateSpecializationT); -// CHECK: DecltypeType {{.*}} -// CHECK-NEXT: |-DeclRefExpr {{.*}} -// CHECK-NEXT: `-DeducedTemplateSpecializationType {{.*}} 'ns::S<int>' sugar using diff --git a/clang/test/CXX/temp/temp.deduct.guide/p3.cpp b/clang/test/CXX/temp/temp.deduct.guide/p3.cpp index 4ba6e8ef03732..ec39c0c5ac995 100644 --- a/clang/test/CXX/temp/temp.deduct.guide/p3.cpp +++ b/clang/test/CXX/temp/temp.deduct.guide/p3.cpp @@ -55,9 +55,6 @@ namespace WrongScope { } using N::NamedNS1; NamedNS1(int) -> NamedNS1<int>; // expected-error {{deduction guide must be declared in the same scope as template}} - // FIXME: remove the following bogus diagnostic - // expected-error@-2{{deduction guide is not written as a specialization of template 'NamedNS1'}} - using namespace N; NamedNS2(int) -> NamedNS2<int>; // expected-error {{deduction guide must be declared in the same scope as template}} struct ClassMemberA { diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp index 9d9332987aec3..0c7406a9002b9 100644 --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -1442,7 +1442,6 @@ bool CursorVisitor::VisitTemplateParameters( bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) { switch (Name.getKind()) { case TemplateName::Template: - case TemplateName::UsingTemplate: return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU)); case TemplateName::OverloadedTemplate: diff --git a/clang/unittests/AST/ASTImporterTest.cpp b/clang/unittests/AST/ASTImporterTest.cpp index f9e6ac0159700..7988603c4d734 100644 --- a/clang/unittests/AST/ASTImporterTest.cpp +++ b/clang/unittests/AST/ASTImporterTest.cpp @@ -890,18 +890,6 @@ TEST_P(ImportDecl, ImportUsingDecl) { functionDecl(hasDescendant(usingDecl(hasName("bar"))))); } -TEST_P(ImportDecl, ImportUsingTemplate) { - MatchVerifier<Decl> Verifier; - testImport("namespace ns { template <typename T> struct S {}; }" - "template <template <typename> class T> class X {};" - "void declToImport() {" - "using ns::S; X<S> xi; }", - Lang_CXX11, "", Lang_CXX11, Verifier, - functionDecl( - hasDescendant(varDecl(hasTypeLoc(templateSpecializationTypeLoc( - hasAnyTemplateArgumentLoc(templateArgumentLoc()))))))); -} - TEST_P(ImportDecl, ImportUsingEnumDecl) { MatchVerifier<Decl> Verifier; testImport("namespace foo { enum bar { baz, toto, quux }; }" diff --git a/clang/unittests/AST/CMakeLists.txt b/clang/unittests/AST/CMakeLists.txt index 48a610c98138a..2dcef2d2fca0e 100644 --- a/clang/unittests/AST/CMakeLists.txt +++ b/clang/unittests/AST/CMakeLists.txt @@ -31,7 +31,6 @@ add_clang_unittest(ASTTests SourceLocationTest.cpp StmtPrinterTest.cpp StructuralEquivalenceTest.cpp - TemplateNameTest.cpp TypePrinterTest.cpp ) diff --git a/clang/unittests/AST/TemplateNameTest.cpp b/clang/unittests/AST/TemplateNameTest.cpp deleted file mode 100644 index fa12752e9d467..0000000000000 --- a/clang/unittests/AST/TemplateNameTest.cpp +++ /dev/null @@ -1,68 +0,0 @@ -//===- unittests/AST/TemplateNameTest.cpp --- Tests for TemplateName ------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#include "ASTPrint.h" -#include "clang/AST/ASTContext.h" -#include "clang/ASTMatchers/ASTMatchers.h" -#include "llvm/Support/raw_ostream.h" -#include "gtest/gtest.h" - -namespace clang { -namespace { -using namespace ast_matchers; - -std::string printTemplateName(TemplateName TN, const PrintingPolicy &Policy, - TemplateName::Qualified Qual) { - std::string Result; - llvm::raw_string_ostream Out(Result); - TN.print(Out, Policy, Qual); - return Out.str(); -} - -TEST(TemplateName, PrintUsingTemplate) { - std::string Code = R"cpp( - namespace std { - template <typename> struct vector {}; - } - namespace absl { using std::vector; } - - template<template <typename> class T> class X; - - using absl::vector; - using A = X<vector>; - )cpp"; - auto AST = tooling::buildASTFromCode(Code); - ASTContext &Ctx = AST->getASTContext(); - // Match X in X<vector>. - auto Matcher = templateArgumentLoc().bind("id"); - - // !TemplateArgumentLoc is a local storage of the MatchCallback! - internal::CollectMatchesCallback StorageCB; - MatchFinder Finder; - Finder.addMatcher(Matcher, &StorageCB); - Finder.matchAST(Ctx); - const auto *Template = - selectFirst<TemplateArgumentLoc>("id", StorageCB.Nodes); - assert(Template); - TemplateName TN = Template->getArgument().getAsTemplate(); - EXPECT_EQ(TN.getKind(), TemplateName::UsingTemplate); - EXPECT_EQ(TN.getAsUsingShadowDecl()->getTargetDecl(), TN.getAsTemplateDecl()); - - EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(), - TemplateName::Qualified::Fully), - "std::vector"); - EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(), - TemplateName::Qualified::AsWritten), - "vector"); - EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(), - TemplateName::Qualified::None), - "vector"); -} - -} // namespace -} // namespace clang _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
