hokein created this revision.
hokein added a reviewer: sammccall.
Herald added subscribers: usaxena95, kadircet, arphaman, martong, mgorny.
Herald added a reviewer: shafik.
Herald added a project: All.
hokein requested review of this revision.
Herald added a subscriber: ilya-biryukov.
Herald added projects: clang, clang-tools-extra.
This is template version of https://reviews.llvm.org/D114251.
This patch introduces a new sugar template name (UsingTemplateName), which
stores
the found using-shadow decl and underlying template name. With the new
template name, we can be able to find the using decl that a template
typeloc (TemplateSpecializationTypeLoc) found its underlying template,
which is useful for tooling use cases (include cleaner etc).
This patch merely focuses on adding the node to the AST.
Next steps:
- add ast matchers for matching different kinds of template names.
- update the clangd and other tools to use this new node.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D123127
Files:
clang-tools-extra/clangd/DumpAST.cpp
clang-tools-extra/clangd/SemanticHighlighting.cpp
clang/include/clang/AST/ASTContext.h
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/lib/Tooling/CMakeLists.txt
clang/test/AST/ast-dump-using-template.cpp
clang/tools/libclang/CIndex.cpp
clang/unittests/AST/ASTImporterTest.cpp
Index: clang/unittests/AST/ASTImporterTest.cpp
===================================================================
--- clang/unittests/AST/ASTImporterTest.cpp
+++ clang/unittests/AST/ASTImporterTest.cpp
@@ -890,6 +890,18 @@
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 }; }"
Index: clang/tools/libclang/CIndex.cpp
===================================================================
--- clang/tools/libclang/CIndex.cpp
+++ clang/tools/libclang/CIndex.cpp
@@ -1472,6 +1472,9 @@
return Visit(MakeCursorTemplateRef(
Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(), Loc,
TU));
+ case TemplateName::UsingTemplate:
+ return VisitTemplateName(Name.getAsUsingTemplateName()->getUnderlying(),
+ Loc);
}
llvm_unreachable("Invalid TemplateName::Kind!");
Index: clang/test/AST/ast-dump-using-template.cpp
===================================================================
--- /dev/null
+++ clang/test/AST/ast-dump-using-template.cpp
@@ -0,0 +1,31 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c++17 -ast-dump %s | FileCheck -strict-whitespace %s
+
+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<S>' sugar X
+// CHECK-NEXT: |-TemplateArgument using template S
+// CHECK-NEXT: `-RecordType {{.*}} 'X<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
Index: clang/lib/Tooling/CMakeLists.txt
===================================================================
--- clang/lib/Tooling/CMakeLists.txt
+++ clang/lib/Tooling/CMakeLists.txt
@@ -59,7 +59,7 @@
COMMAND
$<TARGET_FILE:clang-ast-dump>
# Skip this in debug mode because parsing AST.h is too slow
- --skip-processing=${skip_expensive_processing}
+ --skip-processing=1
-I ${LLVM_BINARY_DIR}/lib/clang/${CLANG_VERSION}/include
-I ${CLANG_SOURCE_DIR}/include
-I ${LLVM_BINARY_DIR}/tools/clang/include
Index: clang/lib/Sema/SemaTemplate.cpp
===================================================================
--- clang/lib/Sema/SemaTemplate.cpp
+++ clang/lib/Sema/SemaTemplate.cpp
@@ -16,6 +16,7 @@
#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"
@@ -303,6 +304,9 @@
isa<ConceptDecl>(TD) ? TNK_Concept_template :
TNK_Type_template;
}
+ if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(*R.begin())) {
+ Template = Context.getUsingTemplateName(Template, USD);
+ }
}
TemplateResult = TemplateTy::make(Template);
Index: clang/lib/Sema/SemaDeclCXX.cpp
===================================================================
--- clang/lib/Sema/SemaDeclCXX.cpp
+++ clang/lib/Sema/SemaDeclCXX.cpp
@@ -11023,7 +11023,9 @@
TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
bool TemplateMatches =
Context.hasSameTemplateName(SpecifiedName, GuidedTemplate);
- if (SpecifiedName.getKind() == TemplateName::Template && TemplateMatches)
+ if ((SpecifiedName.getKind() == TemplateName::Template ||
+ SpecifiedName.getKind() == TemplateName::UsingTemplate) &&
+ TemplateMatches)
AcceptableReturnType = true;
else {
// This could still instantiate to the right type, unless we know it
Index: clang/lib/Sema/SemaDecl.cpp
===================================================================
--- clang/lib/Sema/SemaDecl.cpp
+++ clang/lib/Sema/SemaDecl.cpp
@@ -503,9 +503,11 @@
FoundUsingShadow = nullptr;
} else if (AllowDeducedTemplate) {
if (auto *TD = getAsTypeTemplateDecl(IIDecl)) {
- // FIXME: TemplateName should include FoundUsingShadow sugar.
- T = Context.getDeducedTemplateSpecializationType(TemplateName(TD),
- QualType(), false);
+ TemplateName Template = TemplateName(TD);
+ if (FoundUsingShadow)
+ Template = Context.getUsingTemplateName(Template, FoundUsingShadow);
+ T = Context.getDeducedTemplateSpecializationType(Template, QualType(),
+ false);
// Don't wrap in a further UsingType.
FoundUsingShadow = nullptr;
}
Index: clang/lib/AST/Type.cpp
===================================================================
--- clang/lib/AST/Type.cpp
+++ clang/lib/AST/Type.cpp
@@ -3686,7 +3686,8 @@
"Use DependentTemplateSpecializationType for dependent template-name");
assert((T.getKind() == TemplateName::Template ||
T.getKind() == TemplateName::SubstTemplateTemplateParm ||
- T.getKind() == TemplateName::SubstTemplateTemplateParmPack) &&
+ T.getKind() == TemplateName::SubstTemplateTemplateParmPack ||
+ T.getKind() == TemplateName::UsingTemplate) &&
"Unexpected template name for TemplateSpecializationType");
auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1);
Index: clang/lib/AST/TextNodeDumper.cpp
===================================================================
--- clang/lib/AST/TextNodeDumper.cpp
+++ clang/lib/AST/TextNodeDumper.cpp
@@ -900,12 +900,17 @@
}
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);
}
@@ -1575,10 +1580,18 @@
}
}
+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);
}
Index: clang/lib/AST/TemplateName.cpp
===================================================================
--- clang/lib/AST/TemplateName.cpp
+++ clang/lib/AST/TemplateName.cpp
@@ -76,12 +76,15 @@
: Storage(Storage) {}
TemplateName::TemplateName(QualifiedTemplateName *Qual) : Storage(Qual) {}
TemplateName::TemplateName(DependentTemplateName *Dep) : Storage(Dep) {}
+TemplateName::TemplateName(UsingTemplateName *Using) : Storage(Using) {}
bool TemplateName::isNull() const { return Storage.isNull(); }
TemplateName::NameKind TemplateName::getKind() const {
if (Storage.is<TemplateDecl *>())
return Template;
+ if (Storage.is<UsingTemplateName *>())
+ return UsingTemplate;
if (Storage.is<DependentTemplateName *>())
return DependentTemplate;
if (Storage.is<QualifiedTemplateName *>())
@@ -101,7 +104,8 @@
TemplateDecl *TemplateName::getAsTemplateDecl() const {
if (TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>())
return Template;
-
+ if (auto *UTN = Storage.dyn_cast<UsingTemplateName *>())
+ return UTN->getUnderlying().getAsTemplateDecl();
if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
return QTN->getTemplateDecl();
@@ -127,6 +131,10 @@
return nullptr;
}
+UsingTemplateName *TemplateName::getAsUsingTemplateName() const {
+ return Storage.dyn_cast<UsingTemplateName *>();
+}
+
SubstTemplateTemplateParmStorage *
TemplateName::getAsSubstTemplateTemplateParm() const {
if (UncommonTemplateNameStorage *uncommon =
@@ -261,6 +269,8 @@
OS << *SubstPack->getParameterPack();
else if (AssumedTemplateStorage *Assumed = getAsAssumedTemplateName()) {
Assumed->getDeclName().print(OS, Policy);
+ } else if (auto *U = getAsUsingTemplateName()) {
+ U->getUnderlying().print(OS, Policy);
} else {
OverloadedTemplateStorage *OTS = getAsOverloadedTemplate();
(*OTS->begin())->printName(OS);
Index: clang/lib/AST/ODRHash.cpp
===================================================================
--- clang/lib/AST/ODRHash.cpp
+++ clang/lib/AST/ODRHash.cpp
@@ -150,6 +150,7 @@
case TemplateName::DependentTemplate:
case TemplateName::SubstTemplateTemplateParm:
case TemplateName::SubstTemplateTemplateParmPack:
+ case TemplateName::UsingTemplate:
break;
}
}
Index: clang/lib/AST/ItaniumMangle.cpp
===================================================================
--- clang/lib/AST/ItaniumMangle.cpp
+++ clang/lib/AST/ItaniumMangle.cpp
@@ -2218,6 +2218,10 @@
mangleName(TD);
break;
+ case TemplateName::UsingTemplate:
+ mangleType(TN.getAsUsingTemplateName()->getUnderlying());
+ break;
+
case TemplateName::OverloadedTemplate:
case TemplateName::AssumedTemplate:
llvm_unreachable("can't mangle an overloaded template name as a <type>");
@@ -2348,6 +2352,8 @@
const TemplateSpecializationType *TST =
cast<TemplateSpecializationType>(Ty);
TemplateName TN = TST->getTemplateName();
+ mangleTemplateName:
+
switch (TN.getKind()) {
case TemplateName::Template:
case TemplateName::QualifiedTemplate: {
@@ -2383,6 +2389,10 @@
Out << "_SUBSTPACK_";
break;
}
+ case TemplateName::UsingTemplate: {
+ TN = TN.getAsUsingTemplateName()->getUnderlying();
+ goto mangleTemplateName;
+ }
}
// Note: we don't pass in the template name here. We are mangling the
Index: clang/lib/AST/ASTStructuralEquivalence.cpp
===================================================================
--- clang/lib/AST/ASTStructuralEquivalence.cpp
+++ clang/lib/AST/ASTStructuralEquivalence.cpp
@@ -514,6 +514,12 @@
P2->getParameterPack());
}
+ case TemplateName::UsingTemplate: {
+ return IsStructurallyEquivalent(
+ Context, N1.getAsUsingTemplateName()->getUnderlying(),
+ N2.getAsUsingTemplateName()->getUnderlying());
+ }
+
case TemplateName::Template:
case TemplateName::QualifiedTemplate:
case TemplateName::SubstTemplateTemplateParm:
Index: clang/lib/AST/ASTImporter.cpp
===================================================================
--- clang/lib/AST/ASTImporter.cpp
+++ clang/lib/AST/ASTImporter.cpp
@@ -9190,6 +9190,17 @@
return ToContext.getSubstTemplateTemplateParmPack(
cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr);
}
+ case TemplateName::UsingTemplate: {
+ auto *UTN = From.getAsUsingTemplateName();
+ auto UsingOrError = Import(UTN->getUsingShadowDecl());
+ if (!UsingOrError)
+ return UsingOrError.takeError();
+ auto UnderlyingOrError = Import(UTN->getUnderlying());
+ if (!UnderlyingOrError)
+ return UnderlyingOrError.takeError();
+ return ToContext.getUsingTemplateName(*UnderlyingOrError,
+ cast<UsingShadowDecl>(*UsingOrError));
+ }
}
llvm_unreachable("Invalid template name kind");
Index: clang/lib/AST/ASTContext.cpp
===================================================================
--- clang/lib/AST/ASTContext.cpp
+++ clang/lib/AST/ASTContext.cpp
@@ -6125,6 +6125,11 @@
return DeclarationNameInfo(subst->getParameterPack()->getDeclName(),
NameLoc);
}
+ case TemplateName::UsingTemplate: {
+ return DeclarationNameInfo(
+ Name.getAsUsingTemplateName()->getUsingShadowDecl()->getDeclName(),
+ NameLoc);
+ }
}
llvm_unreachable("bad template name kind!");
@@ -6168,6 +6173,9 @@
= getCanonicalTemplateArgument(subst->getArgumentPack());
return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack);
}
+ case TemplateName::UsingTemplate:
+ return getCanonicalTemplateName(
+ Name.getAsUsingTemplateName()->getUnderlying());
}
llvm_unreachable("bad template name!");
@@ -8989,6 +8997,24 @@
return TemplateName(QTN);
}
+TemplateName ASTContext::getUsingTemplateName(TemplateName Underlying,
+ UsingShadowDecl *USD) const {
+
+ assert(USD);
+ llvm::FoldingSetNodeID ID;
+ UsingTemplateName::Profile(ID, Underlying, USD);
+
+ void *InsertPos = nullptr;
+ UsingTemplateName *T = UsingTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
+ if (T)
+ return TemplateName(T);
+
+ UsingTemplateName *NewType = new (*this, alignof(UsingTemplateName))
+ UsingTemplateName(Underlying, USD);
+ UsingTemplateNames.InsertNode(NewType, InsertPos);
+ return TemplateName(NewType);
+}
+
/// Retrieve the template name that represents a dependent
/// template name such as \c MetaFun::template apply.
TemplateName
Index: clang/include/clang/AST/TextNodeDumper.h
===================================================================
--- clang/include/clang/AST/TextNodeDumper.h
+++ clang/include/clang/AST/TextNodeDumper.h
@@ -317,6 +317,8 @@
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);
Index: clang/include/clang/AST/TemplateName.h
===================================================================
--- clang/include/clang/AST/TemplateName.h
+++ clang/include/clang/AST/TemplateName.h
@@ -26,6 +26,7 @@
class ASTContext;
class DependentTemplateName;
+class UsingTemplateName;
class IdentifierInfo;
class NamedDecl;
class NestedNameSpecifier;
@@ -38,6 +39,7 @@
class SubstTemplateTemplateParmStorage;
class TemplateArgument;
class TemplateDecl;
+class UsingShadowDecl;
class TemplateTemplateParmDecl;
/// Implementation class used to describe either a set of overloaded
@@ -190,7 +192,8 @@
class TemplateName {
using StorageType =
llvm::PointerUnion<TemplateDecl *, UncommonTemplateNameStorage *,
- QualifiedTemplateName *, DependentTemplateName *>;
+ QualifiedTemplateName *, DependentTemplateName *,
+ UsingTemplateName *>;
StorageType Storage;
@@ -224,7 +227,11 @@
/// 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
+ SubstTemplateTemplateParmPack,
+
+ /// A template name that refers to a template through a specific using
+ /// shadow declaration.
+ UsingTemplate,
};
TemplateName() = default;
@@ -235,6 +242,7 @@
explicit TemplateName(SubstTemplateTemplateParmPackStorage *Storage);
explicit TemplateName(QualifiedTemplateName *Qual);
explicit TemplateName(DependentTemplateName *Dep);
+ explicit TemplateName(UsingTemplateName *Using);
/// Determine whether this template name is NULL.
bool isNull() const;
@@ -287,6 +295,9 @@
/// structure, if any.
DependentTemplateName *getAsDependentTemplateName() const;
+ /// Retrieve the underlying using template name, if any.
+ UsingTemplateName *getAsUsingTemplateName() const;
+
TemplateName getUnderlying() const;
/// Get the template name to substitute when this template name is used as a
@@ -376,6 +387,37 @@
return *this;
}
+/// Represents a template name that refers to a template introduced by a using
+/// declaration. For example,
+///
+/// \code
+/// using std::vector;
+///
+/// vector<int> v;
+/// \endcode
+/// The `vector` in \c vector<int> is a UsingTemplateName where its underlying
+/// template name is a normal template name which refers to the vector class
+/// template.
+class UsingTemplateName : public llvm::FoldingSetNode {
+ friend class ASTContext;
+
+ TemplateName UnderlyingTN;
+ UsingShadowDecl *USD = nullptr;
+
+ UsingTemplateName(TemplateName UnderlyingTN, UsingShadowDecl *USD)
+ : UnderlyingTN(UnderlyingTN), USD(USD) {}
+
+public:
+ UsingShadowDecl *getUsingShadowDecl() const { return USD; }
+ TemplateName getUnderlying() const { return UnderlyingTN; }
+ void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, UnderlyingTN, USD); }
+ static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Underlying,
+ UsingShadowDecl *USD) {
+ ID.AddPointer(USD);
+ ID.AddPointer(Underlying.getAsVoidPointer());
+ }
+};
+
/// Represents a template name that was expressed as a
/// qualified name.
///
Index: clang/include/clang/AST/PropertiesBase.td
===================================================================
--- clang/include/clang/AST/PropertiesBase.td
+++ clang/include/clang/AST/PropertiesBase.td
@@ -620,6 +620,19 @@
return TemplateName(declaration);
}]>;
}
+
+let Class = PropertyTypeCase<TemplateName, "UsingTemplate"> in {
+ def : Property<"usingShadowDecl", UsingShadowDeclRef> {
+ let Read = [{ node.getAsUsingTemplateName()->getUsingShadowDecl() }];
+ }
+ def : Property<"underlying", TemplateName> {
+ let Read = [{ node.getAsUsingTemplateName()->getUnderlying() }];
+ }
+ def : Creator<[{
+ return ctx.getUsingTemplateName(underlying, usingShadowDecl);
+ }]>;
+}
+
let Class = PropertyTypeCase<TemplateName, "OverloadedTemplate"> in {
def : Property<"overloads", Array<NamedDeclRef>> {
let Read = [{ node.getAsOverloadedTemplate()->decls() }];
Index: clang/include/clang/AST/ASTContext.h
===================================================================
--- clang/include/clang/AST/ASTContext.h
+++ clang/include/clang/AST/ASTContext.h
@@ -268,6 +268,7 @@
mutable llvm::FoldingSet<QualifiedTemplateName> QualifiedTemplateNames;
mutable llvm::FoldingSet<DependentTemplateName> DependentTemplateNames;
+ mutable llvm::FoldingSet<UsingTemplateName> UsingTemplateNames;
mutable llvm::FoldingSet<SubstTemplateTemplateParmStorage>
SubstTemplateTemplateParms;
mutable llvm::ContextualFoldingSet<SubstTemplateTemplateParmPackStorage,
@@ -2180,6 +2181,9 @@
bool TemplateKeyword,
TemplateDecl *Template) const;
+ TemplateName getUsingTemplateName(TemplateName Underlying,
+ UsingShadowDecl *USD) const;
+
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
const IdentifierInfo *Name) const;
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
Index: clang-tools-extra/clangd/SemanticHighlighting.cpp
===================================================================
--- clang-tools-extra/clangd/SemanticHighlighting.cpp
+++ clang-tools-extra/clangd/SemanticHighlighting.cpp
@@ -762,6 +762,7 @@
case TemplateName::QualifiedTemplate:
case TemplateName::SubstTemplateTemplateParm:
case TemplateName::SubstTemplateTemplateParmPack:
+ case TemplateName::UsingTemplate:
// Names that could be resolved to a TemplateDecl are handled elsewhere.
break;
}
Index: clang-tools-extra/clangd/DumpAST.cpp
===================================================================
--- clang-tools-extra/clangd/DumpAST.cpp
+++ clang-tools-extra/clangd/DumpAST.cpp
@@ -184,6 +184,7 @@
TEMPLATE_KIND(DependentTemplate);
TEMPLATE_KIND(SubstTemplateTemplateParm);
TEMPLATE_KIND(SubstTemplateTemplateParmPack);
+ TEMPLATE_KIND(UsingTemplate);
#undef TEMPLATE_KIND
}
llvm_unreachable("Unhandled NameKind enum");
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
