1 //===- TemplateName.cpp - C++ Template Name Representation ----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 //  This file defines the TemplateName interface and subclasses.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/TemplateName.h"
14 #include "clang/AST/Decl.h"
15 #include "clang/AST/DeclBase.h"
16 #include "clang/AST/DeclTemplate.h"
17 #include "clang/AST/DependenceFlags.h"
18 #include "clang/AST/NestedNameSpecifier.h"
19 #include "clang/AST/PrettyPrinter.h"
20 #include "clang/AST/TemplateBase.h"
21 #include "clang/Basic/Diagnostic.h"
22 #include "clang/Basic/LLVM.h"
23 #include "clang/Basic/LangOptions.h"
24 #include "clang/Basic/OperatorKinds.h"
25 #include "llvm/ADT/ArrayRef.h"
26 #include "llvm/ADT/FoldingSet.h"
27 #include "llvm/Support/Casting.h"
28 #include "llvm/Support/Compiler.h"
29 #include "llvm/Support/raw_ostream.h"
30 #include <cassert>
31 #include <string>
32 
33 using namespace clang;
34 
35 TemplateArgument
36 SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
37   return TemplateArgument(llvm::makeArrayRef(Arguments, size()));
38 }
39 
40 void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) {
41   Profile(ID, Parameter, Replacement);
42 }
43 
44 void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID,
45                                            TemplateTemplateParmDecl *parameter,
46                                                TemplateName replacement) {
47   ID.AddPointer(parameter);
48   ID.AddPointer(replacement.getAsVoidPointer());
49 }
50 
51 void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
52                                                    ASTContext &Context) {
53   Profile(ID, Context, Parameter, getArgumentPack());
54 }
55 
56 void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
57                                                    ASTContext &Context,
58                                            TemplateTemplateParmDecl *Parameter,
59                                              const TemplateArgument &ArgPack) {
60   ID.AddPointer(Parameter);
61   ArgPack.Profile(ID, Context);
62 }
63 
64 TemplateName::TemplateName(void *Ptr) {
65   Storage = StorageType::getFromOpaqueValue(Ptr);
66 }
67 
68 TemplateName::TemplateName(TemplateDecl *Template) : Storage(Template) {}
69 TemplateName::TemplateName(OverloadedTemplateStorage *Storage)
70     : Storage(Storage) {}
71 TemplateName::TemplateName(AssumedTemplateStorage *Storage)
72     : Storage(Storage) {}
73 TemplateName::TemplateName(SubstTemplateTemplateParmStorage *Storage)
74     : Storage(Storage) {}
75 TemplateName::TemplateName(SubstTemplateTemplateParmPackStorage *Storage)
76     : Storage(Storage) {}
77 TemplateName::TemplateName(QualifiedTemplateName *Qual) : Storage(Qual) {}
78 TemplateName::TemplateName(DependentTemplateName *Dep) : Storage(Dep) {}
79 
80 bool TemplateName::isNull() const { return Storage.isNull(); }
81 
82 TemplateName::NameKind TemplateName::getKind() const {
83   if (Storage.is<TemplateDecl *>())
84     return Template;
85   if (Storage.is<DependentTemplateName *>())
86     return DependentTemplate;
87   if (Storage.is<QualifiedTemplateName *>())
88     return QualifiedTemplate;
89 
90   UncommonTemplateNameStorage *uncommon
91     = Storage.get<UncommonTemplateNameStorage*>();
92   if (uncommon->getAsOverloadedStorage())
93     return OverloadedTemplate;
94   if (uncommon->getAsAssumedTemplateName())
95     return AssumedTemplate;
96   if (uncommon->getAsSubstTemplateTemplateParm())
97     return SubstTemplateTemplateParm;
98   return SubstTemplateTemplateParmPack;
99 }
100 
101 TemplateDecl *TemplateName::getAsTemplateDecl() const {
102   if (TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>())
103     return Template;
104 
105   if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
106     return QTN->getTemplateDecl();
107 
108   if (SubstTemplateTemplateParmStorage *sub = getAsSubstTemplateTemplateParm())
109     return sub->getReplacement().getAsTemplateDecl();
110 
111   return nullptr;
112 }
113 
114 OverloadedTemplateStorage *TemplateName::getAsOverloadedTemplate() const {
115   if (UncommonTemplateNameStorage *Uncommon =
116           Storage.dyn_cast<UncommonTemplateNameStorage *>())
117     return Uncommon->getAsOverloadedStorage();
118 
119   return nullptr;
120 }
121 
122 AssumedTemplateStorage *TemplateName::getAsAssumedTemplateName() const {
123   if (UncommonTemplateNameStorage *Uncommon =
124           Storage.dyn_cast<UncommonTemplateNameStorage *>())
125     return Uncommon->getAsAssumedTemplateName();
126 
127   return nullptr;
128 }
129 
130 SubstTemplateTemplateParmStorage *
131 TemplateName::getAsSubstTemplateTemplateParm() const {
132   if (UncommonTemplateNameStorage *uncommon =
133           Storage.dyn_cast<UncommonTemplateNameStorage *>())
134     return uncommon->getAsSubstTemplateTemplateParm();
135 
136   return nullptr;
137 }
138 
139 SubstTemplateTemplateParmPackStorage *
140 TemplateName::getAsSubstTemplateTemplateParmPack() const {
141   if (UncommonTemplateNameStorage *Uncommon =
142           Storage.dyn_cast<UncommonTemplateNameStorage *>())
143     return Uncommon->getAsSubstTemplateTemplateParmPack();
144 
145   return nullptr;
146 }
147 
148 QualifiedTemplateName *TemplateName::getAsQualifiedTemplateName() const {
149   return Storage.dyn_cast<QualifiedTemplateName *>();
150 }
151 
152 DependentTemplateName *TemplateName::getAsDependentTemplateName() const {
153   return Storage.dyn_cast<DependentTemplateName *>();
154 }
155 
156 TemplateName TemplateName::getNameToSubstitute() const {
157   TemplateDecl *Decl = getAsTemplateDecl();
158 
159   // Substituting a dependent template name: preserve it as written.
160   if (!Decl)
161     return *this;
162 
163   // If we have a template declaration, use the most recent non-friend
164   // declaration of that template.
165   Decl = cast<TemplateDecl>(Decl->getMostRecentDecl());
166   while (Decl->getFriendObjectKind()) {
167     Decl = cast<TemplateDecl>(Decl->getPreviousDecl());
168     assert(Decl && "all declarations of template are friends");
169   }
170   return TemplateName(Decl);
171 }
172 
173 TemplateNameDependence TemplateName::getDependence() const {
174   auto D = TemplateNameDependence::None;
175   switch (getKind()) {
176   case TemplateName::NameKind::QualifiedTemplate:
177     D |= toTemplateNameDependence(
178         getAsQualifiedTemplateName()->getQualifier()->getDependence());
179     break;
180   case TemplateName::NameKind::DependentTemplate:
181     D |= toTemplateNameDependence(
182         getAsDependentTemplateName()->getQualifier()->getDependence());
183     break;
184   case TemplateName::NameKind::SubstTemplateTemplateParmPack:
185     D |= TemplateNameDependence::UnexpandedPack;
186     break;
187   case TemplateName::NameKind::OverloadedTemplate:
188     llvm_unreachable("overloaded templates shouldn't survive to here.");
189   default:
190     break;
191   }
192   if (TemplateDecl *Template = getAsTemplateDecl()) {
193     if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template)) {
194       D |= TemplateNameDependence::DependentInstantiation;
195       if (TTP->isParameterPack())
196         D |= TemplateNameDependence::UnexpandedPack;
197     }
198     // FIXME: Hack, getDeclContext() can be null if Template is still
199     // initializing due to PCH reading, so we check it before using it.
200     // Should probably modify TemplateSpecializationType to allow constructing
201     // it without the isDependent() checking.
202     if (Template->getDeclContext() &&
203         Template->getDeclContext()->isDependentContext())
204       D |= TemplateNameDependence::DependentInstantiation;
205   } else {
206     D |= TemplateNameDependence::DependentInstantiation;
207   }
208   return D;
209 }
210 
211 bool TemplateName::isDependent() const {
212   return getDependence() & TemplateNameDependence::Dependent;
213 }
214 
215 bool TemplateName::isInstantiationDependent() const {
216   return getDependence() & TemplateNameDependence::Instantiation;
217 }
218 
219 bool TemplateName::containsUnexpandedParameterPack() const {
220   return getDependence() & TemplateNameDependence::UnexpandedPack;
221 }
222 
223 void
224 TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
225                     bool SuppressNNS) const {
226   if (TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>())
227     OS << *Template;
228   else if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName()) {
229     if (!SuppressNNS)
230       QTN->getQualifier()->print(OS, Policy);
231     if (QTN->hasTemplateKeyword())
232       OS << "template ";
233     OS << *QTN->getDecl();
234   } else if (DependentTemplateName *DTN = getAsDependentTemplateName()) {
235     if (!SuppressNNS && DTN->getQualifier())
236       DTN->getQualifier()->print(OS, Policy);
237     OS << "template ";
238 
239     if (DTN->isIdentifier())
240       OS << DTN->getIdentifier()->getName();
241     else
242       OS << "operator " << getOperatorSpelling(DTN->getOperator());
243   } else if (SubstTemplateTemplateParmStorage *subst
244                = getAsSubstTemplateTemplateParm()) {
245     subst->getReplacement().print(OS, Policy, SuppressNNS);
246   } else if (SubstTemplateTemplateParmPackStorage *SubstPack
247                                         = getAsSubstTemplateTemplateParmPack())
248     OS << *SubstPack->getParameterPack();
249   else if (AssumedTemplateStorage *Assumed = getAsAssumedTemplateName()) {
250     Assumed->getDeclName().print(OS, Policy);
251   } else {
252     OverloadedTemplateStorage *OTS = getAsOverloadedTemplate();
253     (*OTS->begin())->printName(OS);
254   }
255 }
256 
257 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
258                                            TemplateName N) {
259   std::string NameStr;
260   llvm::raw_string_ostream OS(NameStr);
261   LangOptions LO;
262   LO.CPlusPlus = true;
263   LO.Bool = true;
264   OS << '\'';
265   N.print(OS, PrintingPolicy(LO));
266   OS << '\'';
267   OS.flush();
268   return DB << NameStr;
269 }
270 
271 const PartialDiagnostic&clang::operator<<(const PartialDiagnostic &PD,
272                                            TemplateName N) {
273   std::string NameStr;
274   llvm::raw_string_ostream OS(NameStr);
275   LangOptions LO;
276   LO.CPlusPlus = true;
277   LO.Bool = true;
278   OS << '\'';
279   N.print(OS, PrintingPolicy(LO));
280   OS << '\'';
281   OS.flush();
282   return PD << NameStr;
283 }
284 
285 void TemplateName::dump(raw_ostream &OS) const {
286   LangOptions LO;  // FIXME!
287   LO.CPlusPlus = true;
288   LO.Bool = true;
289   print(OS, PrintingPolicy(LO));
290 }
291 
292 LLVM_DUMP_METHOD void TemplateName::dump() const {
293   dump(llvm::errs());
294 }
295