1 //===--- TemplateName.cpp - C++ Template Name Representation---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the TemplateName interface and subclasses.
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/TemplateName.h"
15 #include "clang/AST/DeclTemplate.h"
16 #include "clang/AST/NestedNameSpecifier.h"
17 #include "clang/AST/PrettyPrinter.h"
18 #include "clang/AST/TemplateBase.h"
19 #include "clang/Basic/Diagnostic.h"
20 #include "clang/Basic/LangOptions.h"
21 #include "llvm/Support/raw_ostream.h"
22 using namespace clang;
26 SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
27 return TemplateArgument(llvm::makeArrayRef(Arguments, size()));
30 void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) {
31 Profile(ID, Parameter, Replacement);
34 void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID,
35 TemplateTemplateParmDecl *parameter,
36 TemplateName replacement) {
37 ID.AddPointer(parameter);
38 ID.AddPointer(replacement.getAsVoidPointer());
41 void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
42 ASTContext &Context) {
43 Profile(ID, Context, Parameter, getArgumentPack());
46 void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
48 TemplateTemplateParmDecl *Parameter,
49 const TemplateArgument &ArgPack) {
50 ID.AddPointer(Parameter);
51 ArgPack.Profile(ID, Context);
54 TemplateName::TemplateName(void *Ptr) {
55 Storage = StorageType::getFromOpaqueValue(Ptr);
58 TemplateName::TemplateName(TemplateDecl *Template) : Storage(Template) {}
59 TemplateName::TemplateName(OverloadedTemplateStorage *Storage)
61 TemplateName::TemplateName(SubstTemplateTemplateParmStorage *Storage)
63 TemplateName::TemplateName(SubstTemplateTemplateParmPackStorage *Storage)
65 TemplateName::TemplateName(QualifiedTemplateName *Qual) : Storage(Qual) {}
66 TemplateName::TemplateName(DependentTemplateName *Dep) : Storage(Dep) {}
68 bool TemplateName::isNull() const { return Storage.isNull(); }
70 TemplateName::NameKind TemplateName::getKind() const {
71 if (Storage.is<TemplateDecl *>())
73 if (Storage.is<DependentTemplateName *>())
74 return DependentTemplate;
75 if (Storage.is<QualifiedTemplateName *>())
76 return QualifiedTemplate;
78 UncommonTemplateNameStorage *uncommon
79 = Storage.get<UncommonTemplateNameStorage*>();
80 if (uncommon->getAsOverloadedStorage())
81 return OverloadedTemplate;
82 if (uncommon->getAsSubstTemplateTemplateParm())
83 return SubstTemplateTemplateParm;
84 return SubstTemplateTemplateParmPack;
87 TemplateDecl *TemplateName::getAsTemplateDecl() const {
88 if (TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>())
91 if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
92 return QTN->getTemplateDecl();
94 if (SubstTemplateTemplateParmStorage *sub = getAsSubstTemplateTemplateParm())
95 return sub->getReplacement().getAsTemplateDecl();
100 OverloadedTemplateStorage *TemplateName::getAsOverloadedTemplate() const {
101 if (UncommonTemplateNameStorage *Uncommon =
102 Storage.dyn_cast<UncommonTemplateNameStorage *>())
103 return Uncommon->getAsOverloadedStorage();
108 SubstTemplateTemplateParmStorage *
109 TemplateName::getAsSubstTemplateTemplateParm() const {
110 if (UncommonTemplateNameStorage *uncommon =
111 Storage.dyn_cast<UncommonTemplateNameStorage *>())
112 return uncommon->getAsSubstTemplateTemplateParm();
117 SubstTemplateTemplateParmPackStorage *
118 TemplateName::getAsSubstTemplateTemplateParmPack() const {
119 if (UncommonTemplateNameStorage *Uncommon =
120 Storage.dyn_cast<UncommonTemplateNameStorage *>())
121 return Uncommon->getAsSubstTemplateTemplateParmPack();
126 QualifiedTemplateName *TemplateName::getAsQualifiedTemplateName() const {
127 return Storage.dyn_cast<QualifiedTemplateName *>();
130 DependentTemplateName *TemplateName::getAsDependentTemplateName() const {
131 return Storage.dyn_cast<DependentTemplateName *>();
134 bool TemplateName::isDependent() const {
135 if (TemplateDecl *Template = getAsTemplateDecl()) {
136 if (isa<TemplateTemplateParmDecl>(Template))
138 // FIXME: Hack, getDeclContext() can be null if Template is still
139 // initializing due to PCH reading, so we check it before using it.
140 // Should probably modify TemplateSpecializationType to allow constructing
141 // it without the isDependent() checking.
142 return Template->getDeclContext() &&
143 Template->getDeclContext()->isDependentContext();
146 assert(!getAsOverloadedTemplate() &&
147 "overloaded templates shouldn't survive to here");
152 bool TemplateName::isInstantiationDependent() const {
153 if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName()) {
154 if (QTN->getQualifier()->isInstantiationDependent())
158 return isDependent();
161 bool TemplateName::containsUnexpandedParameterPack() const {
162 if (TemplateDecl *Template = getAsTemplateDecl()) {
163 if (TemplateTemplateParmDecl *TTP
164 = dyn_cast<TemplateTemplateParmDecl>(Template))
165 return TTP->isParameterPack();
170 if (DependentTemplateName *DTN = getAsDependentTemplateName())
171 return DTN->getQualifier() &&
172 DTN->getQualifier()->containsUnexpandedParameterPack();
174 return getAsSubstTemplateTemplateParmPack() != nullptr;
178 TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
179 bool SuppressNNS) const {
180 if (TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>())
182 else if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName()) {
184 QTN->getQualifier()->print(OS, Policy);
185 if (QTN->hasTemplateKeyword())
187 OS << *QTN->getDecl();
188 } else if (DependentTemplateName *DTN = getAsDependentTemplateName()) {
189 if (!SuppressNNS && DTN->getQualifier())
190 DTN->getQualifier()->print(OS, Policy);
193 if (DTN->isIdentifier())
194 OS << DTN->getIdentifier()->getName();
196 OS << "operator " << getOperatorSpelling(DTN->getOperator());
197 } else if (SubstTemplateTemplateParmStorage *subst
198 = getAsSubstTemplateTemplateParm()) {
199 subst->getReplacement().print(OS, Policy, SuppressNNS);
200 } else if (SubstTemplateTemplateParmPackStorage *SubstPack
201 = getAsSubstTemplateTemplateParmPack())
202 OS << *SubstPack->getParameterPack();
204 OverloadedTemplateStorage *OTS = getAsOverloadedTemplate();
205 (*OTS->begin())->printName(OS);
209 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
212 raw_string_ostream OS(NameStr);
217 N.print(OS, PrintingPolicy(LO));
220 return DB << NameStr;
223 void TemplateName::dump(raw_ostream &OS) const {
224 LangOptions LO; // FIXME!
227 print(OS, PrintingPolicy(LO));
230 void TemplateName::dump() const {