1 //===--- DeclTemplate.cpp - Template Declaration AST Node Implementation --===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the C++ related Decl classes for templates.
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/DeclTemplate.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTMutationListener.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/ExprCXX.h"
20 #include "clang/AST/TypeLoc.h"
21 #include "clang/Basic/Builtins.h"
22 #include "clang/Basic/IdentifierTable.h"
23 #include "llvm/ADT/STLExtras.h"
25 using namespace clang;
27 //===----------------------------------------------------------------------===//
28 // TemplateParameterList Implementation
29 //===----------------------------------------------------------------------===//
31 TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
32 SourceLocation LAngleLoc,
33 ArrayRef<NamedDecl *> Params,
34 SourceLocation RAngleLoc,
36 : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
37 NumParams(Params.size()), ContainsUnexpandedParameterPack(false),
38 HasRequiresClause(static_cast<bool>(RequiresClause)) {
39 for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
40 NamedDecl *P = Params[Idx];
43 if (!P->isTemplateParameterPack()) {
44 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
45 if (NTTP->getType()->containsUnexpandedParameterPack())
46 ContainsUnexpandedParameterPack = true;
48 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
49 if (TTP->getTemplateParameters()->containsUnexpandedParameterPack())
50 ContainsUnexpandedParameterPack = true;
52 // FIXME: If a default argument contains an unexpanded parameter pack, the
53 // template parameter list does too.
57 *getTrailingObjects<Expr *>() = RequiresClause;
61 TemplateParameterList *
62 TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc,
63 SourceLocation LAngleLoc,
64 ArrayRef<NamedDecl *> Params,
65 SourceLocation RAngleLoc, Expr *RequiresClause) {
66 void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
67 Params.size(), RequiresClause ? 1u : 0u),
68 alignof(TemplateParameterList));
69 return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params,
70 RAngleLoc, RequiresClause);
73 unsigned TemplateParameterList::getMinRequiredArguments() const {
74 unsigned NumRequiredArgs = 0;
75 for (const NamedDecl *P : asArray()) {
76 if (P->isTemplateParameterPack()) {
77 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
78 if (NTTP->isExpandedParameterPack()) {
79 NumRequiredArgs += NTTP->getNumExpansionTypes();
86 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
87 if (TTP->hasDefaultArgument())
89 } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
90 if (NTTP->hasDefaultArgument())
92 } else if (cast<TemplateTemplateParmDecl>(P)->hasDefaultArgument())
98 return NumRequiredArgs;
101 unsigned TemplateParameterList::getDepth() const {
105 const NamedDecl *FirstParm = getParam(0);
106 if (const TemplateTypeParmDecl *TTP
107 = dyn_cast<TemplateTypeParmDecl>(FirstParm))
108 return TTP->getDepth();
109 else if (const NonTypeTemplateParmDecl *NTTP
110 = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
111 return NTTP->getDepth();
113 return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
116 static void AdoptTemplateParameterList(TemplateParameterList *Params,
117 DeclContext *Owner) {
118 for (NamedDecl *P : *Params) {
119 P->setDeclContext(Owner);
121 if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
122 AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner);
127 void *allocateDefaultArgStorageChain(const ASTContext &C) {
128 return new (C) char[sizeof(void*) * 2];
132 //===----------------------------------------------------------------------===//
133 // RedeclarableTemplateDecl Implementation
134 //===----------------------------------------------------------------------===//
136 RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const {
140 // Walk the previous-declaration chain until we either find a declaration
141 // with a common pointer or we run out of previous declarations.
142 SmallVector<const RedeclarableTemplateDecl *, 2> PrevDecls;
143 for (const RedeclarableTemplateDecl *Prev = getPreviousDecl(); Prev;
144 Prev = Prev->getPreviousDecl()) {
146 Common = Prev->Common;
150 PrevDecls.push_back(Prev);
153 // If we never found a common pointer, allocate one now.
155 // FIXME: If any of the declarations is from an AST file, we probably
156 // need an update record to add the common data.
158 Common = newCommon(getASTContext());
161 // Update any previous declarations we saw with the common pointer.
162 for (const RedeclarableTemplateDecl *Prev : PrevDecls)
163 Prev->Common = Common;
168 template<class EntryType>
169 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
170 RedeclarableTemplateDecl::findSpecializationImpl(
171 llvm::FoldingSetVector<EntryType> &Specs, ArrayRef<TemplateArgument> Args,
173 typedef SpecEntryTraits<EntryType> SETraits;
174 llvm::FoldingSetNodeID ID;
175 EntryType::Profile(ID,Args, getASTContext());
176 EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);
177 return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr;
180 template<class Derived, class EntryType>
181 void RedeclarableTemplateDecl::addSpecializationImpl(
182 llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
184 typedef SpecEntryTraits<EntryType> SETraits;
187 void *CorrectInsertPos;
188 assert(!findSpecializationImpl(Specializations,
189 SETraits::getTemplateArgs(Entry),
191 InsertPos == CorrectInsertPos &&
192 "given incorrect InsertPos for specialization");
194 Specializations.InsertNode(Entry, InsertPos);
196 EntryType *Existing = Specializations.GetOrInsertNode(Entry);
198 assert(SETraits::getDecl(Existing)->isCanonicalDecl() &&
199 "non-canonical specialization?");
202 if (ASTMutationListener *L = getASTMutationListener())
203 L->AddedCXXTemplateSpecialization(cast<Derived>(this),
204 SETraits::getDecl(Entry));
207 //===----------------------------------------------------------------------===//
208 // FunctionTemplateDecl Implementation
209 //===----------------------------------------------------------------------===//
211 FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
214 DeclarationName Name,
215 TemplateParameterList *Params,
217 AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
218 return new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl);
221 FunctionTemplateDecl *FunctionTemplateDecl::CreateDeserialized(ASTContext &C,
223 return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(),
224 DeclarationName(), nullptr, nullptr);
227 RedeclarableTemplateDecl::CommonBase *
228 FunctionTemplateDecl::newCommon(ASTContext &C) const {
229 Common *CommonPtr = new (C) Common;
230 C.addDestruction(CommonPtr);
234 void FunctionTemplateDecl::LoadLazySpecializations() const {
235 // Grab the most recent declaration to ensure we've loaded any lazy
236 // redeclarations of this template.
238 // FIXME: Avoid walking the entire redeclaration chain here.
239 Common *CommonPtr = getMostRecentDecl()->getCommonPtr();
240 if (CommonPtr->LazySpecializations) {
241 ASTContext &Context = getASTContext();
242 uint32_t *Specs = CommonPtr->LazySpecializations;
243 CommonPtr->LazySpecializations = nullptr;
244 for (uint32_t I = 0, N = *Specs++; I != N; ++I)
245 (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
249 llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
250 FunctionTemplateDecl::getSpecializations() const {
251 LoadLazySpecializations();
252 return getCommonPtr()->Specializations;
256 FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
258 return findSpecializationImpl(getSpecializations(), Args, InsertPos);
261 void FunctionTemplateDecl::addSpecialization(
262 FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
263 addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
267 ArrayRef<TemplateArgument> FunctionTemplateDecl::getInjectedTemplateArgs() {
268 TemplateParameterList *Params = getTemplateParameters();
269 Common *CommonPtr = getCommonPtr();
270 if (!CommonPtr->InjectedArgs) {
271 auto &Context = getASTContext();
272 SmallVector<TemplateArgument, 16> TemplateArgs;
273 Context.getInjectedTemplateArgs(Params, TemplateArgs);
274 CommonPtr->InjectedArgs =
275 new (Context) TemplateArgument[TemplateArgs.size()];
276 std::copy(TemplateArgs.begin(), TemplateArgs.end(),
277 CommonPtr->InjectedArgs);
280 return llvm::makeArrayRef(CommonPtr->InjectedArgs, Params->size());
283 //===----------------------------------------------------------------------===//
284 // ClassTemplateDecl Implementation
285 //===----------------------------------------------------------------------===//
287 ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
290 DeclarationName Name,
291 TemplateParameterList *Params,
293 Expr *AssociatedConstraints) {
294 AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
296 if (!AssociatedConstraints) {
297 return new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl);
300 ConstrainedTemplateDeclInfo *const CTDI = new (C) ConstrainedTemplateDeclInfo;
301 ClassTemplateDecl *const New =
302 new (C, DC) ClassTemplateDecl(CTDI, C, DC, L, Name, Params, Decl);
303 New->setAssociatedConstraints(AssociatedConstraints);
307 ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
309 return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
310 DeclarationName(), nullptr, nullptr);
313 void ClassTemplateDecl::LoadLazySpecializations() const {
314 // Grab the most recent declaration to ensure we've loaded any lazy
315 // redeclarations of this template.
317 // FIXME: Avoid walking the entire redeclaration chain here.
318 Common *CommonPtr = getMostRecentDecl()->getCommonPtr();
319 if (CommonPtr->LazySpecializations) {
320 ASTContext &Context = getASTContext();
321 uint32_t *Specs = CommonPtr->LazySpecializations;
322 CommonPtr->LazySpecializations = nullptr;
323 for (uint32_t I = 0, N = *Specs++; I != N; ++I)
324 (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
328 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
329 ClassTemplateDecl::getSpecializations() const {
330 LoadLazySpecializations();
331 return getCommonPtr()->Specializations;
334 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
335 ClassTemplateDecl::getPartialSpecializations() {
336 LoadLazySpecializations();
337 return getCommonPtr()->PartialSpecializations;
340 RedeclarableTemplateDecl::CommonBase *
341 ClassTemplateDecl::newCommon(ASTContext &C) const {
342 Common *CommonPtr = new (C) Common;
343 C.addDestruction(CommonPtr);
347 ClassTemplateSpecializationDecl *
348 ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
350 return findSpecializationImpl(getSpecializations(), Args, InsertPos);
353 void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
355 addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
358 ClassTemplatePartialSpecializationDecl *
359 ClassTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
361 return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
364 void ClassTemplateDecl::AddPartialSpecialization(
365 ClassTemplatePartialSpecializationDecl *D,
368 getPartialSpecializations().InsertNode(D, InsertPos);
370 ClassTemplatePartialSpecializationDecl *Existing
371 = getPartialSpecializations().GetOrInsertNode(D);
373 assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
376 if (ASTMutationListener *L = getASTMutationListener())
377 L->AddedCXXTemplateSpecialization(this, D);
380 void ClassTemplateDecl::getPartialSpecializations(
381 SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) {
382 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
383 = getPartialSpecializations();
385 PS.reserve(PartialSpecs.size());
386 for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs)
387 PS.push_back(P.getMostRecentDecl());
390 ClassTemplatePartialSpecializationDecl *
391 ClassTemplateDecl::findPartialSpecialization(QualType T) {
392 ASTContext &Context = getASTContext();
393 for (ClassTemplatePartialSpecializationDecl &P :
394 getPartialSpecializations()) {
395 if (Context.hasSameType(P.getInjectedSpecializationType(), T))
396 return P.getMostRecentDecl();
402 ClassTemplatePartialSpecializationDecl *
403 ClassTemplateDecl::findPartialSpecInstantiatedFromMember(
404 ClassTemplatePartialSpecializationDecl *D) {
405 Decl *DCanon = D->getCanonicalDecl();
406 for (ClassTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
407 if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
408 return P.getMostRecentDecl();
415 ClassTemplateDecl::getInjectedClassNameSpecialization() {
416 Common *CommonPtr = getCommonPtr();
417 if (!CommonPtr->InjectedClassNameType.isNull())
418 return CommonPtr->InjectedClassNameType;
420 // C++0x [temp.dep.type]p2:
421 // The template argument list of a primary template is a template argument
422 // list in which the nth template argument has the value of the nth template
423 // parameter of the class template. If the nth template parameter is a
424 // template parameter pack (14.5.3), the nth template argument is a pack
425 // expansion (14.5.3) whose pattern is the name of the template parameter
427 ASTContext &Context = getASTContext();
428 TemplateParameterList *Params = getTemplateParameters();
429 SmallVector<TemplateArgument, 16> TemplateArgs;
430 Context.getInjectedTemplateArgs(Params, TemplateArgs);
431 CommonPtr->InjectedClassNameType
432 = Context.getTemplateSpecializationType(TemplateName(this),
434 return CommonPtr->InjectedClassNameType;
437 //===----------------------------------------------------------------------===//
438 // TemplateTypeParm Allocation/Deallocation Method Implementations
439 //===----------------------------------------------------------------------===//
441 TemplateTypeParmDecl *
442 TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC,
443 SourceLocation KeyLoc, SourceLocation NameLoc,
444 unsigned D, unsigned P, IdentifierInfo *Id,
445 bool Typename, bool ParameterPack) {
446 TemplateTypeParmDecl *TTPDecl =
447 new (C, DC) TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename);
448 QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
449 TTPDecl->setTypeForDecl(TTPType.getTypePtr());
453 TemplateTypeParmDecl *
454 TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
455 return new (C, ID) TemplateTypeParmDecl(nullptr, SourceLocation(),
456 SourceLocation(), nullptr, false);
459 SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
460 return hasDefaultArgument()
461 ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc()
465 SourceRange TemplateTypeParmDecl::getSourceRange() const {
466 if (hasDefaultArgument() && !defaultArgumentWasInherited())
467 return SourceRange(getLocStart(),
468 getDefaultArgumentInfo()->getTypeLoc().getEndLoc());
470 return TypeDecl::getSourceRange();
473 unsigned TemplateTypeParmDecl::getDepth() const {
474 return getTypeForDecl()->getAs<TemplateTypeParmType>()->getDepth();
477 unsigned TemplateTypeParmDecl::getIndex() const {
478 return getTypeForDecl()->getAs<TemplateTypeParmType>()->getIndex();
481 bool TemplateTypeParmDecl::isParameterPack() const {
482 return getTypeForDecl()->getAs<TemplateTypeParmType>()->isParameterPack();
485 //===----------------------------------------------------------------------===//
486 // NonTypeTemplateParmDecl Method Implementations
487 //===----------------------------------------------------------------------===//
489 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
490 DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D,
491 unsigned P, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
492 ArrayRef<QualType> ExpandedTypes, ArrayRef<TypeSourceInfo *> ExpandedTInfos)
493 : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
494 TemplateParmPosition(D, P), ParameterPack(true),
495 ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {
496 if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {
498 getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
499 for (unsigned I = 0; I != NumExpandedTypes; ++I) {
500 new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]);
501 TypesAndInfos[I].second = ExpandedTInfos[I];
506 NonTypeTemplateParmDecl *
507 NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
508 SourceLocation StartLoc, SourceLocation IdLoc,
509 unsigned D, unsigned P, IdentifierInfo *Id,
510 QualType T, bool ParameterPack,
511 TypeSourceInfo *TInfo) {
512 return new (C, DC) NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id,
513 T, ParameterPack, TInfo);
516 NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
517 const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
518 SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
519 QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
520 ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
522 additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
523 ExpandedTypes.size()))
524 NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
525 ExpandedTypes, ExpandedTInfos);
528 NonTypeTemplateParmDecl *
529 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
530 return new (C, ID) NonTypeTemplateParmDecl(nullptr, SourceLocation(),
531 SourceLocation(), 0, 0, nullptr,
532 QualType(), false, nullptr);
535 NonTypeTemplateParmDecl *
536 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
537 unsigned NumExpandedTypes) {
539 new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
541 NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
542 0, 0, nullptr, QualType(), nullptr, None,
544 NTTP->NumExpandedTypes = NumExpandedTypes;
548 SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
549 if (hasDefaultArgument() && !defaultArgumentWasInherited())
550 return SourceRange(getOuterLocStart(),
551 getDefaultArgument()->getSourceRange().getEnd());
552 return DeclaratorDecl::getSourceRange();
555 SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
556 return hasDefaultArgument()
557 ? getDefaultArgument()->getSourceRange().getBegin()
561 //===----------------------------------------------------------------------===//
562 // TemplateTemplateParmDecl Method Implementations
563 //===----------------------------------------------------------------------===//
565 void TemplateTemplateParmDecl::anchor() { }
567 TemplateTemplateParmDecl::TemplateTemplateParmDecl(
568 DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
569 IdentifierInfo *Id, TemplateParameterList *Params,
570 ArrayRef<TemplateParameterList *> Expansions)
571 : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
572 TemplateParmPosition(D, P), ParameterPack(true),
573 ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {
574 if (!Expansions.empty())
575 std::uninitialized_copy(Expansions.begin(), Expansions.end(),
576 getTrailingObjects<TemplateParameterList *>());
579 TemplateTemplateParmDecl *
580 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
581 SourceLocation L, unsigned D, unsigned P,
582 bool ParameterPack, IdentifierInfo *Id,
583 TemplateParameterList *Params) {
584 return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
588 TemplateTemplateParmDecl *
589 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
590 SourceLocation L, unsigned D, unsigned P,
592 TemplateParameterList *Params,
593 ArrayRef<TemplateParameterList *> Expansions) {
595 additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
596 TemplateTemplateParmDecl(DC, L, D, P, Id, Params, Expansions);
599 TemplateTemplateParmDecl *
600 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
601 return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
602 false, nullptr, nullptr);
605 TemplateTemplateParmDecl *
606 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
607 unsigned NumExpansions) {
609 new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
610 TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
612 TTP->NumExpandedParams = NumExpansions;
616 SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
617 return hasDefaultArgument() ? getDefaultArgument().getLocation()
621 void TemplateTemplateParmDecl::setDefaultArgument(
622 const ASTContext &C, const TemplateArgumentLoc &DefArg) {
623 if (DefArg.getArgument().isNull())
624 DefaultArgument.set(nullptr);
626 DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg));
629 //===----------------------------------------------------------------------===//
630 // TemplateArgumentList Implementation
631 //===----------------------------------------------------------------------===//
632 TemplateArgumentList::TemplateArgumentList(ArrayRef<TemplateArgument> Args)
633 : Arguments(getTrailingObjects<TemplateArgument>()),
634 NumArguments(Args.size()) {
635 std::uninitialized_copy(Args.begin(), Args.end(),
636 getTrailingObjects<TemplateArgument>());
639 TemplateArgumentList *
640 TemplateArgumentList::CreateCopy(ASTContext &Context,
641 ArrayRef<TemplateArgument> Args) {
642 void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
643 return new (Mem) TemplateArgumentList(Args);
646 FunctionTemplateSpecializationInfo *
647 FunctionTemplateSpecializationInfo::Create(ASTContext &C, FunctionDecl *FD,
648 FunctionTemplateDecl *Template,
649 TemplateSpecializationKind TSK,
650 const TemplateArgumentList *TemplateArgs,
651 const TemplateArgumentListInfo *TemplateArgsAsWritten,
652 SourceLocation POI) {
653 const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
654 if (TemplateArgsAsWritten)
655 ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C,
656 *TemplateArgsAsWritten);
658 return new (C) FunctionTemplateSpecializationInfo(FD, Template, TSK,
664 //===----------------------------------------------------------------------===//
665 // TemplateDecl Implementation
666 //===----------------------------------------------------------------------===//
668 void TemplateDecl::anchor() { }
670 //===----------------------------------------------------------------------===//
671 // ClassTemplateSpecializationDecl Implementation
672 //===----------------------------------------------------------------------===//
673 ClassTemplateSpecializationDecl::
674 ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
675 DeclContext *DC, SourceLocation StartLoc,
676 SourceLocation IdLoc,
677 ClassTemplateDecl *SpecializedTemplate,
678 ArrayRef<TemplateArgument> Args,
679 ClassTemplateSpecializationDecl *PrevDecl)
680 : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,
681 SpecializedTemplate->getIdentifier(),
683 SpecializedTemplate(SpecializedTemplate),
684 ExplicitInfo(nullptr),
685 TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
686 SpecializationKind(TSK_Undeclared) {
689 ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
691 : CXXRecordDecl(DK, TTK_Struct, C, nullptr, SourceLocation(),
692 SourceLocation(), nullptr, nullptr),
693 ExplicitInfo(nullptr), SpecializationKind(TSK_Undeclared) {}
695 ClassTemplateSpecializationDecl *
696 ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
698 SourceLocation StartLoc,
699 SourceLocation IdLoc,
700 ClassTemplateDecl *SpecializedTemplate,
701 ArrayRef<TemplateArgument> Args,
702 ClassTemplateSpecializationDecl *PrevDecl) {
703 ClassTemplateSpecializationDecl *Result =
704 new (Context, DC) ClassTemplateSpecializationDecl(
705 Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
706 SpecializedTemplate, Args, PrevDecl);
707 Result->MayHaveOutOfDateDef = false;
709 Context.getTypeDeclType(Result, PrevDecl);
713 ClassTemplateSpecializationDecl *
714 ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
716 ClassTemplateSpecializationDecl *Result =
717 new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
718 Result->MayHaveOutOfDateDef = false;
722 void ClassTemplateSpecializationDecl::getNameForDiagnostic(
723 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
724 NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
726 auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
727 if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
728 PS ? PS->getTemplateArgsAsWritten() : nullptr) {
729 TemplateSpecializationType::PrintTemplateArgumentList(
730 OS, ArgsAsWritten->arguments(), Policy);
732 const TemplateArgumentList &TemplateArgs = getTemplateArgs();
733 TemplateSpecializationType::PrintTemplateArgumentList(
734 OS, TemplateArgs.asArray(), Policy);
739 ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
740 if (SpecializedPartialSpecialization *PartialSpec
741 = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
742 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
743 return SpecializedTemplate.get<ClassTemplateDecl*>();
747 ClassTemplateSpecializationDecl::getSourceRange() const {
749 SourceLocation Begin = getTemplateKeywordLoc();
750 if (Begin.isValid()) {
751 // Here we have an explicit (partial) specialization or instantiation.
752 assert(getSpecializationKind() == TSK_ExplicitSpecialization ||
753 getSpecializationKind() == TSK_ExplicitInstantiationDeclaration ||
754 getSpecializationKind() == TSK_ExplicitInstantiationDefinition);
755 if (getExternLoc().isValid())
756 Begin = getExternLoc();
757 SourceLocation End = getBraceRange().getEnd();
759 End = getTypeAsWritten()->getTypeLoc().getEndLoc();
760 return SourceRange(Begin, End);
762 // An implicit instantiation of a class template partial specialization
763 // uses ExplicitInfo to record the TypeAsWritten, but the source
764 // locations should be retrieved from the instantiation pattern.
765 typedef ClassTemplatePartialSpecializationDecl CTPSDecl;
766 CTPSDecl *ctpsd = const_cast<CTPSDecl*>(cast<CTPSDecl>(this));
767 CTPSDecl *inst_from = ctpsd->getInstantiatedFromMember();
768 assert(inst_from != nullptr);
769 return inst_from->getSourceRange();
772 // No explicit info available.
773 llvm::PointerUnion<ClassTemplateDecl *,
774 ClassTemplatePartialSpecializationDecl *>
775 inst_from = getInstantiatedFrom();
776 if (inst_from.isNull())
777 return getSpecializedTemplate()->getSourceRange();
778 if (ClassTemplateDecl *ctd = inst_from.dyn_cast<ClassTemplateDecl*>())
779 return ctd->getSourceRange();
780 return inst_from.get<ClassTemplatePartialSpecializationDecl*>()
785 //===----------------------------------------------------------------------===//
786 // ClassTemplatePartialSpecializationDecl Implementation
787 //===----------------------------------------------------------------------===//
788 void ClassTemplatePartialSpecializationDecl::anchor() { }
790 ClassTemplatePartialSpecializationDecl::
791 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
793 SourceLocation StartLoc,
794 SourceLocation IdLoc,
795 TemplateParameterList *Params,
796 ClassTemplateDecl *SpecializedTemplate,
797 ArrayRef<TemplateArgument> Args,
798 const ASTTemplateArgumentListInfo *ArgInfos,
799 ClassTemplatePartialSpecializationDecl *PrevDecl)
800 : ClassTemplateSpecializationDecl(Context,
801 ClassTemplatePartialSpecialization,
802 TK, DC, StartLoc, IdLoc,
805 TemplateParams(Params), ArgsAsWritten(ArgInfos),
806 InstantiatedFromMember(nullptr, false)
808 AdoptTemplateParameterList(Params, this);
811 ClassTemplatePartialSpecializationDecl *
812 ClassTemplatePartialSpecializationDecl::
813 Create(ASTContext &Context, TagKind TK,DeclContext *DC,
814 SourceLocation StartLoc, SourceLocation IdLoc,
815 TemplateParameterList *Params,
816 ClassTemplateDecl *SpecializedTemplate,
817 ArrayRef<TemplateArgument> Args,
818 const TemplateArgumentListInfo &ArgInfos,
819 QualType CanonInjectedType,
820 ClassTemplatePartialSpecializationDecl *PrevDecl) {
821 const ASTTemplateArgumentListInfo *ASTArgInfos =
822 ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
824 ClassTemplatePartialSpecializationDecl *Result = new (Context, DC)
825 ClassTemplatePartialSpecializationDecl(Context, TK, DC, StartLoc, IdLoc,
826 Params, SpecializedTemplate, Args,
827 ASTArgInfos, PrevDecl);
828 Result->setSpecializationKind(TSK_ExplicitSpecialization);
829 Result->MayHaveOutOfDateDef = false;
831 Context.getInjectedClassNameType(Result, CanonInjectedType);
835 ClassTemplatePartialSpecializationDecl *
836 ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
838 ClassTemplatePartialSpecializationDecl *Result =
839 new (C, ID) ClassTemplatePartialSpecializationDecl(C);
840 Result->MayHaveOutOfDateDef = false;
844 //===----------------------------------------------------------------------===//
845 // FriendTemplateDecl Implementation
846 //===----------------------------------------------------------------------===//
848 void FriendTemplateDecl::anchor() { }
851 FriendTemplateDecl::Create(ASTContext &Context, DeclContext *DC,
853 MutableArrayRef<TemplateParameterList *> Params,
854 FriendUnion Friend, SourceLocation FLoc) {
855 return new (Context, DC) FriendTemplateDecl(DC, L, Params, Friend, FLoc);
858 FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
860 return new (C, ID) FriendTemplateDecl(EmptyShell());
863 //===----------------------------------------------------------------------===//
864 // TypeAliasTemplateDecl Implementation
865 //===----------------------------------------------------------------------===//
867 TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C,
870 DeclarationName Name,
871 TemplateParameterList *Params,
873 AdoptTemplateParameterList(Params, DC);
874 return new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl);
877 TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C,
879 return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
880 DeclarationName(), nullptr, nullptr);
883 RedeclarableTemplateDecl::CommonBase *
884 TypeAliasTemplateDecl::newCommon(ASTContext &C) const {
885 Common *CommonPtr = new (C) Common;
886 C.addDestruction(CommonPtr);
890 //===----------------------------------------------------------------------===//
891 // ClassScopeFunctionSpecializationDecl Implementation
892 //===----------------------------------------------------------------------===//
894 void ClassScopeFunctionSpecializationDecl::anchor() { }
896 ClassScopeFunctionSpecializationDecl *
897 ClassScopeFunctionSpecializationDecl::CreateDeserialized(ASTContext &C,
899 return new (C, ID) ClassScopeFunctionSpecializationDecl(
900 nullptr, SourceLocation(), nullptr, false, TemplateArgumentListInfo());
903 //===----------------------------------------------------------------------===//
904 // VarTemplateDecl Implementation
905 //===----------------------------------------------------------------------===//
907 VarTemplateDecl *VarTemplateDecl::getDefinition() {
908 VarTemplateDecl *CurD = this;
910 if (CurD->isThisDeclarationADefinition())
912 CurD = CurD->getPreviousDecl();
917 VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC,
918 SourceLocation L, DeclarationName Name,
919 TemplateParameterList *Params,
921 return new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl);
924 VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C,
926 return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
927 DeclarationName(), nullptr, nullptr);
930 // TODO: Unify across class, function and variable templates?
931 // May require moving this and Common to RedeclarableTemplateDecl.
932 void VarTemplateDecl::LoadLazySpecializations() const {
933 // Grab the most recent declaration to ensure we've loaded any lazy
934 // redeclarations of this template.
936 // FIXME: Avoid walking the entire redeclaration chain here.
937 Common *CommonPtr = getMostRecentDecl()->getCommonPtr();
938 if (CommonPtr->LazySpecializations) {
939 ASTContext &Context = getASTContext();
940 uint32_t *Specs = CommonPtr->LazySpecializations;
941 CommonPtr->LazySpecializations = nullptr;
942 for (uint32_t I = 0, N = *Specs++; I != N; ++I)
943 (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
947 llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
948 VarTemplateDecl::getSpecializations() const {
949 LoadLazySpecializations();
950 return getCommonPtr()->Specializations;
953 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
954 VarTemplateDecl::getPartialSpecializations() {
955 LoadLazySpecializations();
956 return getCommonPtr()->PartialSpecializations;
959 RedeclarableTemplateDecl::CommonBase *
960 VarTemplateDecl::newCommon(ASTContext &C) const {
961 Common *CommonPtr = new (C) Common;
962 C.addDestruction(CommonPtr);
966 VarTemplateSpecializationDecl *
967 VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
969 return findSpecializationImpl(getSpecializations(), Args, InsertPos);
972 void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D,
974 addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
977 VarTemplatePartialSpecializationDecl *
978 VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
980 return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
983 void VarTemplateDecl::AddPartialSpecialization(
984 VarTemplatePartialSpecializationDecl *D, void *InsertPos) {
986 getPartialSpecializations().InsertNode(D, InsertPos);
988 VarTemplatePartialSpecializationDecl *Existing =
989 getPartialSpecializations().GetOrInsertNode(D);
991 assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
994 if (ASTMutationListener *L = getASTMutationListener())
995 L->AddedCXXTemplateSpecialization(this, D);
998 void VarTemplateDecl::getPartialSpecializations(
999 SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) {
1000 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
1001 getPartialSpecializations();
1003 PS.reserve(PartialSpecs.size());
1004 for (VarTemplatePartialSpecializationDecl &P : PartialSpecs)
1005 PS.push_back(P.getMostRecentDecl());
1008 VarTemplatePartialSpecializationDecl *
1009 VarTemplateDecl::findPartialSpecInstantiatedFromMember(
1010 VarTemplatePartialSpecializationDecl *D) {
1011 Decl *DCanon = D->getCanonicalDecl();
1012 for (VarTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
1013 if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
1014 return P.getMostRecentDecl();
1020 //===----------------------------------------------------------------------===//
1021 // VarTemplateSpecializationDecl Implementation
1022 //===----------------------------------------------------------------------===//
1023 VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(
1024 Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1025 SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1026 TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args)
1027 : VarDecl(DK, Context, DC, StartLoc, IdLoc,
1028 SpecializedTemplate->getIdentifier(), T, TInfo, S),
1029 SpecializedTemplate(SpecializedTemplate), ExplicitInfo(nullptr),
1030 TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
1031 SpecializationKind(TSK_Undeclared) {}
1033 VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(Kind DK,
1035 : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1036 QualType(), nullptr, SC_None),
1037 ExplicitInfo(nullptr), SpecializationKind(TSK_Undeclared) {}
1039 VarTemplateSpecializationDecl *VarTemplateSpecializationDecl::Create(
1040 ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1041 SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1042 TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) {
1043 return new (Context, DC) VarTemplateSpecializationDecl(
1044 VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,
1045 SpecializedTemplate, T, TInfo, S, Args);
1048 VarTemplateSpecializationDecl *
1049 VarTemplateSpecializationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1051 VarTemplateSpecializationDecl(VarTemplateSpecialization, C);
1054 void VarTemplateSpecializationDecl::getNameForDiagnostic(
1055 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
1056 NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
1058 auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
1059 if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
1060 PS ? PS->getTemplateArgsAsWritten() : nullptr) {
1061 TemplateSpecializationType::PrintTemplateArgumentList(
1062 OS, ArgsAsWritten->arguments(), Policy);
1064 const TemplateArgumentList &TemplateArgs = getTemplateArgs();
1065 TemplateSpecializationType::PrintTemplateArgumentList(
1066 OS, TemplateArgs.asArray(), Policy);
1070 VarTemplateDecl *VarTemplateSpecializationDecl::getSpecializedTemplate() const {
1071 if (SpecializedPartialSpecialization *PartialSpec =
1072 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1073 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
1074 return SpecializedTemplate.get<VarTemplateDecl *>();
1077 void VarTemplateSpecializationDecl::setTemplateArgsInfo(
1078 const TemplateArgumentListInfo &ArgsInfo) {
1079 TemplateArgsInfo.setLAngleLoc(ArgsInfo.getLAngleLoc());
1080 TemplateArgsInfo.setRAngleLoc(ArgsInfo.getRAngleLoc());
1081 for (const TemplateArgumentLoc &Loc : ArgsInfo.arguments())
1082 TemplateArgsInfo.addArgument(Loc);
1085 //===----------------------------------------------------------------------===//
1086 // VarTemplatePartialSpecializationDecl Implementation
1087 //===----------------------------------------------------------------------===//
1088 void VarTemplatePartialSpecializationDecl::anchor() {}
1090 VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(
1091 ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1092 SourceLocation IdLoc, TemplateParameterList *Params,
1093 VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1094 StorageClass S, ArrayRef<TemplateArgument> Args,
1095 const ASTTemplateArgumentListInfo *ArgInfos)
1096 : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context,
1097 DC, StartLoc, IdLoc, SpecializedTemplate, T,
1099 TemplateParams(Params), ArgsAsWritten(ArgInfos),
1100 InstantiatedFromMember(nullptr, false) {
1101 // TODO: The template parameters should be in DC by now. Verify.
1102 // AdoptTemplateParameterList(Params, DC);
1105 VarTemplatePartialSpecializationDecl *
1106 VarTemplatePartialSpecializationDecl::Create(
1107 ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1108 SourceLocation IdLoc, TemplateParameterList *Params,
1109 VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1110 StorageClass S, ArrayRef<TemplateArgument> Args,
1111 const TemplateArgumentListInfo &ArgInfos) {
1112 const ASTTemplateArgumentListInfo *ASTArgInfos
1113 = ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
1115 VarTemplatePartialSpecializationDecl *Result =
1116 new (Context, DC) VarTemplatePartialSpecializationDecl(
1117 Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo,
1118 S, Args, ASTArgInfos);
1119 Result->setSpecializationKind(TSK_ExplicitSpecialization);
1123 VarTemplatePartialSpecializationDecl *
1124 VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
1126 return new (C, ID) VarTemplatePartialSpecializationDecl(C);
1129 static TemplateParameterList *
1130 createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
1132 auto *T = TemplateTypeParmDecl::Create(
1133 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
1134 /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false);
1135 T->setImplicit(true);
1138 TypeSourceInfo *TI =
1139 C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));
1140 auto *N = NonTypeTemplateParmDecl::Create(
1141 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1142 /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
1143 N->setImplicit(true);
1145 // <typename T, T ...Ints>
1146 NamedDecl *P[2] = {T, N};
1147 auto *TPL = TemplateParameterList::Create(
1148 C, SourceLocation(), SourceLocation(), P, SourceLocation(), nullptr);
1150 // template <typename T, ...Ints> class IntSeq
1151 auto *TemplateTemplateParm = TemplateTemplateParmDecl::Create(
1152 C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
1153 /*ParameterPack=*/false, /*Id=*/nullptr, TPL);
1154 TemplateTemplateParm->setImplicit(true);
1157 auto *TemplateTypeParm = TemplateTypeParmDecl::Create(
1158 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1159 /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false);
1160 TemplateTypeParm->setImplicit(true);
1163 TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(
1164 QualType(TemplateTypeParm->getTypeForDecl(), 0));
1165 auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
1166 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
1167 /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1168 NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,
1169 NonTypeTemplateParm};
1171 // template <template <typename T, T ...Ints> class IntSeq, typename T, T N>
1172 return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1173 Params, SourceLocation(), nullptr);
1176 static TemplateParameterList *
1177 createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
1178 // std::size_t Index
1179 TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
1180 auto *Index = NonTypeTemplateParmDecl::Create(
1181 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
1182 /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1185 auto *Ts = TemplateTypeParmDecl::Create(
1186 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1187 /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/true);
1188 Ts->setImplicit(true);
1190 // template <std::size_t Index, typename ...T>
1191 NamedDecl *Params[] = {Index, Ts};
1192 return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1193 llvm::makeArrayRef(Params),
1194 SourceLocation(), nullptr);
1197 static TemplateParameterList *createBuiltinTemplateParameterList(
1198 const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
1200 case BTK__make_integer_seq:
1201 return createMakeIntegerSeqParameterList(C, DC);
1202 case BTK__type_pack_element:
1203 return createTypePackElementParameterList(C, DC);
1206 llvm_unreachable("unhandled BuiltinTemplateKind!");
1209 void BuiltinTemplateDecl::anchor() {}
1211 BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
1212 DeclarationName Name,
1213 BuiltinTemplateKind BTK)
1214 : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
1215 createBuiltinTemplateParameterList(C, DC, BTK)),