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
41using namespace clang;
42
43//===----------------------------------------------------------------------===//
44// TemplateParameterList Implementation
45//===----------------------------------------------------------------------===//
46
47
48TemplateParameterList::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
94bool 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
118TemplateParameterList *
119TemplateParameterList::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
130void 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
163unsigned 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
189unsigned 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
202static 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
218void TemplateParameterList::
219getAssociatedConstraints(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
234bool TemplateParameterList::hasAssociatedConstraints() const {
235 return HasRequiresClause || HasConstrainedParameters;
236}
237
238bool 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
251namespace clang {
252
253void *allocateDefaultArgStorageChain(const ASTContext &C) {
254 return new (C) char[sizeof(void*) * 2];
255}
256
257} // namespace clang
258
259//===----------------------------------------------------------------------===//
260// TemplateDecl Implementation
261//===----------------------------------------------------------------------===//
262
263TemplateDecl::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
268void TemplateDecl::anchor() {}
269
270void TemplateDecl::
271getAssociatedConstraints(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
278bool 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
286bool 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
300void RedeclarableTemplateDecl::anchor() {}
301
302RedeclarableTemplateDecl::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
334void 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
347template<class EntryType, typename... ProfileArguments>
348typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
349RedeclarableTemplateDecl::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
361template<class Derived, class EntryType>
362void 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
389ArrayRef<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
409FunctionTemplateDecl *
410FunctionTemplateDecl::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
420FunctionTemplateDecl *FunctionTemplateDecl::CreateDeserialized(ASTContext &C,
421 unsigned ID) {
422 return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(),
423 DeclarationName(), nullptr, nullptr);
424}
425
426RedeclarableTemplateDecl::CommonBase *
427FunctionTemplateDecl::newCommon(ASTContext &C) const {
428 auto *CommonPtr = new (C) Common;
429 C.addDestruction(Ptr: CommonPtr);
430 return CommonPtr;
431}
432
433void FunctionTemplateDecl::LoadLazySpecializations() const {
434 loadLazySpecializationsImpl();
435}
436
437llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
438FunctionTemplateDecl::getSpecializations() const {
439 LoadLazySpecializations();
440 return getCommonPtr()->Specializations;
441}
442
443FunctionDecl *
444FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
445 void *&InsertPos) {
446 return findSpecializationImpl(getSpecializations(), InsertPos, Args);
447}
448
449void FunctionTemplateDecl::addSpecialization(
450 FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
451 addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
452 InsertPos);
453}
454
455void 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
493ClassTemplateDecl *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
505ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
506 unsigned ID) {
507 return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
508 DeclarationName(), nullptr, nullptr);
509}
510
511void ClassTemplateDecl::LoadLazySpecializations() const {
512 loadLazySpecializationsImpl();
513}
514
515llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
516ClassTemplateDecl::getSpecializations() const {
517 LoadLazySpecializations();
518 return getCommonPtr()->Specializations;
519}
520
521llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
522ClassTemplateDecl::getPartialSpecializations() const {
523 LoadLazySpecializations();
524 return getCommonPtr()->PartialSpecializations;
525}
526
527RedeclarableTemplateDecl::CommonBase *
528ClassTemplateDecl::newCommon(ASTContext &C) const {
529 auto *CommonPtr = new (C) Common;
530 C.addDestruction(Ptr: CommonPtr);
531 return CommonPtr;
532}
533
534ClassTemplateSpecializationDecl *
535ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
536 void *&InsertPos) {
537 return findSpecializationImpl(getSpecializations(), InsertPos, Args);
538}
539
540void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
541 void *InsertPos) {
542 addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
543}
544
545ClassTemplatePartialSpecializationDecl *
546ClassTemplateDecl::findPartialSpecialization(
547 ArrayRef<TemplateArgument> Args,
548 TemplateParameterList *TPL, void *&InsertPos) {
549 return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
550 TPL);
551}
552
553void 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
562void 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
578void 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
588ClassTemplatePartialSpecializationDecl *
589ClassTemplateDecl::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
600ClassTemplatePartialSpecializationDecl *
601ClassTemplateDecl::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
612QualType
613ClassTemplateDecl::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
639TemplateTypeParmDecl *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
654TemplateTypeParmDecl *
655TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
656 return new (C, ID)
657 TemplateTypeParmDecl(nullptr, SourceLocation(), SourceLocation(), nullptr,
658 false, false, std::nullopt);
659}
660
661TemplateTypeParmDecl *
662TemplateTypeParmDecl::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
670SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
671 return hasDefaultArgument()
672 ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc()
673 : SourceLocation();
674}
675
676SourceRange 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
688unsigned TemplateTypeParmDecl::getDepth() const {
689 return getTypeForDecl()->castAs<TemplateTypeParmType>()->getDepth();
690}
691
692unsigned TemplateTypeParmDecl::getIndex() const {
693 return getTypeForDecl()->castAs<TemplateTypeParmType>()->getIndex();
694}
695
696bool TemplateTypeParmDecl::isParameterPack() const {
697 return getTypeForDecl()->castAs<TemplateTypeParmType>()->isParameterPack();
698}
699
700void 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
716NonTypeTemplateParmDecl::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
733NonTypeTemplateParmDecl *
734NonTypeTemplateParmDecl::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
749NonTypeTemplateParmDecl *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
763NonTypeTemplateParmDecl *
764NonTypeTemplateParmDecl::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
774NonTypeTemplateParmDecl *
775NonTypeTemplateParmDecl::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
789SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
790 if (hasDefaultArgument() && !defaultArgumentWasInherited())
791 return SourceRange(getOuterLocStart(),
792 getDefaultArgument()->getSourceRange().getEnd());
793 return DeclaratorDecl::getSourceRange();
794}
795
796SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
797 return hasDefaultArgument()
798 ? getDefaultArgument()->getSourceRange().getBegin()
799 : SourceLocation();
800}
801
802//===----------------------------------------------------------------------===//
803// TemplateTemplateParmDecl Method Implementations
804//===----------------------------------------------------------------------===//
805
806void TemplateTemplateParmDecl::anchor() {}
807
808TemplateTemplateParmDecl::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
820TemplateTemplateParmDecl *
821TemplateTemplateParmDecl::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
829TemplateTemplateParmDecl *
830TemplateTemplateParmDecl::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
840TemplateTemplateParmDecl *
841TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
842 return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
843 false, nullptr, nullptr);
844}
845
846TemplateTemplateParmDecl *
847TemplateTemplateParmDecl::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
857SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
858 return hasDefaultArgument() ? getDefaultArgument().getLocation()
859 : SourceLocation();
860}
861
862void 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//===----------------------------------------------------------------------===//
873TemplateArgumentList::TemplateArgumentList(ArrayRef<TemplateArgument> Args)
874 : NumArguments(Args.size()) {
875 std::uninitialized_copy(first: Args.begin(), last: Args.end(),
876 result: getTrailingObjects<TemplateArgument>());
877}
878
879TemplateArgumentList *
880TemplateArgumentList::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
886FunctionTemplateSpecializationInfo *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
906ClassTemplateSpecializationDecl::
907ClassTemplateSpecializationDecl(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
920ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
921 Kind DK)
922 : CXXRecordDecl(DK, TagTypeKind::Struct, C, nullptr, SourceLocation(),
923 SourceLocation(), nullptr, nullptr),
924 SpecializationKind(TSK_Undeclared) {}
925
926ClassTemplateSpecializationDecl *
927ClassTemplateSpecializationDecl::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
952ClassTemplateSpecializationDecl *
953ClassTemplateSpecializationDecl::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
961void 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
979ClassTemplateDecl *
980ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
981 if (const auto *PartialSpec =
982 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
983 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
984 return SpecializedTemplate.get<ClassTemplateDecl*>();
985}
986
987SourceRange
988ClassTemplateSpecializationDecl::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//===----------------------------------------------------------------------===//
1029ConceptDecl *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
1040ConceptDecl *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//===----------------------------------------------------------------------===//
1052ImplicitConceptSpecializationDecl::ImplicitConceptSpecializationDecl(
1053 DeclContext *DC, SourceLocation SL,
1054 ArrayRef<TemplateArgument> ConvertedArgs)
1055 : Decl(ImplicitConceptSpecialization, DC, SL),
1056 NumTemplateArgs(ConvertedArgs.size()) {
1057 setTemplateArguments(ConvertedArgs);
1058}
1059
1060ImplicitConceptSpecializationDecl::ImplicitConceptSpecializationDecl(
1061 EmptyShell Empty, unsigned NumTemplateArgs)
1062 : Decl(ImplicitConceptSpecialization, Empty),
1063 NumTemplateArgs(NumTemplateArgs) {}
1064
1065ImplicitConceptSpecializationDecl *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
1073ImplicitConceptSpecializationDecl *
1074ImplicitConceptSpecializationDecl::CreateDeserialized(
1075 const ASTContext &C, unsigned ID, unsigned NumTemplateArgs) {
1076 return new (C, ID, additionalSizeToAlloc<TemplateArgument>(Counts: NumTemplateArgs))
1077 ImplicitConceptSpecializationDecl(EmptyShell{}, NumTemplateArgs);
1078}
1079
1080void 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//===----------------------------------------------------------------------===//
1090void ClassTemplatePartialSpecializationDecl::anchor() {}
1091
1092ClassTemplatePartialSpecializationDecl::
1093ClassTemplatePartialSpecializationDecl(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
1112ClassTemplatePartialSpecializationDecl *
1113ClassTemplatePartialSpecializationDecl::
1114Create(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
1136ClassTemplatePartialSpecializationDecl *
1137ClassTemplatePartialSpecializationDecl::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
1148void FriendTemplateDecl::anchor() {}
1149
1150FriendTemplateDecl *
1151FriendTemplateDecl::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
1164FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
1165 unsigned ID) {
1166 return new (C, ID) FriendTemplateDecl(EmptyShell());
1167}
1168
1169//===----------------------------------------------------------------------===//
1170// TypeAliasTemplateDecl Implementation
1171//===----------------------------------------------------------------------===//
1172
1173TypeAliasTemplateDecl *
1174TypeAliasTemplateDecl::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
1184TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C,
1185 unsigned ID) {
1186 return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
1187 DeclarationName(), nullptr, nullptr);
1188}
1189
1190RedeclarableTemplateDecl::CommonBase *
1191TypeAliasTemplateDecl::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
1201VarTemplateDecl *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
1211VarTemplateDecl *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
1222VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C,
1223 unsigned ID) {
1224 return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
1225 DeclarationName(), nullptr, nullptr);
1226}
1227
1228void VarTemplateDecl::LoadLazySpecializations() const {
1229 loadLazySpecializationsImpl();
1230}
1231
1232llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
1233VarTemplateDecl::getSpecializations() const {
1234 LoadLazySpecializations();
1235 return getCommonPtr()->Specializations;
1236}
1237
1238llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
1239VarTemplateDecl::getPartialSpecializations() const {
1240 LoadLazySpecializations();
1241 return getCommonPtr()->PartialSpecializations;
1242}
1243
1244RedeclarableTemplateDecl::CommonBase *
1245VarTemplateDecl::newCommon(ASTContext &C) const {
1246 auto *CommonPtr = new (C) Common;
1247 C.addDestruction(Ptr: CommonPtr);
1248 return CommonPtr;
1249}
1250
1251VarTemplateSpecializationDecl *
1252VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
1253 void *&InsertPos) {
1254 return findSpecializationImpl(getSpecializations(), InsertPos, Args);
1255}
1256
1257void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D,
1258 void *InsertPos) {
1259 addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
1260}
1261
1262VarTemplatePartialSpecializationDecl *
1263VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
1264 TemplateParameterList *TPL, void *&InsertPos) {
1265 return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
1266 TPL);
1267}
1268
1269void 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
1278void 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
1293void 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
1303VarTemplatePartialSpecializationDecl *
1304VarTemplateDecl::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
1319VarTemplateSpecializationDecl::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
1329VarTemplateSpecializationDecl::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
1335VarTemplateSpecializationDecl *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
1344VarTemplateSpecializationDecl *
1345VarTemplateSpecializationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1346 return new (C, ID)
1347 VarTemplateSpecializationDecl(VarTemplateSpecialization, C);
1348}
1349
1350void 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
1368VarTemplateDecl *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
1375void VarTemplateSpecializationDecl::setTemplateArgsInfo(
1376 const TemplateArgumentListInfo &ArgsInfo) {
1377 TemplateArgsInfo =
1378 ASTTemplateArgumentListInfo::Create(getASTContext(), ArgsInfo);
1379}
1380
1381void VarTemplateSpecializationDecl::setTemplateArgsInfo(
1382 const ASTTemplateArgumentListInfo *ArgsInfo) {
1383 TemplateArgsInfo =
1384 ASTTemplateArgumentListInfo::Create(getASTContext(), ArgsInfo);
1385}
1386
1387SourceRange 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
1400void VarTemplatePartialSpecializationDecl::anchor() {}
1401
1402VarTemplatePartialSpecializationDecl::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
1417VarTemplatePartialSpecializationDecl *
1418VarTemplatePartialSpecializationDecl::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
1435VarTemplatePartialSpecializationDecl *
1436VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
1437 unsigned ID) {
1438 return new (C, ID) VarTemplatePartialSpecializationDecl(C);
1439}
1440
1441SourceRange 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
1449static TemplateParameterList *
1450createMakeIntegerSeqParameterList(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
1498static TemplateParameterList *
1499createTypePackElementParameterList(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
1520static 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
1532void BuiltinTemplateDecl::anchor() {}
1533
1534BuiltinTemplateDecl::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
1541TemplateParamObjectDecl *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
1550TemplateParamObjectDecl *
1551TemplateParamObjectDecl::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
1557void TemplateParamObjectDecl::printName(llvm::raw_ostream &OS,
1558 const PrintingPolicy &Policy) const {
1559 OS << "<template param ";
1560 printAsExpr(OS, Policy);
1561 OS << ">";
1562}
1563
1564void TemplateParamObjectDecl::printAsExpr(llvm::raw_ostream &OS) const {
1565 printAsExpr(OS, getASTContext().getPrintingPolicy());
1566}
1567
1568void TemplateParamObjectDecl::printAsExpr(llvm::raw_ostream &OS,
1569 const PrintingPolicy &Policy) const {
1570 getType().getUnqualifiedType().print(OS, Policy);
1571 printAsInit(OS, Policy);
1572}
1573
1574void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS) const {
1575 printAsInit(OS, getASTContext().getPrintingPolicy());
1576}
1577
1578void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS,
1579 const PrintingPolicy &Policy) const {
1580 getValue().printPretty(OS, Policy, getType(), &getASTContext());
1581}
1582
1583TemplateParameterList *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

source code of clang/lib/AST/DeclTemplate.cpp