1 | //===- DeclTemplate.cpp - Template Declaration AST Node Implementation ----===// |
---|---|
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 implements the C++ related Decl classes for templates. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #include "clang/AST/DeclTemplate.h" |
14 | #include "clang/AST/ASTContext.h" |
15 | #include "clang/AST/ASTMutationListener.h" |
16 | #include "clang/AST/DeclCXX.h" |
17 | #include "clang/AST/DeclarationName.h" |
18 | #include "clang/AST/Expr.h" |
19 | #include "clang/AST/ExprCXX.h" |
20 | #include "clang/AST/ExternalASTSource.h" |
21 | #include "clang/AST/ODRHash.h" |
22 | #include "clang/AST/TemplateBase.h" |
23 | #include "clang/AST/TemplateName.h" |
24 | #include "clang/AST/Type.h" |
25 | #include "clang/AST/TypeLoc.h" |
26 | #include "clang/Basic/Builtins.h" |
27 | #include "clang/Basic/LLVM.h" |
28 | #include "clang/Basic/SourceLocation.h" |
29 | #include "llvm/ADT/ArrayRef.h" |
30 | #include "llvm/ADT/FoldingSet.h" |
31 | #include "llvm/ADT/PointerUnion.h" |
32 | #include "llvm/ADT/STLExtras.h" |
33 | #include "llvm/ADT/SmallVector.h" |
34 | #include "llvm/Support/ErrorHandling.h" |
35 | #include <cassert> |
36 | #include <optional> |
37 | #include <utility> |
38 | |
39 | using namespace clang; |
40 | |
41 | //===----------------------------------------------------------------------===// |
42 | // TemplateParameterList Implementation |
43 | //===----------------------------------------------------------------------===// |
44 | |
45 | template <class TemplateParam> |
46 | static bool |
47 | DefaultTemplateArgumentContainsUnexpandedPack(const TemplateParam &P) { |
48 | return P.hasDefaultArgument() && |
49 | P.getDefaultArgument().getArgument().containsUnexpandedParameterPack(); |
50 | } |
51 | |
52 | TemplateParameterList::TemplateParameterList(const ASTContext &C, |
53 | SourceLocation TemplateLoc, |
54 | SourceLocation LAngleLoc, |
55 | ArrayRef<NamedDecl *> Params, |
56 | SourceLocation RAngleLoc, |
57 | Expr *RequiresClause) |
58 | : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc), |
59 | NumParams(Params.size()), ContainsUnexpandedParameterPack(false), |
60 | HasRequiresClause(RequiresClause != nullptr), |
61 | HasConstrainedParameters(false) { |
62 | for (unsigned Idx = 0; Idx < NumParams; ++Idx) { |
63 | NamedDecl *P = Params[Idx]; |
64 | begin()[Idx] = P; |
65 | |
66 | bool IsPack = P->isTemplateParameterPack(); |
67 | if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Val: P)) { |
68 | if (!IsPack && (NTTP->getType()->containsUnexpandedParameterPack() || |
69 | DefaultTemplateArgumentContainsUnexpandedPack(P: *NTTP))) |
70 | ContainsUnexpandedParameterPack = true; |
71 | if (NTTP->hasPlaceholderTypeConstraint()) |
72 | HasConstrainedParameters = true; |
73 | } else if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Val: P)) { |
74 | if (!IsPack && |
75 | (TTP->getTemplateParameters()->containsUnexpandedParameterPack() || |
76 | DefaultTemplateArgumentContainsUnexpandedPack(P: *TTP))) { |
77 | ContainsUnexpandedParameterPack = true; |
78 | } |
79 | } else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Val: P)) { |
80 | if (!IsPack && DefaultTemplateArgumentContainsUnexpandedPack(P: *TTP)) { |
81 | ContainsUnexpandedParameterPack = true; |
82 | } else if (const TypeConstraint *TC = TTP->getTypeConstraint(); |
83 | TC && TC->getImmediatelyDeclaredConstraint() |
84 | ->containsUnexpandedParameterPack()) { |
85 | ContainsUnexpandedParameterPack = true; |
86 | } |
87 | if (TTP->hasTypeConstraint()) |
88 | HasConstrainedParameters = true; |
89 | } else { |
90 | llvm_unreachable("unexpected template parameter type"); |
91 | } |
92 | } |
93 | |
94 | if (HasRequiresClause) { |
95 | if (RequiresClause->containsUnexpandedParameterPack()) |
96 | ContainsUnexpandedParameterPack = true; |
97 | *getTrailingObjects<Expr *>() = RequiresClause; |
98 | } |
99 | } |
100 | |
101 | bool TemplateParameterList::containsUnexpandedParameterPack() const { |
102 | if (ContainsUnexpandedParameterPack) |
103 | return true; |
104 | if (!HasConstrainedParameters) |
105 | return false; |
106 | |
107 | // An implicit constrained parameter might have had a use of an unexpanded |
108 | // pack added to it after the template parameter list was created. All |
109 | // implicit parameters are at the end of the parameter list. |
110 | for (const NamedDecl *Param : llvm::reverse(C: asArray())) { |
111 | if (!Param->isImplicit()) |
112 | break; |
113 | |
114 | if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Val: Param)) { |
115 | const auto *TC = TTP->getTypeConstraint(); |
116 | if (TC && TC->getImmediatelyDeclaredConstraint() |
117 | ->containsUnexpandedParameterPack()) |
118 | return true; |
119 | } |
120 | } |
121 | |
122 | return false; |
123 | } |
124 | |
125 | TemplateParameterList * |
126 | TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc, |
127 | SourceLocation LAngleLoc, |
128 | ArrayRef<NamedDecl *> Params, |
129 | SourceLocation RAngleLoc, Expr *RequiresClause) { |
130 | void *Mem = C.Allocate(Size: totalSizeToAlloc<NamedDecl *, Expr *>( |
131 | Counts: Params.size(), Counts: RequiresClause ? 1u : 0u), |
132 | Align: alignof(TemplateParameterList)); |
133 | return new (Mem) TemplateParameterList(C, TemplateLoc, LAngleLoc, Params, |
134 | RAngleLoc, RequiresClause); |
135 | } |
136 | |
137 | void TemplateParameterList::Profile(llvm::FoldingSetNodeID &ID, |
138 | const ASTContext &C) const { |
139 | const Expr *RC = getRequiresClause(); |
140 | ID.AddBoolean(B: RC != nullptr); |
141 | if (RC) |
142 | RC->Profile(ID, C, /*Canonical=*/true); |
143 | ID.AddInteger(I: size()); |
144 | for (NamedDecl *D : *this) { |
145 | if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Val: D)) { |
146 | ID.AddInteger(I: 0); |
147 | ID.AddBoolean(B: NTTP->isParameterPack()); |
148 | NTTP->getType().getCanonicalType().Profile(ID); |
149 | ID.AddBoolean(B: NTTP->hasPlaceholderTypeConstraint()); |
150 | if (const Expr *E = NTTP->getPlaceholderTypeConstraint()) |
151 | E->Profile(ID, C, /*Canonical=*/true); |
152 | continue; |
153 | } |
154 | if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Val: D)) { |
155 | ID.AddInteger(I: 1); |
156 | ID.AddBoolean(B: TTP->isParameterPack()); |
157 | ID.AddBoolean(B: TTP->hasTypeConstraint()); |
158 | if (const TypeConstraint *TC = TTP->getTypeConstraint()) |
159 | TC->getImmediatelyDeclaredConstraint()->Profile(ID, C, |
160 | /*Canonical=*/true); |
161 | continue; |
162 | } |
163 | const auto *TTP = cast<TemplateTemplateParmDecl>(Val: D); |
164 | ID.AddInteger(I: 2); |
165 | ID.AddBoolean(B: TTP->isParameterPack()); |
166 | TTP->getTemplateParameters()->Profile(ID, C); |
167 | } |
168 | } |
169 | |
170 | unsigned TemplateParameterList::getMinRequiredArguments() const { |
171 | unsigned NumRequiredArgs = 0; |
172 | for (const NamedDecl *P : asArray()) { |
173 | if (P->isTemplateParameterPack()) { |
174 | if (UnsignedOrNone Expansions = getExpandedPackSize(Param: P)) { |
175 | NumRequiredArgs += *Expansions; |
176 | continue; |
177 | } |
178 | break; |
179 | } |
180 | |
181 | if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Val: P)) { |
182 | if (TTP->hasDefaultArgument()) |
183 | break; |
184 | } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Val: P)) { |
185 | if (NTTP->hasDefaultArgument()) |
186 | break; |
187 | } else if (cast<TemplateTemplateParmDecl>(Val: P)->hasDefaultArgument()) |
188 | break; |
189 | |
190 | ++NumRequiredArgs; |
191 | } |
192 | |
193 | return NumRequiredArgs; |
194 | } |
195 | |
196 | unsigned TemplateParameterList::getDepth() const { |
197 | if (size() == 0) |
198 | return 0; |
199 | |
200 | const NamedDecl *FirstParm = getParam(Idx: 0); |
201 | if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Val: FirstParm)) |
202 | return TTP->getDepth(); |
203 | else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Val: FirstParm)) |
204 | return NTTP->getDepth(); |
205 | else |
206 | return cast<TemplateTemplateParmDecl>(Val: FirstParm)->getDepth(); |
207 | } |
208 | |
209 | static bool AdoptTemplateParameterList(TemplateParameterList *Params, |
210 | DeclContext *Owner) { |
211 | bool Invalid = false; |
212 | for (NamedDecl *P : *Params) { |
213 | P->setDeclContext(Owner); |
214 | |
215 | if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Val: P)) |
216 | if (AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner)) |
217 | Invalid = true; |
218 | |
219 | if (P->isInvalidDecl()) |
220 | Invalid = true; |
221 | } |
222 | return Invalid; |
223 | } |
224 | |
225 | void TemplateParameterList::getAssociatedConstraints( |
226 | llvm::SmallVectorImpl<AssociatedConstraint> &ACs) const { |
227 | if (HasConstrainedParameters) |
228 | for (const NamedDecl *Param : *this) { |
229 | if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Val: Param)) { |
230 | if (const auto *TC = TTP->getTypeConstraint()) |
231 | ACs.emplace_back(Args: TC->getImmediatelyDeclaredConstraint(), |
232 | Args: TC->getArgPackSubstIndex()); |
233 | } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Val: Param)) { |
234 | if (const Expr *E = NTTP->getPlaceholderTypeConstraint()) |
235 | ACs.emplace_back(Args&: E); |
236 | } |
237 | } |
238 | if (HasRequiresClause) |
239 | ACs.emplace_back(Args: getRequiresClause()); |
240 | } |
241 | |
242 | bool TemplateParameterList::hasAssociatedConstraints() const { |
243 | return HasRequiresClause || HasConstrainedParameters; |
244 | } |
245 | |
246 | ArrayRef<TemplateArgument> |
247 | TemplateParameterList::getInjectedTemplateArgs(const ASTContext &Context) { |
248 | if (!InjectedArgs) { |
249 | InjectedArgs = new (Context) TemplateArgument[size()]; |
250 | llvm::transform(Range&: *this, d_first: InjectedArgs, F: [&](NamedDecl *ND) { |
251 | return Context.getInjectedTemplateArg(ParamDecl: ND); |
252 | }); |
253 | } |
254 | return {InjectedArgs, NumParams}; |
255 | } |
256 | |
257 | bool TemplateParameterList::shouldIncludeTypeForArgument( |
258 | const PrintingPolicy &Policy, const TemplateParameterList *TPL, |
259 | unsigned Idx) { |
260 | if (!TPL || Idx >= TPL->size() || Policy.AlwaysIncludeTypeForTemplateArgument) |
261 | return true; |
262 | const NamedDecl *TemplParam = TPL->getParam(Idx); |
263 | if (const auto *ParamValueDecl = |
264 | dyn_cast<NonTypeTemplateParmDecl>(Val: TemplParam)) |
265 | if (ParamValueDecl->getType()->getContainedDeducedType()) |
266 | return true; |
267 | return false; |
268 | } |
269 | |
270 | namespace clang { |
271 | |
272 | void *allocateDefaultArgStorageChain(const ASTContext &C) { |
273 | return new (C) char[sizeof(void*) * 2]; |
274 | } |
275 | |
276 | } // namespace clang |
277 | |
278 | //===----------------------------------------------------------------------===// |
279 | // TemplateDecl Implementation |
280 | //===----------------------------------------------------------------------===// |
281 | |
282 | TemplateDecl::TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, |
283 | DeclarationName Name, TemplateParameterList *Params, |
284 | NamedDecl *Decl) |
285 | : NamedDecl(DK, DC, L, Name), TemplatedDecl(Decl), TemplateParams(Params) {} |
286 | |
287 | void TemplateDecl::anchor() {} |
288 | |
289 | void TemplateDecl::getAssociatedConstraints( |
290 | llvm::SmallVectorImpl<AssociatedConstraint> &ACs) const { |
291 | TemplateParams->getAssociatedConstraints(ACs); |
292 | if (auto *FD = dyn_cast_or_null<FunctionDecl>(Val: getTemplatedDecl())) |
293 | if (const AssociatedConstraint &TRC = FD->getTrailingRequiresClause()) |
294 | ACs.emplace_back(Args: TRC); |
295 | } |
296 | |
297 | bool TemplateDecl::hasAssociatedConstraints() const { |
298 | if (TemplateParams->hasAssociatedConstraints()) |
299 | return true; |
300 | if (auto *FD = dyn_cast_or_null<FunctionDecl>(Val: getTemplatedDecl())) |
301 | return static_cast<bool>(FD->getTrailingRequiresClause()); |
302 | return false; |
303 | } |
304 | |
305 | bool TemplateDecl::isTypeAlias() const { |
306 | switch (getKind()) { |
307 | case TemplateDecl::TypeAliasTemplate: |
308 | case TemplateDecl::BuiltinTemplate: |
309 | return true; |
310 | default: |
311 | return false; |
312 | }; |
313 | } |
314 | |
315 | //===----------------------------------------------------------------------===// |
316 | // RedeclarableTemplateDecl Implementation |
317 | //===----------------------------------------------------------------------===// |
318 | |
319 | void RedeclarableTemplateDecl::anchor() {} |
320 | |
321 | RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const { |
322 | if (Common) |
323 | return Common; |
324 | |
325 | // Walk the previous-declaration chain until we either find a declaration |
326 | // with a common pointer or we run out of previous declarations. |
327 | SmallVector<const RedeclarableTemplateDecl *, 2> PrevDecls; |
328 | for (const RedeclarableTemplateDecl *Prev = getPreviousDecl(); Prev; |
329 | Prev = Prev->getPreviousDecl()) { |
330 | if (Prev->Common) { |
331 | Common = Prev->Common; |
332 | break; |
333 | } |
334 | |
335 | PrevDecls.push_back(Elt: Prev); |
336 | } |
337 | |
338 | // If we never found a common pointer, allocate one now. |
339 | if (!Common) { |
340 | // FIXME: If any of the declarations is from an AST file, we probably |
341 | // need an update record to add the common data. |
342 | |
343 | Common = newCommon(C&: getASTContext()); |
344 | } |
345 | |
346 | // Update any previous declarations we saw with the common pointer. |
347 | for (const RedeclarableTemplateDecl *Prev : PrevDecls) |
348 | Prev->Common = Common; |
349 | |
350 | return Common; |
351 | } |
352 | |
353 | void RedeclarableTemplateDecl::loadLazySpecializationsImpl( |
354 | bool OnlyPartial /*=false*/) const { |
355 | auto *ExternalSource = getASTContext().getExternalSource(); |
356 | if (!ExternalSource) |
357 | return; |
358 | |
359 | ExternalSource->LoadExternalSpecializations(this->getCanonicalDecl(), |
360 | OnlyPartial); |
361 | } |
362 | |
363 | bool RedeclarableTemplateDecl::loadLazySpecializationsImpl( |
364 | ArrayRef<TemplateArgument> Args, TemplateParameterList *TPL) const { |
365 | auto *ExternalSource = getASTContext().getExternalSource(); |
366 | if (!ExternalSource) |
367 | return false; |
368 | |
369 | // If TPL is not null, it implies that we're loading specializations for |
370 | // partial templates. We need to load all specializations in such cases. |
371 | if (TPL) |
372 | return ExternalSource->LoadExternalSpecializations(this->getCanonicalDecl(), |
373 | /*OnlyPartial=*/false); |
374 | |
375 | return ExternalSource->LoadExternalSpecializations(this->getCanonicalDecl(), |
376 | Args); |
377 | } |
378 | |
379 | template <class EntryType, typename... ProfileArguments> |
380 | typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType * |
381 | RedeclarableTemplateDecl::findSpecializationLocally( |
382 | llvm::FoldingSetVector<EntryType> &Specs, void *&InsertPos, |
383 | ProfileArguments... ProfileArgs) { |
384 | using SETraits = RedeclarableTemplateDecl::SpecEntryTraits<EntryType>; |
385 | |
386 | llvm::FoldingSetNodeID ID; |
387 | EntryType::Profile(ID, ProfileArgs..., getASTContext()); |
388 | EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos); |
389 | return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr; |
390 | } |
391 | |
392 | template <class EntryType, typename... ProfileArguments> |
393 | typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType * |
394 | RedeclarableTemplateDecl::findSpecializationImpl( |
395 | llvm::FoldingSetVector<EntryType> &Specs, void *&InsertPos, |
396 | ProfileArguments... ProfileArgs) { |
397 | |
398 | if (auto *Found = findSpecializationLocally(Specs, InsertPos, ProfileArgs...)) |
399 | return Found; |
400 | |
401 | if (!loadLazySpecializationsImpl(ProfileArgs...)) |
402 | return nullptr; |
403 | |
404 | return findSpecializationLocally(Specs, InsertPos, ProfileArgs...); |
405 | } |
406 | |
407 | template<class Derived, class EntryType> |
408 | void RedeclarableTemplateDecl::addSpecializationImpl( |
409 | llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry, |
410 | void *InsertPos) { |
411 | using SETraits = SpecEntryTraits<EntryType>; |
412 | |
413 | if (InsertPos) { |
414 | #ifndef NDEBUG |
415 | auto Args = SETraits::getTemplateArgs(Entry); |
416 | // Due to hash collisions, it can happen that we load another template |
417 | // specialization with the same hash. This is fine, as long as the next |
418 | // call to findSpecializationImpl does not find a matching Decl for the |
419 | // template arguments. |
420 | loadLazySpecializationsImpl(Args); |
421 | void *CorrectInsertPos; |
422 | assert(!findSpecializationImpl(Specializations, CorrectInsertPos, Args) && |
423 | InsertPos == CorrectInsertPos && |
424 | "given incorrect InsertPos for specialization"); |
425 | #endif |
426 | Specializations.InsertNode(Entry, InsertPos); |
427 | } else { |
428 | EntryType *Existing = Specializations.GetOrInsertNode(Entry); |
429 | (void)Existing; |
430 | assert(SETraits::getDecl(Existing)->isCanonicalDecl() && |
431 | "non-canonical specialization?"); |
432 | } |
433 | |
434 | if (ASTMutationListener *L = getASTMutationListener()) |
435 | L->AddedCXXTemplateSpecialization(cast<Derived>(this), |
436 | SETraits::getDecl(Entry)); |
437 | } |
438 | |
439 | //===----------------------------------------------------------------------===// |
440 | // FunctionTemplateDecl Implementation |
441 | //===----------------------------------------------------------------------===// |
442 | |
443 | FunctionTemplateDecl * |
444 | FunctionTemplateDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L, |
445 | DeclarationName Name, |
446 | TemplateParameterList *Params, NamedDecl *Decl) { |
447 | bool Invalid = AdoptTemplateParameterList(Params, Owner: cast<DeclContext>(Val: Decl)); |
448 | auto *TD = new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl); |
449 | if (Invalid) |
450 | TD->setInvalidDecl(); |
451 | return TD; |
452 | } |
453 | |
454 | FunctionTemplateDecl * |
455 | FunctionTemplateDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { |
456 | return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(), |
457 | DeclarationName(), nullptr, nullptr); |
458 | } |
459 | |
460 | RedeclarableTemplateDecl::CommonBase * |
461 | FunctionTemplateDecl::newCommon(ASTContext &C) const { |
462 | auto *CommonPtr = new (C) Common; |
463 | C.addDestruction(Ptr: CommonPtr); |
464 | return CommonPtr; |
465 | } |
466 | |
467 | void FunctionTemplateDecl::LoadLazySpecializations() const { |
468 | loadLazySpecializationsImpl(); |
469 | } |
470 | |
471 | llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> & |
472 | FunctionTemplateDecl::getSpecializations() const { |
473 | LoadLazySpecializations(); |
474 | return getCommonPtr()->Specializations; |
475 | } |
476 | |
477 | FunctionDecl * |
478 | FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args, |
479 | void *&InsertPos) { |
480 | auto *Common = getCommonPtr(); |
481 | return findSpecializationImpl(Common->Specializations, InsertPos, Args); |
482 | } |
483 | |
484 | void FunctionTemplateDecl::addSpecialization( |
485 | FunctionTemplateSpecializationInfo *Info, void *InsertPos) { |
486 | auto *Common = getCommonPtr(); |
487 | addSpecializationImpl<FunctionTemplateDecl>(Common->Specializations, Info, |
488 | InsertPos); |
489 | } |
490 | |
491 | void FunctionTemplateDecl::mergePrevDecl(FunctionTemplateDecl *Prev) { |
492 | using Base = RedeclarableTemplateDecl; |
493 | |
494 | // If we haven't created a common pointer yet, then it can just be created |
495 | // with the usual method. |
496 | if (!Base::Common) |
497 | return; |
498 | |
499 | Common *ThisCommon = static_cast<Common *>(Base::Common); |
500 | Common *PrevCommon = nullptr; |
501 | SmallVector<FunctionTemplateDecl *, 8> PreviousDecls; |
502 | for (; Prev; Prev = Prev->getPreviousDecl()) { |
503 | if (Prev->Base::Common) { |
504 | PrevCommon = static_cast<Common *>(Prev->Base::Common); |
505 | break; |
506 | } |
507 | PreviousDecls.push_back(Elt: Prev); |
508 | } |
509 | |
510 | // If the previous redecl chain hasn't created a common pointer yet, then just |
511 | // use this common pointer. |
512 | if (!PrevCommon) { |
513 | for (auto *D : PreviousDecls) |
514 | D->Base::Common = ThisCommon; |
515 | return; |
516 | } |
517 | |
518 | // Ensure we don't leak any important state. |
519 | assert(ThisCommon->Specializations.size() == 0 && |
520 | "Can't merge incompatible declarations!"); |
521 | |
522 | Base::Common = PrevCommon; |
523 | } |
524 | |
525 | //===----------------------------------------------------------------------===// |
526 | // ClassTemplateDecl Implementation |
527 | //===----------------------------------------------------------------------===// |
528 | |
529 | ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C, DeclContext *DC, |
530 | SourceLocation L, |
531 | DeclarationName Name, |
532 | TemplateParameterList *Params, |
533 | NamedDecl *Decl) { |
534 | bool Invalid = AdoptTemplateParameterList(Params, Owner: cast<DeclContext>(Val: Decl)); |
535 | auto *TD = new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl); |
536 | if (Invalid) |
537 | TD->setInvalidDecl(); |
538 | return TD; |
539 | } |
540 | |
541 | ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C, |
542 | GlobalDeclID ID) { |
543 | return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(), |
544 | DeclarationName(), nullptr, nullptr); |
545 | } |
546 | |
547 | void ClassTemplateDecl::LoadLazySpecializations( |
548 | bool OnlyPartial /*=false*/) const { |
549 | loadLazySpecializationsImpl(OnlyPartial); |
550 | } |
551 | |
552 | llvm::FoldingSetVector<ClassTemplateSpecializationDecl> & |
553 | ClassTemplateDecl::getSpecializations() const { |
554 | LoadLazySpecializations(); |
555 | return getCommonPtr()->Specializations; |
556 | } |
557 | |
558 | llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> & |
559 | ClassTemplateDecl::getPartialSpecializations() const { |
560 | LoadLazySpecializations(/*PartialOnly = */ OnlyPartial: true); |
561 | return getCommonPtr()->PartialSpecializations; |
562 | } |
563 | |
564 | RedeclarableTemplateDecl::CommonBase * |
565 | ClassTemplateDecl::newCommon(ASTContext &C) const { |
566 | auto *CommonPtr = new (C) Common; |
567 | C.addDestruction(Ptr: CommonPtr); |
568 | return CommonPtr; |
569 | } |
570 | |
571 | ClassTemplateSpecializationDecl * |
572 | ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args, |
573 | void *&InsertPos) { |
574 | auto *Common = getCommonPtr(); |
575 | return findSpecializationImpl(Common->Specializations, InsertPos, Args); |
576 | } |
577 | |
578 | void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D, |
579 | void *InsertPos) { |
580 | auto *Common = getCommonPtr(); |
581 | addSpecializationImpl<ClassTemplateDecl>(Common->Specializations, D, |
582 | InsertPos); |
583 | } |
584 | |
585 | ClassTemplatePartialSpecializationDecl * |
586 | ClassTemplateDecl::findPartialSpecialization( |
587 | ArrayRef<TemplateArgument> Args, |
588 | TemplateParameterList *TPL, void *&InsertPos) { |
589 | return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args, |
590 | TPL); |
591 | } |
592 | |
593 | void ClassTemplatePartialSpecializationDecl::Profile( |
594 | llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs, |
595 | TemplateParameterList *TPL, const ASTContext &Context) { |
596 | ID.AddInteger(I: TemplateArgs.size()); |
597 | for (const TemplateArgument &TemplateArg : TemplateArgs) |
598 | TemplateArg.Profile(ID, Context); |
599 | TPL->Profile(ID, C: Context); |
600 | } |
601 | |
602 | void ClassTemplateDecl::AddPartialSpecialization( |
603 | ClassTemplatePartialSpecializationDecl *D, |
604 | void *InsertPos) { |
605 | if (InsertPos) |
606 | getPartialSpecializations().InsertNode(N: D, InsertPos); |
607 | else { |
608 | ClassTemplatePartialSpecializationDecl *Existing |
609 | = getPartialSpecializations().GetOrInsertNode(N: D); |
610 | (void)Existing; |
611 | assert(Existing->isCanonicalDecl() && "Non-canonical specialization?"); |
612 | } |
613 | |
614 | if (ASTMutationListener *L = getASTMutationListener()) |
615 | L->AddedCXXTemplateSpecialization(this, D); |
616 | } |
617 | |
618 | void ClassTemplateDecl::getPartialSpecializations( |
619 | SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) const { |
620 | llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs |
621 | = getPartialSpecializations(); |
622 | PS.clear(); |
623 | PS.reserve(N: PartialSpecs.size()); |
624 | for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs) |
625 | PS.push_back(Elt: P.getMostRecentDecl()); |
626 | } |
627 | |
628 | ClassTemplatePartialSpecializationDecl * |
629 | ClassTemplateDecl::findPartialSpecialization(QualType T) { |
630 | ASTContext &Context = getASTContext(); |
631 | for (ClassTemplatePartialSpecializationDecl &P : |
632 | getPartialSpecializations()) { |
633 | if (Context.hasSameType(T1: P.getInjectedSpecializationType(), T2: T)) |
634 | return P.getMostRecentDecl(); |
635 | } |
636 | |
637 | return nullptr; |
638 | } |
639 | |
640 | ClassTemplatePartialSpecializationDecl * |
641 | ClassTemplateDecl::findPartialSpecInstantiatedFromMember( |
642 | ClassTemplatePartialSpecializationDecl *D) { |
643 | Decl *DCanon = D->getCanonicalDecl(); |
644 | for (ClassTemplatePartialSpecializationDecl &P : getPartialSpecializations()) { |
645 | if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon) |
646 | return P.getMostRecentDecl(); |
647 | } |
648 | |
649 | return nullptr; |
650 | } |
651 | |
652 | QualType |
653 | ClassTemplateDecl::getInjectedClassNameSpecialization() { |
654 | Common *CommonPtr = getCommonPtr(); |
655 | if (!CommonPtr->InjectedClassNameType.isNull()) |
656 | return CommonPtr->InjectedClassNameType; |
657 | |
658 | // C++0x [temp.dep.type]p2: |
659 | // The template argument list of a primary template is a template argument |
660 | // list in which the nth template argument has the value of the nth template |
661 | // parameter of the class template. If the nth template parameter is a |
662 | // template parameter pack (14.5.3), the nth template argument is a pack |
663 | // expansion (14.5.3) whose pattern is the name of the template parameter |
664 | // pack. |
665 | ASTContext &Context = getASTContext(); |
666 | TemplateName Name = Context.getQualifiedTemplateName( |
667 | /*NNS=*/nullptr, /*TemplateKeyword=*/false, Template: TemplateName(this)); |
668 | auto TemplateArgs = getTemplateParameters()->getInjectedTemplateArgs(Context); |
669 | CommonPtr->InjectedClassNameType = |
670 | Context.getTemplateSpecializationType(Name, |
671 | /*SpecifiedArgs=*/TemplateArgs, |
672 | /*CanonicalArgs=*/std::nullopt); |
673 | return CommonPtr->InjectedClassNameType; |
674 | } |
675 | |
676 | //===----------------------------------------------------------------------===// |
677 | // TemplateTypeParm Allocation/Deallocation Method Implementations |
678 | //===----------------------------------------------------------------------===// |
679 | |
680 | TemplateTypeParmDecl *TemplateTypeParmDecl::Create( |
681 | const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, |
682 | SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, |
683 | bool Typename, bool ParameterPack, bool HasTypeConstraint, |
684 | UnsignedOrNone NumExpanded) { |
685 | auto *TTPDecl = |
686 | new (C, DC, |
687 | additionalSizeToAlloc<TypeConstraint>(Counts: HasTypeConstraint ? 1 : 0)) |
688 | TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename, |
689 | HasTypeConstraint, NumExpanded); |
690 | QualType TTPType = C.getTemplateTypeParmType(Depth: D, Index: P, ParameterPack, ParmDecl: TTPDecl); |
691 | TTPDecl->setTypeForDecl(TTPType.getTypePtr()); |
692 | return TTPDecl; |
693 | } |
694 | |
695 | TemplateTypeParmDecl * |
696 | TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, GlobalDeclID ID) { |
697 | return new (C, ID) |
698 | TemplateTypeParmDecl(nullptr, SourceLocation(), SourceLocation(), nullptr, |
699 | false, false, std::nullopt); |
700 | } |
701 | |
702 | TemplateTypeParmDecl * |
703 | TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, GlobalDeclID ID, |
704 | bool HasTypeConstraint) { |
705 | return new (C, ID, |
706 | additionalSizeToAlloc<TypeConstraint>(Counts: HasTypeConstraint ? 1 : 0)) |
707 | TemplateTypeParmDecl(nullptr, SourceLocation(), SourceLocation(), nullptr, |
708 | false, HasTypeConstraint, std::nullopt); |
709 | } |
710 | |
711 | SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const { |
712 | return hasDefaultArgument() ? getDefaultArgument().getLocation() |
713 | : SourceLocation(); |
714 | } |
715 | |
716 | SourceRange TemplateTypeParmDecl::getSourceRange() const { |
717 | if (hasDefaultArgument() && !defaultArgumentWasInherited()) |
718 | return SourceRange(getBeginLoc(), |
719 | getDefaultArgument().getSourceRange().getEnd()); |
720 | // TypeDecl::getSourceRange returns a range containing name location, which is |
721 | // wrong for unnamed template parameters. e.g: |
722 | // it will return <[[typename>]] instead of <[[typename]]> |
723 | if (getDeclName().isEmpty()) |
724 | return SourceRange(getBeginLoc()); |
725 | return TypeDecl::getSourceRange(); |
726 | } |
727 | |
728 | void TemplateTypeParmDecl::setDefaultArgument( |
729 | const ASTContext &C, const TemplateArgumentLoc &DefArg) { |
730 | if (DefArg.getArgument().isNull()) |
731 | DefaultArgument.set(nullptr); |
732 | else |
733 | DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg)); |
734 | } |
735 | |
736 | unsigned TemplateTypeParmDecl::getDepth() const { |
737 | return getTypeForDecl()->castAs<TemplateTypeParmType>()->getDepth(); |
738 | } |
739 | |
740 | unsigned TemplateTypeParmDecl::getIndex() const { |
741 | return getTypeForDecl()->castAs<TemplateTypeParmType>()->getIndex(); |
742 | } |
743 | |
744 | bool TemplateTypeParmDecl::isParameterPack() const { |
745 | return getTypeForDecl()->castAs<TemplateTypeParmType>()->isParameterPack(); |
746 | } |
747 | |
748 | void TemplateTypeParmDecl::setTypeConstraint( |
749 | ConceptReference *Loc, Expr *ImmediatelyDeclaredConstraint, |
750 | UnsignedOrNone ArgPackSubstIndex) { |
751 | assert(HasTypeConstraint && |
752 | "HasTypeConstraint=true must be passed at construction in order to " |
753 | "call setTypeConstraint"); |
754 | assert(!TypeConstraintInitialized && |
755 | "TypeConstraint was already initialized!"); |
756 | new (getTrailingObjects()) |
757 | TypeConstraint(Loc, ImmediatelyDeclaredConstraint, ArgPackSubstIndex); |
758 | TypeConstraintInitialized = true; |
759 | } |
760 | |
761 | //===----------------------------------------------------------------------===// |
762 | // NonTypeTemplateParmDecl Method Implementations |
763 | //===----------------------------------------------------------------------===// |
764 | |
765 | NonTypeTemplateParmDecl::NonTypeTemplateParmDecl( |
766 | DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, |
767 | unsigned P, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, |
768 | ArrayRef<QualType> ExpandedTypes, ArrayRef<TypeSourceInfo *> ExpandedTInfos) |
769 | : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc), |
770 | TemplateParmPosition(D, P), ParameterPack(true), |
771 | ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) { |
772 | if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) { |
773 | auto TypesAndInfos = |
774 | getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>(); |
775 | for (unsigned I = 0; I != NumExpandedTypes; ++I) { |
776 | new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]); |
777 | TypesAndInfos[I].second = ExpandedTInfos[I]; |
778 | } |
779 | } |
780 | } |
781 | |
782 | NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create( |
783 | const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, |
784 | SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id, |
785 | QualType T, bool ParameterPack, TypeSourceInfo *TInfo) { |
786 | AutoType *AT = |
787 | C.getLangOpts().CPlusPlus20 ? T->getContainedAutoType() : nullptr; |
788 | const bool HasConstraint = AT && AT->isConstrained(); |
789 | auto *NTTP = |
790 | new (C, DC, |
791 | additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, Expr *>( |
792 | 0, HasConstraint ? 1 : 0)) |
793 | NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, |
794 | ParameterPack, TInfo); |
795 | if (HasConstraint) |
796 | NTTP->setPlaceholderTypeConstraint(nullptr); |
797 | return NTTP; |
798 | } |
799 | |
800 | NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create( |
801 | const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, |
802 | SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id, |
803 | QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes, |
804 | ArrayRef<TypeSourceInfo *> ExpandedTInfos) { |
805 | AutoType *AT = TInfo->getType()->getContainedAutoType(); |
806 | const bool HasConstraint = AT && AT->isConstrained(); |
807 | auto *NTTP = |
808 | new (C, DC, |
809 | additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, Expr *>( |
810 | ExpandedTypes.size(), HasConstraint ? 1 : 0)) |
811 | NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo, |
812 | ExpandedTypes, ExpandedTInfos); |
813 | if (HasConstraint) |
814 | NTTP->setPlaceholderTypeConstraint(nullptr); |
815 | return NTTP; |
816 | } |
817 | |
818 | NonTypeTemplateParmDecl * |
819 | NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID, |
820 | bool HasTypeConstraint) { |
821 | auto *NTTP = |
822 | new (C, ID, |
823 | additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, Expr *>( |
824 | 0, HasTypeConstraint ? 1 : 0)) |
825 | NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(), |
826 | 0, 0, nullptr, QualType(), false, nullptr); |
827 | if (HasTypeConstraint) |
828 | NTTP->setPlaceholderTypeConstraint(nullptr); |
829 | return NTTP; |
830 | } |
831 | |
832 | NonTypeTemplateParmDecl * |
833 | NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID, |
834 | unsigned NumExpandedTypes, |
835 | bool HasTypeConstraint) { |
836 | auto *NTTP = |
837 | new (C, ID, |
838 | additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, Expr *>( |
839 | NumExpandedTypes, HasTypeConstraint ? 1 : 0)) |
840 | NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(), |
841 | 0, 0, nullptr, QualType(), nullptr, {}, {}); |
842 | NTTP->NumExpandedTypes = NumExpandedTypes; |
843 | if (HasTypeConstraint) |
844 | NTTP->setPlaceholderTypeConstraint(nullptr); |
845 | return NTTP; |
846 | } |
847 | |
848 | SourceRange NonTypeTemplateParmDecl::getSourceRange() const { |
849 | if (hasDefaultArgument() && !defaultArgumentWasInherited()) |
850 | return SourceRange(getOuterLocStart(), |
851 | getDefaultArgument().getSourceRange().getEnd()); |
852 | return DeclaratorDecl::getSourceRange(); |
853 | } |
854 | |
855 | SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const { |
856 | return hasDefaultArgument() ? getDefaultArgument().getSourceRange().getBegin() |
857 | : SourceLocation(); |
858 | } |
859 | |
860 | void NonTypeTemplateParmDecl::setDefaultArgument( |
861 | const ASTContext &C, const TemplateArgumentLoc &DefArg) { |
862 | if (DefArg.getArgument().isNull()) |
863 | DefaultArgument.set(nullptr); |
864 | else |
865 | DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg)); |
866 | } |
867 | |
868 | //===----------------------------------------------------------------------===// |
869 | // TemplateTemplateParmDecl Method Implementations |
870 | //===----------------------------------------------------------------------===// |
871 | |
872 | void TemplateTemplateParmDecl::anchor() {} |
873 | |
874 | TemplateTemplateParmDecl::TemplateTemplateParmDecl( |
875 | DeclContext *DC, SourceLocation L, unsigned D, unsigned P, |
876 | IdentifierInfo *Id, bool Typename, TemplateParameterList *Params, |
877 | ArrayRef<TemplateParameterList *> Expansions) |
878 | : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params), |
879 | TemplateParmPosition(D, P), Typename(Typename), ParameterPack(true), |
880 | ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) { |
881 | llvm::uninitialized_copy(Expansions, getTrailingObjects()); |
882 | } |
883 | |
884 | TemplateTemplateParmDecl * |
885 | TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC, |
886 | SourceLocation L, unsigned D, unsigned P, |
887 | bool ParameterPack, IdentifierInfo *Id, |
888 | bool Typename, TemplateParameterList *Params) { |
889 | return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id, |
890 | Typename, Params); |
891 | } |
892 | |
893 | TemplateTemplateParmDecl * |
894 | TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC, |
895 | SourceLocation L, unsigned D, unsigned P, |
896 | IdentifierInfo *Id, bool Typename, |
897 | TemplateParameterList *Params, |
898 | ArrayRef<TemplateParameterList *> Expansions) { |
899 | return new (C, DC, |
900 | additionalSizeToAlloc<TemplateParameterList *>(Counts: Expansions.size())) |
901 | TemplateTemplateParmDecl(DC, L, D, P, Id, Typename, Params, Expansions); |
902 | } |
903 | |
904 | TemplateTemplateParmDecl * |
905 | TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { |
906 | return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, |
907 | false, nullptr, false, nullptr); |
908 | } |
909 | |
910 | TemplateTemplateParmDecl * |
911 | TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID, |
912 | unsigned NumExpansions) { |
913 | auto *TTP = |
914 | new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(Counts: NumExpansions)) |
915 | TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr, |
916 | false, nullptr, {}); |
917 | TTP->NumExpandedParams = NumExpansions; |
918 | return TTP; |
919 | } |
920 | |
921 | SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const { |
922 | return hasDefaultArgument() ? getDefaultArgument().getLocation() |
923 | : SourceLocation(); |
924 | } |
925 | |
926 | void TemplateTemplateParmDecl::setDefaultArgument( |
927 | const ASTContext &C, const TemplateArgumentLoc &DefArg) { |
928 | if (DefArg.getArgument().isNull()) |
929 | DefaultArgument.set(nullptr); |
930 | else |
931 | DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg)); |
932 | } |
933 | |
934 | //===----------------------------------------------------------------------===// |
935 | // TemplateArgumentList Implementation |
936 | //===----------------------------------------------------------------------===// |
937 | TemplateArgumentList::TemplateArgumentList(ArrayRef<TemplateArgument> Args) |
938 | : NumArguments(Args.size()) { |
939 | llvm::uninitialized_copy(Src&: Args, Dst: getTrailingObjects()); |
940 | } |
941 | |
942 | TemplateArgumentList * |
943 | TemplateArgumentList::CreateCopy(ASTContext &Context, |
944 | ArrayRef<TemplateArgument> Args) { |
945 | void *Mem = Context.Allocate(Size: totalSizeToAlloc<TemplateArgument>(Counts: Args.size())); |
946 | return new (Mem) TemplateArgumentList(Args); |
947 | } |
948 | |
949 | FunctionTemplateSpecializationInfo *FunctionTemplateSpecializationInfo::Create( |
950 | ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template, |
951 | TemplateSpecializationKind TSK, TemplateArgumentList *TemplateArgs, |
952 | const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI, |
953 | MemberSpecializationInfo *MSInfo) { |
954 | const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr; |
955 | if (TemplateArgsAsWritten) |
956 | ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C, |
957 | List: *TemplateArgsAsWritten); |
958 | |
959 | void *Mem = |
960 | C.Allocate(Size: totalSizeToAlloc<MemberSpecializationInfo *>(Counts: MSInfo ? 1 : 0)); |
961 | return new (Mem) FunctionTemplateSpecializationInfo( |
962 | FD, Template, TSK, TemplateArgs, ArgsAsWritten, POI, MSInfo); |
963 | } |
964 | |
965 | //===----------------------------------------------------------------------===// |
966 | // ClassTemplateSpecializationDecl Implementation |
967 | //===----------------------------------------------------------------------===// |
968 | |
969 | ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl( |
970 | ASTContext &Context, Kind DK, TagKind TK, DeclContext *DC, |
971 | SourceLocation StartLoc, SourceLocation IdLoc, |
972 | ClassTemplateDecl *SpecializedTemplate, ArrayRef<TemplateArgument> Args, |
973 | bool StrictPackMatch, ClassTemplateSpecializationDecl *PrevDecl) |
974 | : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc, |
975 | SpecializedTemplate->getIdentifier(), PrevDecl), |
976 | SpecializedTemplate(SpecializedTemplate), |
977 | TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)), |
978 | SpecializationKind(TSK_Undeclared), StrictPackMatch(StrictPackMatch) { |
979 | assert(DK == Kind::ClassTemplateSpecialization || StrictPackMatch == false); |
980 | } |
981 | |
982 | ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C, |
983 | Kind DK) |
984 | : CXXRecordDecl(DK, TagTypeKind::Struct, C, nullptr, SourceLocation(), |
985 | SourceLocation(), nullptr, nullptr), |
986 | SpecializationKind(TSK_Undeclared) {} |
987 | |
988 | ClassTemplateSpecializationDecl *ClassTemplateSpecializationDecl::Create( |
989 | ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, |
990 | SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, |
991 | ArrayRef<TemplateArgument> Args, bool StrictPackMatch, |
992 | ClassTemplateSpecializationDecl *PrevDecl) { |
993 | auto *Result = new (Context, DC) ClassTemplateSpecializationDecl( |
994 | Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc, |
995 | SpecializedTemplate, Args, StrictPackMatch, PrevDecl); |
996 | Result->setMayHaveOutOfDateDef(false); |
997 | |
998 | // If the template decl is incomplete, copy the external lexical storage from |
999 | // the base template. This allows instantiations of incomplete types to |
1000 | // complete using the external AST if the template's declaration came from an |
1001 | // external AST. |
1002 | if (!SpecializedTemplate->getTemplatedDecl()->isCompleteDefinition()) |
1003 | Result->setHasExternalLexicalStorage( |
1004 | SpecializedTemplate->getTemplatedDecl()->hasExternalLexicalStorage()); |
1005 | |
1006 | Context.getTypeDeclType(Decl: Result, PrevDecl); |
1007 | return Result; |
1008 | } |
1009 | |
1010 | ClassTemplateSpecializationDecl * |
1011 | ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C, |
1012 | GlobalDeclID ID) { |
1013 | auto *Result = |
1014 | new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization); |
1015 | Result->setMayHaveOutOfDateDef(false); |
1016 | return Result; |
1017 | } |
1018 | |
1019 | void ClassTemplateSpecializationDecl::getNameForDiagnostic( |
1020 | raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const { |
1021 | NamedDecl::getNameForDiagnostic(OS, Policy, Qualified); |
1022 | |
1023 | const auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(Val: this); |
1024 | if (const ASTTemplateArgumentListInfo *ArgsAsWritten = |
1025 | PS ? PS->getTemplateArgsAsWritten() : nullptr) { |
1026 | printTemplateArgumentList( |
1027 | OS, ArgsAsWritten->arguments(), Policy, |
1028 | getSpecializedTemplate()->getTemplateParameters()); |
1029 | } else { |
1030 | const TemplateArgumentList &TemplateArgs = getTemplateArgs(); |
1031 | printTemplateArgumentList( |
1032 | OS, TemplateArgs.asArray(), Policy, |
1033 | getSpecializedTemplate()->getTemplateParameters()); |
1034 | } |
1035 | } |
1036 | |
1037 | ClassTemplateDecl * |
1038 | ClassTemplateSpecializationDecl::getSpecializedTemplate() const { |
1039 | if (const auto *PartialSpec = |
1040 | SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>()) |
1041 | return PartialSpec->PartialSpecialization->getSpecializedTemplate(); |
1042 | return cast<ClassTemplateDecl *>(Val: SpecializedTemplate); |
1043 | } |
1044 | |
1045 | SourceRange |
1046 | ClassTemplateSpecializationDecl::getSourceRange() const { |
1047 | switch (getSpecializationKind()) { |
1048 | case TSK_Undeclared: |
1049 | case TSK_ImplicitInstantiation: { |
1050 | llvm::PointerUnion<ClassTemplateDecl *, |
1051 | ClassTemplatePartialSpecializationDecl *> |
1052 | Pattern = getSpecializedTemplateOrPartial(); |
1053 | assert(!Pattern.isNull() && |
1054 | "Class template specialization without pattern?"); |
1055 | if (const auto *CTPSD = |
1056 | dyn_cast<ClassTemplatePartialSpecializationDecl *>(Val&: Pattern)) |
1057 | return CTPSD->getSourceRange(); |
1058 | return cast<ClassTemplateDecl *>(Val&: Pattern)->getSourceRange(); |
1059 | } |
1060 | case TSK_ExplicitSpecialization: { |
1061 | SourceRange Range = CXXRecordDecl::getSourceRange(); |
1062 | if (const ASTTemplateArgumentListInfo *Args = getTemplateArgsAsWritten(); |
1063 | !isThisDeclarationADefinition() && Args) |
1064 | Range.setEnd(Args->getRAngleLoc()); |
1065 | return Range; |
1066 | } |
1067 | case TSK_ExplicitInstantiationDeclaration: |
1068 | case TSK_ExplicitInstantiationDefinition: { |
1069 | SourceRange Range = CXXRecordDecl::getSourceRange(); |
1070 | if (SourceLocation ExternKW = getExternKeywordLoc(); ExternKW.isValid()) |
1071 | Range.setBegin(ExternKW); |
1072 | else if (SourceLocation TemplateKW = getTemplateKeywordLoc(); |
1073 | TemplateKW.isValid()) |
1074 | Range.setBegin(TemplateKW); |
1075 | if (const ASTTemplateArgumentListInfo *Args = getTemplateArgsAsWritten()) |
1076 | Range.setEnd(Args->getRAngleLoc()); |
1077 | return Range; |
1078 | } |
1079 | } |
1080 | llvm_unreachable("unhandled template specialization kind"); |
1081 | } |
1082 | |
1083 | void ClassTemplateSpecializationDecl::setExternKeywordLoc(SourceLocation Loc) { |
1084 | auto *Info = dyn_cast_if_present<ExplicitInstantiationInfo *>(Val&: ExplicitInfo); |
1085 | if (!Info) { |
1086 | // Don't allocate if the location is invalid. |
1087 | if (Loc.isInvalid()) |
1088 | return; |
1089 | Info = new (getASTContext()) ExplicitInstantiationInfo; |
1090 | Info->TemplateArgsAsWritten = getTemplateArgsAsWritten(); |
1091 | ExplicitInfo = Info; |
1092 | } |
1093 | Info->ExternKeywordLoc = Loc; |
1094 | } |
1095 | |
1096 | void ClassTemplateSpecializationDecl::setTemplateKeywordLoc( |
1097 | SourceLocation Loc) { |
1098 | auto *Info = dyn_cast_if_present<ExplicitInstantiationInfo *>(Val&: ExplicitInfo); |
1099 | if (!Info) { |
1100 | // Don't allocate if the location is invalid. |
1101 | if (Loc.isInvalid()) |
1102 | return; |
1103 | Info = new (getASTContext()) ExplicitInstantiationInfo; |
1104 | Info->TemplateArgsAsWritten = getTemplateArgsAsWritten(); |
1105 | ExplicitInfo = Info; |
1106 | } |
1107 | Info->TemplateKeywordLoc = Loc; |
1108 | } |
1109 | |
1110 | //===----------------------------------------------------------------------===// |
1111 | // ConceptDecl Implementation |
1112 | //===----------------------------------------------------------------------===// |
1113 | ConceptDecl *ConceptDecl::Create(ASTContext &C, DeclContext *DC, |
1114 | SourceLocation L, DeclarationName Name, |
1115 | TemplateParameterList *Params, |
1116 | Expr *ConstraintExpr) { |
1117 | bool Invalid = AdoptTemplateParameterList(Params, Owner: DC); |
1118 | auto *TD = new (C, DC) ConceptDecl(DC, L, Name, Params, ConstraintExpr); |
1119 | if (Invalid) |
1120 | TD->setInvalidDecl(); |
1121 | return TD; |
1122 | } |
1123 | |
1124 | ConceptDecl *ConceptDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { |
1125 | ConceptDecl *Result = new (C, ID) ConceptDecl(nullptr, SourceLocation(), |
1126 | DeclarationName(), |
1127 | nullptr, nullptr); |
1128 | |
1129 | return Result; |
1130 | } |
1131 | |
1132 | //===----------------------------------------------------------------------===// |
1133 | // ImplicitConceptSpecializationDecl Implementation |
1134 | //===----------------------------------------------------------------------===// |
1135 | ImplicitConceptSpecializationDecl::ImplicitConceptSpecializationDecl( |
1136 | DeclContext *DC, SourceLocation SL, |
1137 | ArrayRef<TemplateArgument> ConvertedArgs) |
1138 | : Decl(ImplicitConceptSpecialization, DC, SL), |
1139 | NumTemplateArgs(ConvertedArgs.size()) { |
1140 | setTemplateArguments(ConvertedArgs); |
1141 | } |
1142 | |
1143 | ImplicitConceptSpecializationDecl::ImplicitConceptSpecializationDecl( |
1144 | EmptyShell Empty, unsigned NumTemplateArgs) |
1145 | : Decl(ImplicitConceptSpecialization, Empty), |
1146 | NumTemplateArgs(NumTemplateArgs) {} |
1147 | |
1148 | ImplicitConceptSpecializationDecl *ImplicitConceptSpecializationDecl::Create( |
1149 | const ASTContext &C, DeclContext *DC, SourceLocation SL, |
1150 | ArrayRef<TemplateArgument> ConvertedArgs) { |
1151 | return new (C, DC, |
1152 | additionalSizeToAlloc<TemplateArgument>(Counts: ConvertedArgs.size())) |
1153 | ImplicitConceptSpecializationDecl(DC, SL, ConvertedArgs); |
1154 | } |
1155 | |
1156 | ImplicitConceptSpecializationDecl * |
1157 | ImplicitConceptSpecializationDecl::CreateDeserialized( |
1158 | const ASTContext &C, GlobalDeclID ID, unsigned NumTemplateArgs) { |
1159 | return new (C, ID, additionalSizeToAlloc<TemplateArgument>(Counts: NumTemplateArgs)) |
1160 | ImplicitConceptSpecializationDecl(EmptyShell{}, NumTemplateArgs); |
1161 | } |
1162 | |
1163 | void ImplicitConceptSpecializationDecl::setTemplateArguments( |
1164 | ArrayRef<TemplateArgument> Converted) { |
1165 | assert(Converted.size() == NumTemplateArgs); |
1166 | llvm::uninitialized_copy(Converted, getTrailingObjects()); |
1167 | } |
1168 | |
1169 | //===----------------------------------------------------------------------===// |
1170 | // ClassTemplatePartialSpecializationDecl Implementation |
1171 | //===----------------------------------------------------------------------===// |
1172 | void ClassTemplatePartialSpecializationDecl::anchor() {} |
1173 | |
1174 | ClassTemplatePartialSpecializationDecl::ClassTemplatePartialSpecializationDecl( |
1175 | ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, |
1176 | SourceLocation IdLoc, TemplateParameterList *Params, |
1177 | ClassTemplateDecl *SpecializedTemplate, ArrayRef<TemplateArgument> Args, |
1178 | ClassTemplatePartialSpecializationDecl *PrevDecl) |
1179 | : ClassTemplateSpecializationDecl( |
1180 | Context, ClassTemplatePartialSpecialization, TK, DC, StartLoc, IdLoc, |
1181 | // Tracking StrictPackMatch for Partial |
1182 | // Specializations is not needed. |
1183 | SpecializedTemplate, Args, /*StrictPackMatch=*/false, PrevDecl), |
1184 | TemplateParams(Params), InstantiatedFromMember(nullptr, false) { |
1185 | if (AdoptTemplateParameterList(Params, this)) |
1186 | setInvalidDecl(); |
1187 | } |
1188 | |
1189 | ClassTemplatePartialSpecializationDecl * |
1190 | ClassTemplatePartialSpecializationDecl::Create( |
1191 | ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, |
1192 | SourceLocation IdLoc, TemplateParameterList *Params, |
1193 | ClassTemplateDecl *SpecializedTemplate, ArrayRef<TemplateArgument> Args, |
1194 | QualType CanonInjectedType, |
1195 | ClassTemplatePartialSpecializationDecl *PrevDecl) { |
1196 | auto *Result = new (Context, DC) ClassTemplatePartialSpecializationDecl( |
1197 | Context, TK, DC, StartLoc, IdLoc, Params, SpecializedTemplate, Args, |
1198 | PrevDecl); |
1199 | Result->setSpecializationKind(TSK_ExplicitSpecialization); |
1200 | Result->setMayHaveOutOfDateDef(false); |
1201 | |
1202 | Context.getInjectedClassNameType(Result, CanonInjectedType); |
1203 | return Result; |
1204 | } |
1205 | |
1206 | ClassTemplatePartialSpecializationDecl * |
1207 | ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C, |
1208 | GlobalDeclID ID) { |
1209 | auto *Result = new (C, ID) ClassTemplatePartialSpecializationDecl(C); |
1210 | Result->setMayHaveOutOfDateDef(false); |
1211 | return Result; |
1212 | } |
1213 | |
1214 | SourceRange ClassTemplatePartialSpecializationDecl::getSourceRange() const { |
1215 | if (const ClassTemplatePartialSpecializationDecl *MT = |
1216 | getInstantiatedFromMember(); |
1217 | MT && !isMemberSpecialization()) |
1218 | return MT->getSourceRange(); |
1219 | SourceRange Range = ClassTemplateSpecializationDecl::getSourceRange(); |
1220 | if (const TemplateParameterList *TPL = getTemplateParameters(); |
1221 | TPL && !getNumTemplateParameterLists()) |
1222 | Range.setBegin(TPL->getTemplateLoc()); |
1223 | return Range; |
1224 | } |
1225 | |
1226 | //===----------------------------------------------------------------------===// |
1227 | // FriendTemplateDecl Implementation |
1228 | //===----------------------------------------------------------------------===// |
1229 | |
1230 | void FriendTemplateDecl::anchor() {} |
1231 | |
1232 | FriendTemplateDecl * |
1233 | FriendTemplateDecl::Create(ASTContext &Context, DeclContext *DC, |
1234 | SourceLocation L, |
1235 | MutableArrayRef<TemplateParameterList *> Params, |
1236 | FriendUnion Friend, SourceLocation FLoc) { |
1237 | TemplateParameterList **TPL = nullptr; |
1238 | if (!Params.empty()) { |
1239 | TPL = new (Context) TemplateParameterList *[Params.size()]; |
1240 | llvm::copy(Range&: Params, Out: TPL); |
1241 | } |
1242 | return new (Context, DC) |
1243 | FriendTemplateDecl(DC, L, TPL, Params.size(), Friend, FLoc); |
1244 | } |
1245 | |
1246 | FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C, |
1247 | GlobalDeclID ID) { |
1248 | return new (C, ID) FriendTemplateDecl(EmptyShell()); |
1249 | } |
1250 | |
1251 | //===----------------------------------------------------------------------===// |
1252 | // TypeAliasTemplateDecl Implementation |
1253 | //===----------------------------------------------------------------------===// |
1254 | |
1255 | TypeAliasTemplateDecl * |
1256 | TypeAliasTemplateDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L, |
1257 | DeclarationName Name, |
1258 | TemplateParameterList *Params, NamedDecl *Decl) { |
1259 | bool Invalid = AdoptTemplateParameterList(Params, Owner: DC); |
1260 | auto *TD = new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl); |
1261 | if (Invalid) |
1262 | TD->setInvalidDecl(); |
1263 | return TD; |
1264 | } |
1265 | |
1266 | TypeAliasTemplateDecl * |
1267 | TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { |
1268 | return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(), |
1269 | DeclarationName(), nullptr, nullptr); |
1270 | } |
1271 | |
1272 | RedeclarableTemplateDecl::CommonBase * |
1273 | TypeAliasTemplateDecl::newCommon(ASTContext &C) const { |
1274 | auto *CommonPtr = new (C) Common; |
1275 | C.addDestruction(Ptr: CommonPtr); |
1276 | return CommonPtr; |
1277 | } |
1278 | |
1279 | //===----------------------------------------------------------------------===// |
1280 | // VarTemplateDecl Implementation |
1281 | //===----------------------------------------------------------------------===// |
1282 | |
1283 | VarTemplateDecl *VarTemplateDecl::getDefinition() { |
1284 | VarTemplateDecl *CurD = this; |
1285 | while (CurD) { |
1286 | if (CurD->isThisDeclarationADefinition()) |
1287 | return CurD; |
1288 | CurD = CurD->getPreviousDecl(); |
1289 | } |
1290 | return nullptr; |
1291 | } |
1292 | |
1293 | VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC, |
1294 | SourceLocation L, DeclarationName Name, |
1295 | TemplateParameterList *Params, |
1296 | VarDecl *Decl) { |
1297 | bool Invalid = AdoptTemplateParameterList(Params, Owner: DC); |
1298 | auto *TD = new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl); |
1299 | if (Invalid) |
1300 | TD->setInvalidDecl(); |
1301 | return TD; |
1302 | } |
1303 | |
1304 | VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C, |
1305 | GlobalDeclID ID) { |
1306 | return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(), |
1307 | DeclarationName(), nullptr, nullptr); |
1308 | } |
1309 | |
1310 | void VarTemplateDecl::LoadLazySpecializations( |
1311 | bool OnlyPartial /*=false*/) const { |
1312 | loadLazySpecializationsImpl(OnlyPartial); |
1313 | } |
1314 | |
1315 | llvm::FoldingSetVector<VarTemplateSpecializationDecl> & |
1316 | VarTemplateDecl::getSpecializations() const { |
1317 | LoadLazySpecializations(); |
1318 | return getCommonPtr()->Specializations; |
1319 | } |
1320 | |
1321 | llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> & |
1322 | VarTemplateDecl::getPartialSpecializations() const { |
1323 | LoadLazySpecializations(/*PartialOnly = */ OnlyPartial: true); |
1324 | return getCommonPtr()->PartialSpecializations; |
1325 | } |
1326 | |
1327 | RedeclarableTemplateDecl::CommonBase * |
1328 | VarTemplateDecl::newCommon(ASTContext &C) const { |
1329 | auto *CommonPtr = new (C) Common; |
1330 | C.addDestruction(Ptr: CommonPtr); |
1331 | return CommonPtr; |
1332 | } |
1333 | |
1334 | VarTemplateSpecializationDecl * |
1335 | VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args, |
1336 | void *&InsertPos) { |
1337 | auto *Common = getCommonPtr(); |
1338 | return findSpecializationImpl(Common->Specializations, InsertPos, Args); |
1339 | } |
1340 | |
1341 | void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D, |
1342 | void *InsertPos) { |
1343 | auto *Common = getCommonPtr(); |
1344 | addSpecializationImpl<VarTemplateDecl>(Common->Specializations, D, InsertPos); |
1345 | } |
1346 | |
1347 | VarTemplatePartialSpecializationDecl * |
1348 | VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args, |
1349 | TemplateParameterList *TPL, void *&InsertPos) { |
1350 | return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args, |
1351 | TPL); |
1352 | } |
1353 | |
1354 | void VarTemplatePartialSpecializationDecl::Profile( |
1355 | llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs, |
1356 | TemplateParameterList *TPL, const ASTContext &Context) { |
1357 | ID.AddInteger(I: TemplateArgs.size()); |
1358 | for (const TemplateArgument &TemplateArg : TemplateArgs) |
1359 | TemplateArg.Profile(ID, Context); |
1360 | TPL->Profile(ID, C: Context); |
1361 | } |
1362 | |
1363 | void VarTemplateDecl::AddPartialSpecialization( |
1364 | VarTemplatePartialSpecializationDecl *D, void *InsertPos) { |
1365 | if (InsertPos) |
1366 | getPartialSpecializations().InsertNode(N: D, InsertPos); |
1367 | else { |
1368 | VarTemplatePartialSpecializationDecl *Existing = |
1369 | getPartialSpecializations().GetOrInsertNode(N: D); |
1370 | (void)Existing; |
1371 | assert(Existing->isCanonicalDecl() && "Non-canonical specialization?"); |
1372 | } |
1373 | |
1374 | if (ASTMutationListener *L = getASTMutationListener()) |
1375 | L->AddedCXXTemplateSpecialization(this, D); |
1376 | } |
1377 | |
1378 | void VarTemplateDecl::getPartialSpecializations( |
1379 | SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) const { |
1380 | llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs = |
1381 | getPartialSpecializations(); |
1382 | PS.clear(); |
1383 | PS.reserve(N: PartialSpecs.size()); |
1384 | for (VarTemplatePartialSpecializationDecl &P : PartialSpecs) |
1385 | PS.push_back(Elt: P.getMostRecentDecl()); |
1386 | } |
1387 | |
1388 | VarTemplatePartialSpecializationDecl * |
1389 | VarTemplateDecl::findPartialSpecInstantiatedFromMember( |
1390 | VarTemplatePartialSpecializationDecl *D) { |
1391 | Decl *DCanon = D->getCanonicalDecl(); |
1392 | for (VarTemplatePartialSpecializationDecl &P : getPartialSpecializations()) { |
1393 | if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon) |
1394 | return P.getMostRecentDecl(); |
1395 | } |
1396 | |
1397 | return nullptr; |
1398 | } |
1399 | |
1400 | //===----------------------------------------------------------------------===// |
1401 | // VarTemplateSpecializationDecl Implementation |
1402 | //===----------------------------------------------------------------------===// |
1403 | |
1404 | VarTemplateSpecializationDecl::VarTemplateSpecializationDecl( |
1405 | Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, |
1406 | SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, |
1407 | TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) |
1408 | : VarDecl(DK, Context, DC, StartLoc, IdLoc, |
1409 | SpecializedTemplate->getIdentifier(), T, TInfo, S), |
1410 | SpecializedTemplate(SpecializedTemplate), |
1411 | TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)), |
1412 | SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {} |
1413 | |
1414 | VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(Kind DK, |
1415 | ASTContext &C) |
1416 | : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr, |
1417 | QualType(), nullptr, SC_None), |
1418 | SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {} |
1419 | |
1420 | VarTemplateSpecializationDecl *VarTemplateSpecializationDecl::Create( |
1421 | ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, |
1422 | SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, |
1423 | TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) { |
1424 | return new (Context, DC) VarTemplateSpecializationDecl( |
1425 | VarTemplateSpecialization, Context, DC, StartLoc, IdLoc, |
1426 | SpecializedTemplate, T, TInfo, S, Args); |
1427 | } |
1428 | |
1429 | VarTemplateSpecializationDecl * |
1430 | VarTemplateSpecializationDecl::CreateDeserialized(ASTContext &C, |
1431 | GlobalDeclID ID) { |
1432 | return new (C, ID) |
1433 | VarTemplateSpecializationDecl(VarTemplateSpecialization, C); |
1434 | } |
1435 | |
1436 | void VarTemplateSpecializationDecl::getNameForDiagnostic( |
1437 | raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const { |
1438 | NamedDecl::getNameForDiagnostic(OS, Policy, Qualified); |
1439 | |
1440 | const auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(Val: this); |
1441 | if (const ASTTemplateArgumentListInfo *ArgsAsWritten = |
1442 | PS ? PS->getTemplateArgsAsWritten() : nullptr) { |
1443 | printTemplateArgumentList( |
1444 | OS, ArgsAsWritten->arguments(), Policy, |
1445 | getSpecializedTemplate()->getTemplateParameters()); |
1446 | } else { |
1447 | const TemplateArgumentList &TemplateArgs = getTemplateArgs(); |
1448 | printTemplateArgumentList( |
1449 | OS, TemplateArgs.asArray(), Policy, |
1450 | getSpecializedTemplate()->getTemplateParameters()); |
1451 | } |
1452 | } |
1453 | |
1454 | VarTemplateDecl *VarTemplateSpecializationDecl::getSpecializedTemplate() const { |
1455 | if (const auto *PartialSpec = |
1456 | SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>()) |
1457 | return PartialSpec->PartialSpecialization->getSpecializedTemplate(); |
1458 | return cast<VarTemplateDecl *>(Val: SpecializedTemplate); |
1459 | } |
1460 | |
1461 | SourceRange VarTemplateSpecializationDecl::getSourceRange() const { |
1462 | switch (getSpecializationKind()) { |
1463 | case TSK_Undeclared: |
1464 | case TSK_ImplicitInstantiation: { |
1465 | llvm::PointerUnion<VarTemplateDecl *, |
1466 | VarTemplatePartialSpecializationDecl *> |
1467 | Pattern = getSpecializedTemplateOrPartial(); |
1468 | assert(!Pattern.isNull() && |
1469 | "Variable template specialization without pattern?"); |
1470 | if (const auto *VTPSD = |
1471 | dyn_cast<VarTemplatePartialSpecializationDecl *>(Val&: Pattern)) |
1472 | return VTPSD->getSourceRange(); |
1473 | VarTemplateDecl *VTD = cast<VarTemplateDecl *>(Val&: Pattern); |
1474 | if (hasInit()) { |
1475 | if (VarTemplateDecl *Definition = VTD->getDefinition()) |
1476 | return Definition->getSourceRange(); |
1477 | } |
1478 | return VTD->getCanonicalDecl()->getSourceRange(); |
1479 | } |
1480 | case TSK_ExplicitSpecialization: { |
1481 | SourceRange Range = VarDecl::getSourceRange(); |
1482 | if (const ASTTemplateArgumentListInfo *Args = getTemplateArgsAsWritten(); |
1483 | !hasInit() && Args) |
1484 | Range.setEnd(Args->getRAngleLoc()); |
1485 | return Range; |
1486 | } |
1487 | case TSK_ExplicitInstantiationDeclaration: |
1488 | case TSK_ExplicitInstantiationDefinition: { |
1489 | SourceRange Range = VarDecl::getSourceRange(); |
1490 | if (SourceLocation ExternKW = getExternKeywordLoc(); ExternKW.isValid()) |
1491 | Range.setBegin(ExternKW); |
1492 | else if (SourceLocation TemplateKW = getTemplateKeywordLoc(); |
1493 | TemplateKW.isValid()) |
1494 | Range.setBegin(TemplateKW); |
1495 | if (const ASTTemplateArgumentListInfo *Args = getTemplateArgsAsWritten()) |
1496 | Range.setEnd(Args->getRAngleLoc()); |
1497 | return Range; |
1498 | } |
1499 | } |
1500 | llvm_unreachable("unhandled template specialization kind"); |
1501 | } |
1502 | |
1503 | void VarTemplateSpecializationDecl::setExternKeywordLoc(SourceLocation Loc) { |
1504 | auto *Info = dyn_cast_if_present<ExplicitInstantiationInfo *>(Val&: ExplicitInfo); |
1505 | if (!Info) { |
1506 | // Don't allocate if the location is invalid. |
1507 | if (Loc.isInvalid()) |
1508 | return; |
1509 | Info = new (getASTContext()) ExplicitInstantiationInfo; |
1510 | Info->TemplateArgsAsWritten = getTemplateArgsAsWritten(); |
1511 | ExplicitInfo = Info; |
1512 | } |
1513 | Info->ExternKeywordLoc = Loc; |
1514 | } |
1515 | |
1516 | void VarTemplateSpecializationDecl::setTemplateKeywordLoc(SourceLocation Loc) { |
1517 | auto *Info = dyn_cast_if_present<ExplicitInstantiationInfo *>(Val&: ExplicitInfo); |
1518 | if (!Info) { |
1519 | // Don't allocate if the location is invalid. |
1520 | if (Loc.isInvalid()) |
1521 | return; |
1522 | Info = new (getASTContext()) ExplicitInstantiationInfo; |
1523 | Info->TemplateArgsAsWritten = getTemplateArgsAsWritten(); |
1524 | ExplicitInfo = Info; |
1525 | } |
1526 | Info->TemplateKeywordLoc = Loc; |
1527 | } |
1528 | |
1529 | //===----------------------------------------------------------------------===// |
1530 | // VarTemplatePartialSpecializationDecl Implementation |
1531 | //===----------------------------------------------------------------------===// |
1532 | |
1533 | void VarTemplatePartialSpecializationDecl::anchor() {} |
1534 | |
1535 | VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl( |
1536 | ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, |
1537 | SourceLocation IdLoc, TemplateParameterList *Params, |
1538 | VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, |
1539 | StorageClass S, ArrayRef<TemplateArgument> Args) |
1540 | : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context, |
1541 | DC, StartLoc, IdLoc, SpecializedTemplate, T, |
1542 | TInfo, S, Args), |
1543 | TemplateParams(Params), InstantiatedFromMember(nullptr, false) { |
1544 | if (AdoptTemplateParameterList(Params, Owner: DC)) |
1545 | setInvalidDecl(); |
1546 | } |
1547 | |
1548 | VarTemplatePartialSpecializationDecl * |
1549 | VarTemplatePartialSpecializationDecl::Create( |
1550 | ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, |
1551 | SourceLocation IdLoc, TemplateParameterList *Params, |
1552 | VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, |
1553 | StorageClass S, ArrayRef<TemplateArgument> Args) { |
1554 | auto *Result = new (Context, DC) VarTemplatePartialSpecializationDecl( |
1555 | Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo, S, |
1556 | Args); |
1557 | Result->setSpecializationKind(TSK_ExplicitSpecialization); |
1558 | return Result; |
1559 | } |
1560 | |
1561 | VarTemplatePartialSpecializationDecl * |
1562 | VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C, |
1563 | GlobalDeclID ID) { |
1564 | return new (C, ID) VarTemplatePartialSpecializationDecl(C); |
1565 | } |
1566 | |
1567 | SourceRange VarTemplatePartialSpecializationDecl::getSourceRange() const { |
1568 | if (const VarTemplatePartialSpecializationDecl *MT = |
1569 | getInstantiatedFromMember(); |
1570 | MT && !isMemberSpecialization()) |
1571 | return MT->getSourceRange(); |
1572 | SourceRange Range = VarTemplateSpecializationDecl::getSourceRange(); |
1573 | if (const TemplateParameterList *TPL = getTemplateParameters(); |
1574 | TPL && !getNumTemplateParameterLists()) |
1575 | Range.setBegin(TPL->getTemplateLoc()); |
1576 | return Range; |
1577 | } |
1578 | |
1579 | static TemplateParameterList *createBuiltinTemplateParameterList( |
1580 | const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) { |
1581 | switch (BTK) { |
1582 | #define CREATE_BUILTIN_TEMPLATE_PARAMETER_LIST |
1583 | #include "clang/Basic/BuiltinTemplates.inc" |
1584 | } |
1585 | |
1586 | llvm_unreachable("unhandled BuiltinTemplateKind!"); |
1587 | } |
1588 | |
1589 | void BuiltinTemplateDecl::anchor() {} |
1590 | |
1591 | BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC, |
1592 | DeclarationName Name, |
1593 | BuiltinTemplateKind BTK) |
1594 | : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name, |
1595 | createBuiltinTemplateParameterList(C, DC, BTK)), |
1596 | BTK(BTK) {} |
1597 | |
1598 | TemplateParamObjectDecl *TemplateParamObjectDecl::Create(const ASTContext &C, |
1599 | QualType T, |
1600 | const APValue &V) { |
1601 | DeclContext *DC = C.getTranslationUnitDecl(); |
1602 | auto *TPOD = new (C, DC) TemplateParamObjectDecl(DC, T, V); |
1603 | C.addDestruction(&TPOD->Value); |
1604 | return TPOD; |
1605 | } |
1606 | |
1607 | TemplateParamObjectDecl * |
1608 | TemplateParamObjectDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { |
1609 | auto *TPOD = new (C, ID) TemplateParamObjectDecl(nullptr, QualType(), APValue()); |
1610 | C.addDestruction(Ptr: &TPOD->Value); |
1611 | return TPOD; |
1612 | } |
1613 | |
1614 | void TemplateParamObjectDecl::printName(llvm::raw_ostream &OS, |
1615 | const PrintingPolicy &Policy) const { |
1616 | OS << "<template param "; |
1617 | printAsExpr(OS, Policy); |
1618 | OS << ">"; |
1619 | } |
1620 | |
1621 | void TemplateParamObjectDecl::printAsExpr(llvm::raw_ostream &OS) const { |
1622 | printAsExpr(OS, getASTContext().getPrintingPolicy()); |
1623 | } |
1624 | |
1625 | void TemplateParamObjectDecl::printAsExpr(llvm::raw_ostream &OS, |
1626 | const PrintingPolicy &Policy) const { |
1627 | getType().getUnqualifiedType().print(OS, Policy); |
1628 | printAsInit(OS, Policy); |
1629 | } |
1630 | |
1631 | void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS) const { |
1632 | printAsInit(OS, getASTContext().getPrintingPolicy()); |
1633 | } |
1634 | |
1635 | void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS, |
1636 | const PrintingPolicy &Policy) const { |
1637 | getValue().printPretty(OS, Policy, getType(), &getASTContext()); |
1638 | } |
1639 | |
1640 | TemplateParameterList *clang::getReplacedTemplateParameterList(const Decl *D) { |
1641 | switch (D->getKind()) { |
1642 | case Decl::Kind::CXXRecord: |
1643 | return cast<CXXRecordDecl>(Val: D) |
1644 | ->getDescribedTemplate() |
1645 | ->getTemplateParameters(); |
1646 | case Decl::Kind::ClassTemplate: |
1647 | return cast<ClassTemplateDecl>(Val: D)->getTemplateParameters(); |
1648 | case Decl::Kind::ClassTemplateSpecialization: { |
1649 | const auto *CTSD = cast<ClassTemplateSpecializationDecl>(Val: D); |
1650 | auto P = CTSD->getSpecializedTemplateOrPartial(); |
1651 | if (const auto *CTPSD = |
1652 | dyn_cast<ClassTemplatePartialSpecializationDecl *>(Val&: P)) |
1653 | return CTPSD->getTemplateParameters(); |
1654 | return cast<ClassTemplateDecl *>(Val&: P)->getTemplateParameters(); |
1655 | } |
1656 | case Decl::Kind::ClassTemplatePartialSpecialization: |
1657 | return cast<ClassTemplatePartialSpecializationDecl>(Val: D) |
1658 | ->getTemplateParameters(); |
1659 | case Decl::Kind::TypeAliasTemplate: |
1660 | return cast<TypeAliasTemplateDecl>(Val: D)->getTemplateParameters(); |
1661 | case Decl::Kind::BuiltinTemplate: |
1662 | return cast<BuiltinTemplateDecl>(Val: D)->getTemplateParameters(); |
1663 | case Decl::Kind::CXXDeductionGuide: |
1664 | case Decl::Kind::CXXConversion: |
1665 | case Decl::Kind::CXXConstructor: |
1666 | case Decl::Kind::CXXDestructor: |
1667 | case Decl::Kind::CXXMethod: |
1668 | case Decl::Kind::Function: |
1669 | return cast<FunctionDecl>(Val: D) |
1670 | ->getTemplateSpecializationInfo() |
1671 | ->getTemplate() |
1672 | ->getTemplateParameters(); |
1673 | case Decl::Kind::FunctionTemplate: |
1674 | return cast<FunctionTemplateDecl>(Val: D)->getTemplateParameters(); |
1675 | case Decl::Kind::VarTemplate: |
1676 | return cast<VarTemplateDecl>(Val: D)->getTemplateParameters(); |
1677 | case Decl::Kind::VarTemplateSpecialization: { |
1678 | const auto *VTSD = cast<VarTemplateSpecializationDecl>(Val: D); |
1679 | auto P = VTSD->getSpecializedTemplateOrPartial(); |
1680 | if (const auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl *>(Val&: P)) |
1681 | return VTPSD->getTemplateParameters(); |
1682 | return cast<VarTemplateDecl *>(Val&: P)->getTemplateParameters(); |
1683 | } |
1684 | case Decl::Kind::VarTemplatePartialSpecialization: |
1685 | return cast<VarTemplatePartialSpecializationDecl>(Val: D) |
1686 | ->getTemplateParameters(); |
1687 | case Decl::Kind::TemplateTemplateParm: |
1688 | return cast<TemplateTemplateParmDecl>(Val: D)->getTemplateParameters(); |
1689 | case Decl::Kind::Concept: |
1690 | return cast<ConceptDecl>(Val: D)->getTemplateParameters(); |
1691 | default: |
1692 | llvm_unreachable("Unhandled templated declaration kind"); |
1693 | } |
1694 | } |
1695 |
Definitions
- DefaultTemplateArgumentContainsUnexpandedPack
- TemplateParameterList
- containsUnexpandedParameterPack
- Create
- Profile
- getMinRequiredArguments
- getDepth
- AdoptTemplateParameterList
- getAssociatedConstraints
- hasAssociatedConstraints
- getInjectedTemplateArgs
- shouldIncludeTypeForArgument
- allocateDefaultArgStorageChain
- TemplateDecl
- anchor
- getAssociatedConstraints
- hasAssociatedConstraints
- isTypeAlias
- anchor
- getCommonPtr
- loadLazySpecializationsImpl
- loadLazySpecializationsImpl
- findSpecializationLocally
- findSpecializationImpl
- addSpecializationImpl
- Create
- CreateDeserialized
- newCommon
- LoadLazySpecializations
- getSpecializations
- findSpecialization
- addSpecialization
- mergePrevDecl
- Create
- CreateDeserialized
- LoadLazySpecializations
- getSpecializations
- getPartialSpecializations
- newCommon
- findSpecialization
- AddSpecialization
- findPartialSpecialization
- Profile
- AddPartialSpecialization
- getPartialSpecializations
- findPartialSpecialization
- findPartialSpecInstantiatedFromMember
- getInjectedClassNameSpecialization
- Create
- CreateDeserialized
- CreateDeserialized
- getDefaultArgumentLoc
- getSourceRange
- setDefaultArgument
- getDepth
- getIndex
- isParameterPack
- setTypeConstraint
- NonTypeTemplateParmDecl
- Create
- Create
- CreateDeserialized
- CreateDeserialized
- getSourceRange
- getDefaultArgumentLoc
- setDefaultArgument
- anchor
- TemplateTemplateParmDecl
- Create
- Create
- CreateDeserialized
- CreateDeserialized
- getDefaultArgumentLoc
- setDefaultArgument
- TemplateArgumentList
- CreateCopy
- Create
- ClassTemplateSpecializationDecl
- ClassTemplateSpecializationDecl
- Create
- CreateDeserialized
- getNameForDiagnostic
- getSpecializedTemplate
- getSourceRange
- setExternKeywordLoc
- setTemplateKeywordLoc
- Create
- CreateDeserialized
- ImplicitConceptSpecializationDecl
- ImplicitConceptSpecializationDecl
- Create
- CreateDeserialized
- setTemplateArguments
- anchor
- ClassTemplatePartialSpecializationDecl
- Create
- CreateDeserialized
- getSourceRange
- anchor
- Create
- CreateDeserialized
- Create
- CreateDeserialized
- newCommon
- getDefinition
- Create
- CreateDeserialized
- LoadLazySpecializations
- getSpecializations
- getPartialSpecializations
- newCommon
- findSpecialization
- AddSpecialization
- findPartialSpecialization
- Profile
- AddPartialSpecialization
- getPartialSpecializations
- findPartialSpecInstantiatedFromMember
- VarTemplateSpecializationDecl
- VarTemplateSpecializationDecl
- Create
- CreateDeserialized
- getNameForDiagnostic
- getSpecializedTemplate
- getSourceRange
- setExternKeywordLoc
- setTemplateKeywordLoc
- anchor
- VarTemplatePartialSpecializationDecl
- Create
- CreateDeserialized
- getSourceRange
- createBuiltinTemplateParameterList
- anchor
- BuiltinTemplateDecl
- Create
- CreateDeserialized
- printName
- printAsExpr
- printAsExpr
- printAsInit
- printAsInit
Update your C++ knowledge – Modern C++11/14/17 Training
Find out more