[clang] 95f0f69 - Revert "[AST] Add a new TemplateKind for template decls found via a using decl."
Haojian Wu via cfe-commits
cfe-commits at lists.llvm.org
Tue Apr 12 02:55:16 PDT 2022
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 at -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
More information about the cfe-commits
mailing list