clang 19.0.0git
DeclTemplate.cpp
Go to the documentation of this file.
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
16#include "clang/AST/DeclCXX.h"
18#include "clang/AST/Expr.h"
22#include "clang/AST/Type.h"
23#include "clang/AST/TypeLoc.h"
25#include "clang/Basic/LLVM.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,
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>(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>(P)) {
69 if (!IsPack &&
70 TTP->getTemplateParameters()->containsUnexpandedParameterPack())
71 ContainsUnexpandedParameterPack = true;
72 } else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(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(asArray())) {
104 if (!Param->isImplicit())
105 break;
106
107 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(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
120 SourceLocation LAngleLoc,
122 SourceLocation RAngleLoc, Expr *RequiresClause) {
123 void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
124 Params.size(), RequiresClause ? 1u : 0u),
125 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(RC != nullptr);
134 if (RC)
135 RC->Profile(ID, C, /*Canonical=*/true);
136 ID.AddInteger(size());
137 for (NamedDecl *D : *this) {
138 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
139 ID.AddInteger(0);
140 ID.AddBoolean(NTTP->isParameterPack());
141 NTTP->getType().getCanonicalType().Profile(ID);
142 ID.AddBoolean(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>(D)) {
148 ID.AddInteger(1);
149 ID.AddBoolean(TTP->isParameterPack());
150 ID.AddBoolean(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>(D);
157 ID.AddInteger(2);
158 ID.AddBoolean(TTP->isParameterPack());
159 TTP->getTemplateParameters()->Profile(ID, C);
160 }
161}
162
164 unsigned NumRequiredArgs = 0;
165 for (const NamedDecl *P : asArray()) {
166 if (P->isTemplateParameterPack()) {
167 if (std::optional<unsigned> Expansions = getExpandedPackSize(P)) {
168 NumRequiredArgs += *Expansions;
169 continue;
170 }
171 break;
172 }
173
174 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
175 if (TTP->hasDefaultArgument())
176 break;
177 } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
178 if (NTTP->hasDefaultArgument())
179 break;
180 } else if (cast<TemplateTemplateParmDecl>(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(0);
194 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(FirstParm))
195 return TTP->getDepth();
196 else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
197 return NTTP->getDepth();
198 else
199 return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
200}
201
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>(P))
209 if (AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner))
210 Invalid = true;
211
212 if (P->isInvalidDecl())
213 Invalid = true;
214 }
215 return Invalid;
216}
217
220 if (HasConstrainedParameters)
221 for (const NamedDecl *Param : *this) {
222 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
223 if (const auto *TC = TTP->getTypeConstraint())
224 AC.push_back(TC->getImmediatelyDeclaredConstraint());
225 } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
226 if (const Expr *E = NTTP->getPlaceholderTypeConstraint())
227 AC.push_back(E);
228 }
229 }
230 if (HasRequiresClause)
231 AC.push_back(getRequiresClause());
232}
233
235 return HasRequiresClause || HasConstrainedParameters;
236}
237
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>(TemplParam))
246 if (ParamValueDecl->getType()->getContainedDeducedType())
247 return true;
248 return false;
249}
250
251namespace clang {
252
254 return new (C) char[sizeof(void*) * 2];
255}
256
257} // namespace clang
258
259//===----------------------------------------------------------------------===//
260// TemplateDecl Implementation
261//===----------------------------------------------------------------------===//
262
266 : NamedDecl(DK, DC, L, Name), TemplatedDecl(Decl), TemplateParams(Params) {}
267
268void TemplateDecl::anchor() {}
269
273 if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
274 if (const Expr *TRC = FD->getTrailingRequiresClause())
275 AC.push_back(TRC);
276}
277
280 return true;
281 if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
282 return FD->getTrailingRequiresClause();
283 return false;
284}
285
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
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.
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(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
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
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(Specs[I]);
344 }
345}
346
347template<class EntryType, typename... ProfileArguments>
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>
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
385 L->AddedCXXTemplateSpecialization(cast<Derived>(this),
386 SETraits::getDecl(Entry));
387}
388
391 auto *CommonPtr = getCommonPtr();
392 if (!CommonPtr->InjectedArgs) {
393 auto &Context = getASTContext();
395 Context.getInjectedTemplateArgs(Params, TemplateArgs);
396 CommonPtr->InjectedArgs =
397 new (Context) TemplateArgument[TemplateArgs.size()];
398 std::copy(TemplateArgs.begin(), TemplateArgs.end(),
399 CommonPtr->InjectedArgs);
400 }
401
402 return llvm::ArrayRef(CommonPtr->InjectedArgs, Params->size());
403}
404
405//===----------------------------------------------------------------------===//
406// FunctionTemplateDecl Implementation
407//===----------------------------------------------------------------------===//
408
411 DeclarationName Name,
413 bool Invalid = AdoptTemplateParameterList(Params, cast<DeclContext>(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
421 unsigned ID) {
422 return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(),
423 DeclarationName(), nullptr, nullptr);
424}
425
428 auto *CommonPtr = new (C) Common;
429 C.addDestruction(CommonPtr);
430 return CommonPtr;
431}
432
435}
436
437llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
441}
442
445 void *&InsertPos) {
446 return findSpecializationImpl(getSpecializations(), InsertPos, Args);
447}
448
450 FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
451 addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
452 InsertPos);
453}
454
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;
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(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
495 DeclarationName Name,
496 TemplateParameterList *Params,
497 NamedDecl *Decl) {
498 bool Invalid = AdoptTemplateParameterList(Params, cast<DeclContext>(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
506 unsigned ID) {
507 return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
508 DeclarationName(), nullptr, nullptr);
509}
510
513}
514
515llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
519}
520
521llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
525}
526
529 auto *CommonPtr = new (C) Common;
530 C.addDestruction(CommonPtr);
531 return CommonPtr;
532}
533
536 void *&InsertPos) {
537 return findSpecializationImpl(getSpecializations(), InsertPos, Args);
538}
539
541 void *InsertPos) {
542 addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
543}
544
548 TemplateParameterList *TPL, void *&InsertPos) {
549 return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
550 TPL);
551}
552
554 llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
555 TemplateParameterList *TPL, const ASTContext &Context) {
556 ID.AddInteger(TemplateArgs.size());
557 for (const TemplateArgument &TemplateArg : TemplateArgs)
558 TemplateArg.Profile(ID, Context);
559 TPL->Profile(ID, Context);
560}
561
564 void *InsertPos) {
565 if (InsertPos)
566 getPartialSpecializations().InsertNode(D, InsertPos);
567 else {
569 = getPartialSpecializations().GetOrInsertNode(D);
570 (void)Existing;
571 assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
572 }
573
575 L->AddedCXXTemplateSpecialization(this, D);
576}
577
580 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
582 PS.clear();
583 PS.reserve(PartialSpecs.size());
584 for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs)
585 PS.push_back(P.getMostRecentDecl());
586}
587
590 ASTContext &Context = getASTContext();
593 if (Context.hasSameType(P.getInjectedSpecializationType(), T))
594 return P.getMostRecentDecl();
595 }
596
597 return nullptr;
598}
599
603 Decl *DCanon = D->getCanonicalDecl();
605 if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
606 return P.getMostRecentDecl();
607 }
608
609 return nullptr;
610}
611
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();
628 Context.getInjectedTemplateArgs(Params, TemplateArgs);
629 CommonPtr->InjectedClassNameType
631 TemplateArgs);
632 return CommonPtr->InjectedClassNameType;
633}
634
635//===----------------------------------------------------------------------===//
636// TemplateTypeParm Allocation/Deallocation Method Implementations
637//===----------------------------------------------------------------------===//
638
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>(HasTypeConstraint ? 1 : 0))
647 TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename,
648 HasTypeConstraint, NumExpanded);
649 QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
650 TTPDecl->setTypeForDecl(TTPType.getTypePtr());
651 return TTPDecl;
652}
653
656 return new (C, ID)
658 false, false, std::nullopt);
659}
660
663 bool HasTypeConstraint) {
664 return new (C, ID,
665 additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
667 false, HasTypeConstraint, std::nullopt);
668}
669
671 return hasDefaultArgument()
673 : SourceLocation();
674}
675
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());
686}
687
690}
691
694}
695
698}
699
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
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
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
765 bool HasTypeConstraint) {
766 return new (C, ID, additionalSizeToAlloc<std::pair<QualType,
768 Expr *>(0,
769 HasTypeConstraint ? 1 : 0))
771 0, 0, nullptr, QualType(), false, nullptr);
772}
773
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))
783 0, 0, nullptr, QualType(), nullptr,
784 std::nullopt, std::nullopt);
785 NTTP->NumExpandedTypes = NumExpandedTypes;
786 return NTTP;
787}
788
792 getDefaultArgument()->getSourceRange().getEnd());
794}
795
797 return hasDefaultArgument()
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,
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
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
831 SourceLocation L, unsigned D, unsigned P,
833 TemplateParameterList *Params,
835 return new (C, DC,
836 additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
837 TemplateTemplateParmDecl(DC, L, D, P, Id, Params, Expansions);
838}
839
842 return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
843 false, nullptr, nullptr);
844}
845
848 unsigned NumExpansions) {
849 auto *TTP =
850 new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
851 TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
852 nullptr, std::nullopt);
853 TTP->NumExpandedParams = NumExpansions;
854 return TTP;
855}
856
859 : SourceLocation();
860}
861
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(Args.begin(), Args.end(),
876 getTrailingObjects<TemplateArgument>());
877}
878
882 void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
883 return new (Mem) TemplateArgumentList(Args);
884}
885
888 TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs,
889 const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI,
890 MemberSpecializationInfo *MSInfo) {
891 const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
892 if (TemplateArgsAsWritten)
894 *TemplateArgsAsWritten);
895
896 void *Mem =
897 C.Allocate(totalSizeToAlloc<MemberSpecializationInfo *>(MSInfo ? 1 : 0));
898 return new (Mem) FunctionTemplateSpecializationInfo(
899 FD, Template, TSK, TemplateArgs, ArgsAsWritten, POI, MSInfo);
900}
901
902//===----------------------------------------------------------------------===//
903// ClassTemplateSpecializationDecl Implementation
904//===----------------------------------------------------------------------===//
905
908 DeclContext *DC, SourceLocation StartLoc,
909 SourceLocation IdLoc,
910 ClassTemplateDecl *SpecializedTemplate,
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
921 Kind DK)
922 : CXXRecordDecl(DK, TagTypeKind::Struct, C, nullptr, SourceLocation(),
923 SourceLocation(), nullptr, nullptr),
924 SpecializationKind(TSK_Undeclared) {}
925
928 DeclContext *DC,
929 SourceLocation StartLoc,
930 SourceLocation IdLoc,
931 ClassTemplateDecl *SpecializedTemplate,
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(Result, PrevDecl);
949 return Result;
950}
951
954 unsigned ID) {
955 auto *Result =
956 new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
957 Result->setMayHaveOutOfDateDef(false);
958 return Result;
959}
960
962 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
964
965 const auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
966 if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
967 PS ? PS->getTemplateArgsAsWritten() : nullptr) {
969 OS, ArgsAsWritten->arguments(), Policy,
970 getSpecializedTemplate()->getTemplateParameters());
971 } else {
972 const TemplateArgumentList &TemplateArgs = getTemplateArgs();
974 OS, TemplateArgs.asArray(), Policy,
975 getSpecializedTemplate()->getTemplateParameters());
976 }
977}
978
981 if (const auto *PartialSpec =
982 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
983 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
984 return SpecializedTemplate.get<ClassTemplateDecl*>();
985}
986
989 if (ExplicitInfo) {
991 if (Begin.isValid()) {
992 // Here we have an explicit (partial) specialization or instantiation.
996 if (getExternLoc().isValid())
999 if (End.isInvalid())
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.
1007 auto *ctpsd = const_cast<CTPSDecl *>(cast<CTPSDecl>(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 *,
1016 inst_from = getInstantiatedFrom();
1017 if (inst_from.isNull())
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//===----------------------------------------------------------------------===//
1031 TemplateParameterList *Params,
1032 Expr *ConstraintExpr) {
1033 bool Invalid = AdoptTemplateParameterList(Params, DC);
1034 auto *TD = new (C, DC) ConceptDecl(DC, L, Name, Params, ConstraintExpr);
1035 if (Invalid)
1036 TD->setInvalidDecl();
1037 return TD;
1038}
1039
1041 unsigned ID) {
1042 ConceptDecl *Result = new (C, ID) ConceptDecl(nullptr, SourceLocation(),
1044 nullptr, nullptr);
1045
1046 return Result;
1047}
1048
1049//===----------------------------------------------------------------------===//
1050// ImplicitConceptSpecializationDecl Implementation
1051//===----------------------------------------------------------------------===//
1052ImplicitConceptSpecializationDecl::ImplicitConceptSpecializationDecl(
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
1066 const ASTContext &C, DeclContext *DC, SourceLocation SL,
1067 ArrayRef<TemplateArgument> ConvertedArgs) {
1068 return new (C, DC,
1069 additionalSizeToAlloc<TemplateArgument>(ConvertedArgs.size()))
1070 ImplicitConceptSpecializationDecl(DC, SL, ConvertedArgs);
1071}
1072
1075 const ASTContext &C, unsigned ID, unsigned NumTemplateArgs) {
1076 return new (C, ID, additionalSizeToAlloc<TemplateArgument>(NumTemplateArgs))
1078}
1079
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,
1100 const ASTTemplateArgumentListInfo *ArgInfos,
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))
1110}
1111
1114Create(ASTContext &Context, TagKind TK,DeclContext *DC,
1115 SourceLocation StartLoc, SourceLocation IdLoc,
1116 TemplateParameterList *Params,
1117 ClassTemplateDecl *SpecializedTemplate,
1119 const TemplateArgumentListInfo &ArgInfos,
1120 QualType CanonInjectedType,
1122 const ASTTemplateArgumentListInfo *ASTArgInfos =
1123 ASTTemplateArgumentListInfo::Create(Context, 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
1138 unsigned ID) {
1140 Result->setMayHaveOutOfDateDef(false);
1141 return Result;
1142}
1143
1144//===----------------------------------------------------------------------===//
1145// FriendTemplateDecl Implementation
1146//===----------------------------------------------------------------------===//
1147
1148void FriendTemplateDecl::anchor() {}
1149
1154 FriendUnion Friend, SourceLocation FLoc) {
1155 TemplateParameterList **TPL = nullptr;
1156 if (!Params.empty()) {
1157 TPL = new (Context) TemplateParameterList *[Params.size()];
1158 llvm::copy(Params, TPL);
1159 }
1160 return new (Context, DC)
1161 FriendTemplateDecl(DC, L, TPL, Params.size(), Friend, FLoc);
1162}
1163
1165 unsigned ID) {
1166 return new (C, ID) FriendTemplateDecl(EmptyShell());
1167}
1168
1169//===----------------------------------------------------------------------===//
1170// TypeAliasTemplateDecl Implementation
1171//===----------------------------------------------------------------------===//
1172
1175 DeclarationName Name,
1177 bool Invalid = AdoptTemplateParameterList(Params, 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
1185 unsigned ID) {
1186 return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
1187 DeclarationName(), nullptr, nullptr);
1188}
1189
1192 auto *CommonPtr = new (C) Common;
1193 C.addDestruction(CommonPtr);
1194 return CommonPtr;
1195}
1196
1197//===----------------------------------------------------------------------===//
1198// VarTemplateDecl Implementation
1199//===----------------------------------------------------------------------===//
1200
1202 VarTemplateDecl *CurD = this;
1203 while (CurD) {
1204 if (CurD->isThisDeclarationADefinition())
1205 return CurD;
1206 CurD = CurD->getPreviousDecl();
1207 }
1208 return nullptr;
1209}
1210
1213 TemplateParameterList *Params,
1214 VarDecl *Decl) {
1215 bool Invalid = AdoptTemplateParameterList(Params, 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
1223 unsigned ID) {
1224 return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
1225 DeclarationName(), nullptr, nullptr);
1226}
1227
1230}
1231
1232llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
1235 return getCommonPtr()->Specializations;
1236}
1237
1238llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
1242}
1243
1246 auto *CommonPtr = new (C) Common;
1247 C.addDestruction(CommonPtr);
1248 return CommonPtr;
1249}
1250
1253 void *&InsertPos) {
1254 return findSpecializationImpl(getSpecializations(), InsertPos, Args);
1255}
1256
1258 void *InsertPos) {
1259 addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
1260}
1261
1264 TemplateParameterList *TPL, void *&InsertPos) {
1265 return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
1266 TPL);
1267}
1268
1270 llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
1271 TemplateParameterList *TPL, const ASTContext &Context) {
1272 ID.AddInteger(TemplateArgs.size());
1273 for (const TemplateArgument &TemplateArg : TemplateArgs)
1274 TemplateArg.Profile(ID, Context);
1275 TPL->Profile(ID, Context);
1276}
1277
1279 VarTemplatePartialSpecializationDecl *D, void *InsertPos) {
1280 if (InsertPos)
1281 getPartialSpecializations().InsertNode(D, InsertPos);
1282 else {
1284 getPartialSpecializations().GetOrInsertNode(D);
1285 (void)Existing;
1286 assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
1287 }
1288
1290 L->AddedCXXTemplateSpecialization(this, D);
1291}
1292
1295 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
1297 PS.clear();
1298 PS.reserve(PartialSpecs.size());
1299 for (VarTemplatePartialSpecializationDecl &P : PartialSpecs)
1300 PS.push_back(P.getMostRecentDecl());
1301}
1302
1306 Decl *DCanon = D->getCanonicalDecl();
1308 if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
1309 return P.getMostRecentDecl();
1310 }
1311
1312 return nullptr;
1313}
1314
1315//===----------------------------------------------------------------------===//
1316// VarTemplateSpecializationDecl Implementation
1317//===----------------------------------------------------------------------===//
1318
1320 Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1321 SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
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
1330 ASTContext &C)
1331 : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1332 QualType(), nullptr, SC_None),
1333 SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1334
1336 ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1337 SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1339 return new (Context, DC) VarTemplateSpecializationDecl(
1340 VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,
1341 SpecializedTemplate, T, TInfo, S, Args);
1342}
1343
1346 return new (C, ID)
1347 VarTemplateSpecializationDecl(VarTemplateSpecialization, C);
1348}
1349
1351 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
1353
1354 const auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
1355 if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
1356 PS ? PS->getTemplateArgsAsWritten() : nullptr) {
1358 OS, ArgsAsWritten->arguments(), Policy,
1359 getSpecializedTemplate()->getTemplateParameters());
1360 } else {
1361 const TemplateArgumentList &TemplateArgs = getTemplateArgs();
1363 OS, TemplateArgs.asArray(), Policy,
1364 getSpecializedTemplate()->getTemplateParameters());
1365 }
1366}
1367
1369 if (const auto *PartialSpec =
1370 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1371 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
1372 return SpecializedTemplate.get<VarTemplateDecl *>();
1373}
1374
1376 const TemplateArgumentListInfo &ArgsInfo) {
1377 TemplateArgsInfo =
1379}
1380
1382 const ASTTemplateArgumentListInfo *ArgsInfo) {
1383 TemplateArgsInfo =
1385}
1386
1388 if (isExplicitSpecialization() && !hasInit()) {
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,
1405 VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
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, DC))
1415}
1416
1419 ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1421 VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1423 const TemplateArgumentListInfo &ArgInfos) {
1424 const ASTTemplateArgumentListInfo *ASTArgInfos
1425 = ASTTemplateArgumentListInfo::Create(Context, 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
1437 unsigned ID) {
1438 return new (C, ID) VarTemplatePartialSpecializationDecl(C);
1439}
1440
1442 if (isExplicitSpecialization() && !hasInit()) {
1444 return SourceRange(getOuterLocStart(), Info->getRAngleLoc());
1445 }
1446 return VarDecl::getSourceRange();
1447}
1448
1449static TemplateParameterList *
1451 // typename T
1453 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/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(QualType(T->getTypeForDecl(), 0));
1462 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1463 /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
1464 N->setImplicit(true);
1465
1466 // <typename T, T ...Ints>
1467 NamedDecl *P[2] = {T, N};
1469 C, SourceLocation(), SourceLocation(), P, SourceLocation(), 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, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/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 QualType(TemplateTypeParm->getTypeForDecl(), 0));
1487 auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
1488 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
1489 /*Id=*/nullptr, 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>
1495 Params, SourceLocation(), nullptr);
1496}
1497
1498static TemplateParameterList *
1500 // std::size_t Index
1501 TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
1502 auto *Index = NonTypeTemplateParmDecl::Create(
1503 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
1504 /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1505
1506 // typename ...T
1508 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/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};
1516 llvm::ArrayRef(Params), SourceLocation(),
1517 nullptr);
1518}
1519
1521 const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
1522 switch (BTK) {
1527 }
1528
1529 llvm_unreachable("unhandled BuiltinTemplateKind!");
1530}
1531
1532void BuiltinTemplateDecl::anchor() {}
1533
1534BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
1535 DeclarationName Name,
1537 : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
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
1551TemplateParamObjectDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1552 auto *TPOD = new (C, ID) TemplateParamObjectDecl(nullptr, QualType(), APValue());
1553 C.addDestruction(&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
1584 switch (D->getKind()) {
1585 case Decl::Kind::CXXRecord:
1586 return cast<CXXRecordDecl>(D)
1587 ->getDescribedTemplate()
1588 ->getTemplateParameters();
1589 case Decl::Kind::ClassTemplate:
1590 return cast<ClassTemplateDecl>(D)->getTemplateParameters();
1591 case Decl::Kind::ClassTemplateSpecialization: {
1592 const auto *CTSD = cast<ClassTemplateSpecializationDecl>(D);
1593 auto P = CTSD->getSpecializedTemplateOrPartial();
1594 if (const auto *CTPSD =
1596 return CTPSD->getTemplateParameters();
1597 return cast<ClassTemplateDecl *>(P)->getTemplateParameters();
1598 }
1599 case Decl::Kind::ClassTemplatePartialSpecialization:
1600 return cast<ClassTemplatePartialSpecializationDecl>(D)
1601 ->getTemplateParameters();
1602 case Decl::Kind::TypeAliasTemplate:
1603 return cast<TypeAliasTemplateDecl>(D)->getTemplateParameters();
1604 case Decl::Kind::BuiltinTemplate:
1605 return cast<BuiltinTemplateDecl>(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>(D)
1613 ->getTemplateSpecializationInfo()
1614 ->getTemplate()
1615 ->getTemplateParameters();
1616 case Decl::Kind::FunctionTemplate:
1617 return cast<FunctionTemplateDecl>(D)->getTemplateParameters();
1618 case Decl::Kind::VarTemplate:
1619 return cast<VarTemplateDecl>(D)->getTemplateParameters();
1620 case Decl::Kind::VarTemplateSpecialization: {
1621 const auto *VTSD = cast<VarTemplateSpecializationDecl>(D);
1622 auto P = VTSD->getSpecializedTemplateOrPartial();
1623 if (const auto *VTPSD =
1625 return VTPSD->getTemplateParameters();
1626 return cast<VarTemplateDecl *>(P)->getTemplateParameters();
1627 }
1628 case Decl::Kind::VarTemplatePartialSpecialization:
1629 return cast<VarTemplatePartialSpecializationDecl>(D)
1630 ->getTemplateParameters();
1631 case Decl::Kind::TemplateTemplateParm:
1632 return cast<TemplateTemplateParmDecl>(D)->getTemplateParameters();
1633 case Decl::Kind::Concept:
1634 return cast<ConceptDecl>(D)->getTemplateParameters();
1635 default:
1636 llvm_unreachable("Unhandled templated declaration kind");
1637 }
1638}
Defines the clang::ASTContext interface.
#define V(N, I)
Definition: ASTContext.h:3259
int Id
Definition: ASTDiff.cpp:190
StringRef P
Defines enum values for all the target-independent builtin functions.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
static TemplateParameterList * createTypePackElementParameterList(const ASTContext &C, DeclContext *DC)
static TemplateParameterList * createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC)
static bool AdoptTemplateParameterList(TemplateParameterList *Params, DeclContext *Owner)
static TemplateParameterList * createBuiltinTemplateParameterList(const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK)
Defines the C++ template declaration subclasses.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
static StringRef getIdentifier(const Token &Tok)
Defines the clang::SourceLocation class and associated facilities.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
SourceLocation Begin
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
void printPretty(raw_ostream &OS, const ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:693
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2565
void getInjectedTemplateArgs(const TemplateParameterList *Params, SmallVectorImpl< TemplateArgument > &Args)
Get a template argument list with one argument per template parameter in a template parameter list,...
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1575
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:713
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1182
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition: Type.h:5524
bool isConstrained() const
Definition: Type.h:5543
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:523
Declaration of a class template.
void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D, void *InsertPos)
Insert the specified partial specialization knowing that it is not already in.
llvm::FoldingSetVector< ClassTemplateSpecializationDecl > & getSpecializations() const
Retrieve the set of specializations of this class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
static ClassTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty class template node.
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations() const
Retrieve the set of partial specializations of this class template.
ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, TemplateParameterList *TPL, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
CommonBase * newCommon(ASTContext &C) const override
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a class template node.
ClassTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *D)
Find a class template partial specialization which was instantiated from the given member partial spe...
void LoadLazySpecializations() const
Load any lazily-loaded specializations from the external source.
void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template.
Common * getCommonPtr() const
ClassTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
void Profile(llvm::FoldingSetNodeID &ID) const
static ClassTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, const TemplateArgumentListInfo &ArgInfos, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)
Represents a class template specialization, which refers to a class template with a given set of temp...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
static ClassTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getInstantiatedFrom() const
If this class template specialization is an instantiation of a template (rather than an explicit spec...
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
Declaration of a C++20 concept.
static ConceptDecl * CreateDeserialized(ASTContext &C, unsigned ID)
static ConceptDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, Expr *ConstraintExpr)
A reference to a concept and its template args, as it appears in the code.
Definition: ASTConcept.h:128
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1446
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:2647
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:440
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:501
ASTMutationListener * getASTMutationListener() const
Definition: DeclBase.cpp:511
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:88
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:984
Kind getKind() const
Definition: DeclBase.h:447
The name of a declaration.
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:770
SourceLocation getOuterLocStart() const
Return start of source range taking into account any outer template declarations.
Definition: Decl.cpp:2047
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2087
void set(ArgType Arg)
Set the default argument.
Definition: DeclTemplate.h:354
This represents one expression.
Definition: Expr.h:110
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
Definition: Expr.h:239
virtual Decl * GetExternalDecl(uint32_t ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
Declaration of a friend template.
static FriendTemplateDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc, MutableArrayRef< TemplateParameterList * > Params, FriendUnion Friend, SourceLocation FriendLoc)
static FriendTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
llvm::PointerUnion< NamedDecl *, TypeSourceInfo * > FriendUnion
Represents a function declaration or definition.
Definition: Decl.h:1959
Declaration of a template function.
Definition: DeclTemplate.h:958
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
void addSpecialization(FunctionTemplateSpecializationInfo *Info, void *InsertPos)
Add a specialization of this function template.
CommonBase * newCommon(ASTContext &C) const override
static FunctionTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty function template node.
Common * getCommonPtr() const
Definition: DeclTemplate.h:980
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > & getSpecializations() const
Retrieve the set of function template specializations of this function template.
void mergePrevDecl(FunctionTemplateDecl *Prev)
Merge Prev with our RedeclarableTemplateDecl::Common.
void LoadLazySpecializations() const
Load any lazily-loaded specializations from the external source.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:467
static FunctionTemplateSpecializationInfo * Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template, TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI, MemberSpecializationInfo *MSInfo)
One of these records is kept for each identifier that is lexed.
void setTemplateArguments(ArrayRef< TemplateArgument > Converted)
static ImplicitConceptSpecializationDecl * CreateDeserialized(const ASTContext &C, unsigned ID, unsigned NumTemplateArgs)
static ImplicitConceptSpecializationDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation SL, ArrayRef< TemplateArgument > ConvertedArgs)
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:616
This represents a decl that may have a name.
Definition: Decl.h:249
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:315
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
Definition: Decl.cpp:1826
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
SourceLocation getDefaultArgumentLoc() const
Retrieve the location of the default argument, if any.
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
static NonTypeTemplateParmDecl * CreateDeserialized(ASTContext &C, unsigned ID, bool HasTypeConstraint)
A (possibly-)qualified type.
Definition: Type.h:737
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:804
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6902
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6995
Declaration of a redeclarable template.
Definition: DeclTemplate.h:717
CommonBase * getCommonPtr() const
Retrieves the "common" pointer shared by all (re-)declarations of the same template.
SpecEntryTraits< EntryType >::DeclType * findSpecializationImpl(llvm::FoldingSetVector< EntryType > &Specs, void *&InsertPos, ProfileArguments &&...ProfileArgs)
CommonBase * Common
Pointer to the common data shared by all declarations of this template.
Definition: DeclTemplate.h:814
virtual CommonBase * newCommon(ASTContext &C) const =0
void addSpecializationImpl(llvm::FoldingSetVector< EntryType > &Specs, EntryType *Entry, void *InsertPos)
ArrayRef< TemplateArgument > getInjectedTemplateArgs()
Retrieve the "injected" template arguments that correspond to the template parameters of this templat...
RedeclarableTemplateDecl * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:204
RedeclarableTemplateDecl * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:226
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:326
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
SourceRange getBraceRange() const
Definition: Decl.h:3628
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3652
A convenient class for passing around template argument information.
Definition: TemplateBase.h:632
A template argument list.
Definition: DeclTemplate.h:244
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:274
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:524
SourceLocation getLocation() const
Definition: TemplateBase.h:563
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:574
Represents a template argument.
Definition: TemplateBase.h:61
bool isNull() const
Determine whether this template argument has no value.
Definition: TemplateBase.h:298
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:394
TemplateParameterList * TemplateParams
Definition: DeclTemplate.h:445
bool isTypeAlias() const
bool hasAssociatedConstraints() const
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:426
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: DeclTemplate.h:438
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const
Get the total constraint-expression associated with this template, including constraint-expressions d...
TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:413
Represents a C++ template name within the type system.
Definition: TemplateName.h:202
A template parameter object.
void printAsExpr(llvm::raw_ostream &OS) const
Print this object as an equivalent expression.
const APValue & getValue() const
void printName(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const override
Print this template parameter object in a human-readable format.
void printAsInit(llvm::raw_ostream &OS) const
Print this object as an initializer suitable for a variable of the object's type.
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:73
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:144
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
bool hasAssociatedConstraints() const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
Definition: DeclTemplate.h:180
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C) const
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const
All associated constraints derived from this template parameter list, including the requires clause a...
ArrayRef< NamedDecl * > asArray()
Definition: DeclTemplate.h:139
static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)
Defines the position of a template parameter within a template parameter list.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
static TemplateTemplateParmDecl * CreateDeserialized(ASTContext &C, unsigned ID)
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
SourceLocation getDefaultArgumentLoc() const
Retrieve the location of the default argument, if any.
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, TemplateParameterList *Params)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Declaration of a template type parameter.
SourceLocation getDefaultArgumentLoc() const
Retrieves the location of the default argument declaration.
unsigned getIndex() const
Retrieve the index of the template parameter.
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument's source information, if any.
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
static TemplateTypeParmDecl * CreateDeserialized(const ASTContext &C, unsigned ID)
bool isParameterPack() const
Returns whether this is a parameter pack.
unsigned getDepth() const
Retrieve the depth of the template parameter.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)
Declaration of an alias template.
CommonBase * newCommon(ASTContext &C) const override
static TypeAliasTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty alias template node.
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
Definition: ASTConcept.h:231
const Type * getTypeForDecl() const
Definition: Decl.h:3381
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.h:3386
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:3384
SourceLocation getEndLoc() const
Get the end source location.
Definition: TypeLoc.cpp:235
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:192
A container of type source information.
Definition: Type.h:6873
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:256
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6884
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7724
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
Definition: Type.h:2525
QualType getType() const
Definition: Decl.h:717
Represents a variable declaration or definition.
Definition: Decl.h:918
bool hasInit() const
Definition: Decl.cpp:2395
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2187
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2254
Declaration of a variable template.
VarTemplateDecl * getDefinition()
void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D, void *InsertPos)
Insert the specified partial specialization knowing that it is not already in.
Common * getCommonPtr() const
VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, TemplateParameterList *TPL, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
void LoadLazySpecializations() const
Load any lazily-loaded specializations from the external source.
void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
VarTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this variable template, or nullptr if no such declaration exists...
CommonBase * newCommon(ASTContext &C) const override
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations() const
Retrieve the set of partial specializations of this class template.
llvm::FoldingSetVector< VarTemplateSpecializationDecl > & getSpecializations() const
Retrieve the set of specializations of this variable template.
bool isThisDeclarationADefinition() const
Returns whether this template declaration defines the primary variable pattern.
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
VarTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(VarTemplatePartialSpecializationDecl *D)
Find a variable template partial specialization which was instantiated from the given member partial ...
static VarTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty variable template node.
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args, const TemplateArgumentListInfo &ArgInfos)
void Profile(llvm::FoldingSetNodeID &ID) const
static VarTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Represents a variable template specialization, which refers to a variable template with a given set o...
VarTemplateSpecializationDecl(Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
static VarTemplateSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
const ASTTemplateArgumentListInfo * getTemplateArgsInfo() const
static VarTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
The JSON file list parser is used to communicate input to InstallAPI.
StorageClass
Storage classes.
Definition: Specifiers.h:245
@ SC_None
Definition: Specifiers.h:247
void * allocateDefaultArgStorageChain(const ASTContext &C)
@ Result
The result type of a method or function.
TemplateParameterList * getReplacedTemplateParameterList(Decl *D)
Internal helper used by Subst* nodes to retrieve the parameter list for their AssociatedDecl.
TagTypeKind
The kind of a tag type.
Definition: Type.h:5842
BuiltinTemplateKind
Kinds of BuiltinTemplateDecl.
Definition: Builtins.h:302
@ BTK__type_pack_element
This names the __type_pack_element BuiltinTemplateDecl.
Definition: Builtins.h:307
@ BTK__make_integer_seq
This names the __make_integer_seq BuiltinTemplateDecl.
Definition: Builtins.h:304
std::optional< unsigned > getExpandedPackSize(const NamedDecl *Param)
Check whether the template parameter is a pack expansion, and if so, determine the number of paramete...
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:185
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:203
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:199
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
Definition: Specifiers.h:195
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
Definition: Specifiers.h:188
@ Struct
The "struct" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
#define true
Definition: stdbool.h:21
#define false
Definition: stdbool.h:22
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:676
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
Data that is common to all of the declarations of a given class template.
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > PartialSpecializations
The class template partial specializations for this class template.
llvm::FoldingSetVector< ClassTemplateSpecializationDecl > Specializations
The class template specializations for this class template, including explicit specializations and in...
QualType InjectedClassNameType
The injected-class-name type for this class template.
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
Definition: DeclBase.h:101
Data that is common to all of the declarations of a given function template.
Definition: DeclTemplate.h:964
llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > Specializations
The function template specializations for this function template, including explicit specializations ...
Definition: DeclTemplate.h:967
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57
unsigned AlwaysIncludeTypeForTemplateArgument
Whether to use type suffixes (eg: 1U) on integral non-type template parameters.
uint32_t * LazySpecializations
If non-null, points to an array of specializations (including partial specializations) known only by ...
Definition: DeclTemplate.h:800
Data that is common to all of the declarations of a given variable template.
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > PartialSpecializations
The variable template partial specializations for this variable template.
llvm::FoldingSetVector< VarTemplateSpecializationDecl > Specializations
The variable template specializations for this variable template, including explicit specializations ...