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