1 //===- DeclTemplate.h - Classes for representing C++ templates --*- C++ -*-===//
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 //===----------------------------------------------------------------------===//
11 /// Defines the C++ template declaration subclasses.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CLANG_AST_DECLTEMPLATE_H
16 #define LLVM_CLANG_AST_DECLTEMPLATE_H
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/DeclBase.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclarationName.h"
22 #include "clang/AST/Redeclarable.h"
23 #include "clang/AST/TemplateBase.h"
24 #include "clang/AST/Type.h"
25 #include "clang/Basic/LLVM.h"
26 #include "clang/Basic/SourceLocation.h"
27 #include "clang/Basic/Specifiers.h"
28 #include "llvm/ADT/ArrayRef.h"
29 #include "llvm/ADT/FoldingSet.h"
30 #include "llvm/ADT/PointerIntPair.h"
31 #include "llvm/ADT/PointerUnion.h"
32 #include "llvm/ADT/iterator.h"
33 #include "llvm/ADT/iterator_range.h"
34 #include "llvm/Support/Casting.h"
35 #include "llvm/Support/Compiler.h"
36 #include "llvm/Support/TrailingObjects.h"
45 enum BuiltinTemplateKind : int;
46 class ClassTemplateDecl;
47 class ClassTemplatePartialSpecializationDecl;
49 class FunctionTemplateDecl;
51 class NonTypeTemplateParmDecl;
53 class TemplateTemplateParmDecl;
54 class TemplateTypeParmDecl;
55 class UnresolvedSetImpl;
56 class VarTemplateDecl;
57 class VarTemplatePartialSpecializationDecl;
59 /// Stores a template parameter of any kind.
60 using TemplateParameter =
61 llvm::PointerUnion3<TemplateTypeParmDecl *, NonTypeTemplateParmDecl *,
62 TemplateTemplateParmDecl *>;
64 NamedDecl *getAsNamedDecl(TemplateParameter P);
66 /// Stores a list of template parameters for a TemplateDecl and its
68 class TemplateParameterList final
69 : private llvm::TrailingObjects<TemplateParameterList, NamedDecl *,
71 /// The location of the 'template' keyword.
72 SourceLocation TemplateLoc;
74 /// The locations of the '<' and '>' angle brackets.
75 SourceLocation LAngleLoc, RAngleLoc;
77 /// The number of template parameters in this template
79 unsigned NumParams : 30;
81 /// Whether this template parameter list contains an unexpanded parameter
83 unsigned ContainsUnexpandedParameterPack : 1;
85 /// Whether this template parameter list has an associated requires-clause
86 unsigned HasRequiresClause : 1;
89 TemplateParameterList(SourceLocation TemplateLoc, SourceLocation LAngleLoc,
90 ArrayRef<NamedDecl *> Params, SourceLocation RAngleLoc,
91 Expr *RequiresClause);
93 size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
97 size_t numTrailingObjects(OverloadToken<Expr *>) const {
98 return HasRequiresClause;
102 template <size_t N, bool HasRequiresClause>
103 friend class FixedSizeTemplateParameterListStorage;
104 friend TrailingObjects;
106 static TemplateParameterList *Create(const ASTContext &C,
107 SourceLocation TemplateLoc,
108 SourceLocation LAngleLoc,
109 ArrayRef<NamedDecl *> Params,
110 SourceLocation RAngleLoc,
111 Expr *RequiresClause);
113 /// Iterates through the template parameters in this list.
114 using iterator = NamedDecl **;
116 /// Iterates through the template parameters in this list.
117 using const_iterator = NamedDecl * const *;
119 iterator begin() { return getTrailingObjects<NamedDecl *>(); }
120 const_iterator begin() const { return getTrailingObjects<NamedDecl *>(); }
121 iterator end() { return begin() + NumParams; }
122 const_iterator end() const { return begin() + NumParams; }
124 unsigned size() const { return NumParams; }
126 ArrayRef<NamedDecl*> asArray() {
127 return llvm::makeArrayRef(begin(), end());
129 ArrayRef<const NamedDecl*> asArray() const {
130 return llvm::makeArrayRef(begin(), size());
133 NamedDecl* getParam(unsigned Idx) {
134 assert(Idx < size() && "Template parameter index out-of-range");
137 const NamedDecl* getParam(unsigned Idx) const {
138 assert(Idx < size() && "Template parameter index out-of-range");
142 /// Returns the minimum number of arguments needed to form a
143 /// template specialization.
145 /// This may be fewer than the number of template parameters, if some of
146 /// the parameters have default arguments or if there is a parameter pack.
147 unsigned getMinRequiredArguments() const;
149 /// Get the depth of this template parameter list in the set of
150 /// template parameter lists.
152 /// The first template parameter list in a declaration will have depth 0,
153 /// the second template parameter list will have depth 1, etc.
154 unsigned getDepth() const;
156 /// Determine whether this template parameter list contains an
157 /// unexpanded parameter pack.
158 bool containsUnexpandedParameterPack() const {
159 return ContainsUnexpandedParameterPack;
162 /// The constraint-expression of the associated requires-clause.
163 Expr *getRequiresClause() {
164 return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
167 /// The constraint-expression of the associated requires-clause.
168 const Expr *getRequiresClause() const {
169 return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
172 SourceLocation getTemplateLoc() const { return TemplateLoc; }
173 SourceLocation getLAngleLoc() const { return LAngleLoc; }
174 SourceLocation getRAngleLoc() const { return RAngleLoc; }
176 SourceRange getSourceRange() const LLVM_READONLY {
177 return SourceRange(TemplateLoc, RAngleLoc);
181 // FIXME: workaround for MSVC 2013; remove when no longer needed
182 using FixedSizeStorageOwner = TrailingObjects::FixedSizeStorageOwner;
185 /// Stores a list of template parameters and the associated
186 /// requires-clause (if any) for a TemplateDecl and its derived classes.
187 /// Suitable for creating on the stack.
188 template <size_t N, bool HasRequiresClause>
189 class FixedSizeTemplateParameterListStorage
190 : public TemplateParameterList::FixedSizeStorageOwner {
191 typename TemplateParameterList::FixedSizeStorage<
192 NamedDecl *, Expr *>::with_counts<
193 N, HasRequiresClause ? 1u : 0u
197 FixedSizeTemplateParameterListStorage(SourceLocation TemplateLoc,
198 SourceLocation LAngleLoc,
199 ArrayRef<NamedDecl *> Params,
200 SourceLocation RAngleLoc,
201 Expr *RequiresClause)
202 : FixedSizeStorageOwner(
203 (assert(N == Params.size()),
204 assert(HasRequiresClause == static_cast<bool>(RequiresClause)),
205 new (static_cast<void *>(&storage)) TemplateParameterList(
206 TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause))) {}
209 /// A template argument list.
210 class TemplateArgumentList final
211 : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {
212 /// The template argument list.
213 const TemplateArgument *Arguments;
215 /// The number of template arguments in this template
217 unsigned NumArguments;
219 // Constructs an instance with an internal Argument list, containing
220 // a copy of the Args array. (Called by CreateCopy)
221 TemplateArgumentList(ArrayRef<TemplateArgument> Args);
224 friend TrailingObjects;
226 TemplateArgumentList(const TemplateArgumentList &) = delete;
227 TemplateArgumentList &operator=(const TemplateArgumentList &) = delete;
229 /// Type used to indicate that the template argument list itself is a
230 /// stack object. It does not own its template arguments.
231 enum OnStackType { OnStack };
233 /// Create a new template argument list that copies the given set of
234 /// template arguments.
235 static TemplateArgumentList *CreateCopy(ASTContext &Context,
236 ArrayRef<TemplateArgument> Args);
238 /// Construct a new, temporary template argument list on the stack.
240 /// The template argument list does not own the template arguments
242 explicit TemplateArgumentList(OnStackType, ArrayRef<TemplateArgument> Args)
243 : Arguments(Args.data()), NumArguments(Args.size()) {}
245 /// Produces a shallow copy of the given template argument list.
247 /// This operation assumes that the input argument list outlives it.
248 /// This takes the list as a pointer to avoid looking like a copy
249 /// constructor, since this really really isn't safe to use that
251 explicit TemplateArgumentList(const TemplateArgumentList *Other)
252 : Arguments(Other->data()), NumArguments(Other->size()) {}
254 /// Retrieve the template argument at a given index.
255 const TemplateArgument &get(unsigned Idx) const {
256 assert(Idx < NumArguments && "Invalid template argument index");
260 /// Retrieve the template argument at a given index.
261 const TemplateArgument &operator[](unsigned Idx) const { return get(Idx); }
263 /// Produce this as an array ref.
264 ArrayRef<TemplateArgument> asArray() const {
265 return llvm::makeArrayRef(data(), size());
268 /// Retrieve the number of template arguments in this
269 /// template argument list.
270 unsigned size() const { return NumArguments; }
272 /// Retrieve a pointer to the template argument list.
273 const TemplateArgument *data() const { return Arguments; }
276 void *allocateDefaultArgStorageChain(const ASTContext &C);
278 /// Storage for a default argument. This is conceptually either empty, or an
279 /// argument value, or a pointer to a previous declaration that had a default
282 /// However, this is complicated by modules: while we require all the default
283 /// arguments for a template to be equivalent, there may be more than one, and
284 /// we need to track all the originating parameters to determine if the default
285 /// argument is visible.
286 template<typename ParmDecl, typename ArgType>
287 class DefaultArgStorage {
288 /// Storage for both the value *and* another parameter from which we inherit
289 /// the default argument. This is used when multiple default arguments for a
290 /// parameter are merged together from different modules.
292 ParmDecl *PrevDeclWithDefaultArg;
295 static_assert(sizeof(Chain) == sizeof(void *) * 2,
296 "non-pointer argument type?");
298 llvm::PointerUnion3<ArgType, ParmDecl*, Chain*> ValueOrInherited;
300 static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {
301 const DefaultArgStorage &Storage = Parm->getDefaultArgStorage();
302 if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl *>())
304 assert(!Parm->getDefaultArgStorage()
305 .ValueOrInherited.template is<ParmDecl *>() &&
306 "should only be one level of indirection");
311 DefaultArgStorage() : ValueOrInherited(ArgType()) {}
313 /// Determine whether there is a default argument for this parameter.
314 bool isSet() const { return !ValueOrInherited.isNull(); }
316 /// Determine whether the default argument for this parameter was inherited
317 /// from a previous declaration of the same entity.
318 bool isInherited() const { return ValueOrInherited.template is<ParmDecl*>(); }
320 /// Get the default argument's value. This does not consider whether the
321 /// default argument is visible.
322 ArgType get() const {
323 const DefaultArgStorage *Storage = this;
324 if (const auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl *>())
325 Storage = &Prev->getDefaultArgStorage();
326 if (const auto *C = Storage->ValueOrInherited.template dyn_cast<Chain *>())
328 return Storage->ValueOrInherited.template get<ArgType>();
331 /// Get the parameter from which we inherit the default argument, if any.
332 /// This is the parameter on which the default argument was actually written.
333 const ParmDecl *getInheritedFrom() const {
334 if (const auto *D = ValueOrInherited.template dyn_cast<ParmDecl *>())
336 if (const auto *C = ValueOrInherited.template dyn_cast<Chain *>())
337 return C->PrevDeclWithDefaultArg;
341 /// Set the default argument.
342 void set(ArgType Arg) {
343 assert(!isSet() && "default argument already set");
344 ValueOrInherited = Arg;
347 /// Set that the default argument was inherited from another parameter.
348 void setInherited(const ASTContext &C, ParmDecl *InheritedFrom) {
349 assert(!isInherited() && "default argument already inherited");
350 InheritedFrom = getParmOwningDefaultArg(InheritedFrom);
352 ValueOrInherited = InheritedFrom;
354 ValueOrInherited = new (allocateDefaultArgStorageChain(C))
355 Chain{InheritedFrom, ValueOrInherited.template get<ArgType>()};
358 /// Remove the default argument, even if it was inherited.
360 ValueOrInherited = ArgType();
364 //===----------------------------------------------------------------------===//
365 // Kinds of Templates
366 //===----------------------------------------------------------------------===//
368 /// Stores the template parameter list and associated constraints for
369 /// \c TemplateDecl objects that track associated constraints.
370 class ConstrainedTemplateDeclInfo {
374 ConstrainedTemplateDeclInfo() = default;
376 TemplateParameterList *getTemplateParameters() const {
377 return TemplateParams;
380 Expr *getAssociatedConstraints() const { return AssociatedConstraints; }
383 void setTemplateParameters(TemplateParameterList *TParams) {
384 TemplateParams = TParams;
387 void setAssociatedConstraints(Expr *AC) { AssociatedConstraints = AC; }
389 TemplateParameterList *TemplateParams = nullptr;
390 Expr *AssociatedConstraints = nullptr;
394 /// The base class of all kinds of template declarations (e.g.,
395 /// class, function, etc.).
397 /// The TemplateDecl class stores the list of template parameters and a
398 /// reference to the templated scoped declaration: the underlying AST node.
399 class TemplateDecl : public NamedDecl {
400 void anchor() override;
403 // Construct a template decl with the given name and parameters.
404 // Used when there is no templated element (e.g., for tt-params).
405 TemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK, DeclContext *DC,
406 SourceLocation L, DeclarationName Name,
407 TemplateParameterList *Params)
408 : NamedDecl(DK, DC, L, Name), TemplatedDecl(nullptr),
409 TemplateParams(CTDI) {
410 this->setTemplateParameters(Params);
413 TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,
414 TemplateParameterList *Params)
415 : TemplateDecl(nullptr, DK, DC, L, Name, Params) {}
417 // Construct a template decl with name, parameters, and templated element.
418 TemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK, DeclContext *DC,
419 SourceLocation L, DeclarationName Name,
420 TemplateParameterList *Params, NamedDecl *Decl)
421 : NamedDecl(DK, DC, L, Name), TemplatedDecl(Decl),
422 TemplateParams(CTDI) {
423 this->setTemplateParameters(Params);
426 TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,
427 TemplateParameterList *Params, NamedDecl *Decl)
428 : TemplateDecl(nullptr, DK, DC, L, Name, Params, Decl) {}
431 /// Get the list of template parameters
432 TemplateParameterList *getTemplateParameters() const {
433 const auto *const CTDI =
434 TemplateParams.dyn_cast<ConstrainedTemplateDeclInfo *>();
435 return CTDI ? CTDI->getTemplateParameters()
436 : TemplateParams.get<TemplateParameterList *>();
439 /// Get the constraint-expression from the associated requires-clause (if any)
440 const Expr *getRequiresClause() const {
441 const TemplateParameterList *const TP = getTemplateParameters();
442 return TP ? TP->getRequiresClause() : nullptr;
445 Expr *getAssociatedConstraints() const {
446 const auto *const C = cast<TemplateDecl>(getCanonicalDecl());
447 const auto *const CTDI =
448 C->TemplateParams.dyn_cast<ConstrainedTemplateDeclInfo *>();
449 return CTDI ? CTDI->getAssociatedConstraints() : nullptr;
452 /// Get the underlying, templated declaration.
453 NamedDecl *getTemplatedDecl() const { return TemplatedDecl; }
455 // Implement isa/cast/dyncast/etc.
456 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
458 static bool classofKind(Kind K) {
459 return K >= firstTemplate && K <= lastTemplate;
462 SourceRange getSourceRange() const override LLVM_READONLY {
463 return SourceRange(getTemplateParameters()->getTemplateLoc(),
464 TemplatedDecl->getSourceRange().getEnd());
468 NamedDecl *TemplatedDecl;
470 /// The template parameter list and optional requires-clause
471 /// associated with this declaration; alternatively, a
472 /// \c ConstrainedTemplateDeclInfo if the associated constraints of the
473 /// template are being tracked by this particular declaration.
474 llvm::PointerUnion<TemplateParameterList *,
475 ConstrainedTemplateDeclInfo *>
478 void setTemplateParameters(TemplateParameterList *TParams) {
479 if (auto *const CTDI =
480 TemplateParams.dyn_cast<ConstrainedTemplateDeclInfo *>()) {
481 CTDI->setTemplateParameters(TParams);
483 TemplateParams = TParams;
487 void setAssociatedConstraints(Expr *AC) {
488 assert(isCanonicalDecl() &&
489 "Attaching associated constraints to non-canonical Decl");
490 TemplateParams.get<ConstrainedTemplateDeclInfo *>()
491 ->setAssociatedConstraints(AC);
495 /// Initialize the underlying templated declaration and
496 /// template parameters.
497 void init(NamedDecl *templatedDecl, TemplateParameterList* templateParams) {
498 assert(!TemplatedDecl && "TemplatedDecl already set!");
499 assert(!TemplateParams && "TemplateParams already set!");
500 TemplatedDecl = templatedDecl;
501 TemplateParams = templateParams;
505 /// Provides information about a function template specialization,
506 /// which is a FunctionDecl that has been explicitly specialization or
507 /// instantiated from a function template.
508 class FunctionTemplateSpecializationInfo : public llvm::FoldingSetNode {
509 FunctionTemplateSpecializationInfo(FunctionDecl *FD,
510 FunctionTemplateDecl *Template,
511 TemplateSpecializationKind TSK,
512 const TemplateArgumentList *TemplateArgs,
513 const ASTTemplateArgumentListInfo *TemplateArgsAsWritten,
515 : Function(FD), Template(Template, TSK - 1),
516 TemplateArguments(TemplateArgs),
517 TemplateArgumentsAsWritten(TemplateArgsAsWritten),
518 PointOfInstantiation(POI) {}
521 static FunctionTemplateSpecializationInfo *
522 Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template,
523 TemplateSpecializationKind TSK,
524 const TemplateArgumentList *TemplateArgs,
525 const TemplateArgumentListInfo *TemplateArgsAsWritten,
528 /// The function template specialization that this structure
530 FunctionDecl *Function;
532 /// The function template from which this function template
533 /// specialization was generated.
535 /// The two bits contain the top 4 values of TemplateSpecializationKind.
536 llvm::PointerIntPair<FunctionTemplateDecl *, 2> Template;
538 /// The template arguments used to produce the function template
539 /// specialization from the function template.
540 const TemplateArgumentList *TemplateArguments;
542 /// The template arguments as written in the sources, if provided.
543 const ASTTemplateArgumentListInfo *TemplateArgumentsAsWritten;
545 /// The point at which this function template specialization was
546 /// first instantiated.
547 SourceLocation PointOfInstantiation;
549 /// Retrieve the template from which this function was specialized.
550 FunctionTemplateDecl *getTemplate() const { return Template.getPointer(); }
552 /// Determine what kind of template specialization this is.
553 TemplateSpecializationKind getTemplateSpecializationKind() const {
554 return (TemplateSpecializationKind)(Template.getInt() + 1);
557 bool isExplicitSpecialization() const {
558 return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
561 /// True if this declaration is an explicit specialization,
562 /// explicit instantiation declaration, or explicit instantiation
564 bool isExplicitInstantiationOrSpecialization() const {
565 return isTemplateExplicitInstantiationOrSpecialization(
566 getTemplateSpecializationKind());
569 /// Set the template specialization kind.
570 void setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
571 assert(TSK != TSK_Undeclared &&
572 "Cannot encode TSK_Undeclared for a function template specialization");
573 Template.setInt(TSK - 1);
576 /// Retrieve the first point of instantiation of this function
577 /// template specialization.
579 /// The point of instantiation may be an invalid source location if this
580 /// function has yet to be instantiated.
581 SourceLocation getPointOfInstantiation() const {
582 return PointOfInstantiation;
585 /// Set the (first) point of instantiation of this function template
587 void setPointOfInstantiation(SourceLocation POI) {
588 PointOfInstantiation = POI;
591 void Profile(llvm::FoldingSetNodeID &ID) {
592 Profile(ID, TemplateArguments->asArray(),
593 Function->getASTContext());
597 Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
598 ASTContext &Context) {
599 ID.AddInteger(TemplateArgs.size());
600 for (const TemplateArgument &TemplateArg : TemplateArgs)
601 TemplateArg.Profile(ID, Context);
605 /// Provides information a specialization of a member of a class
606 /// template, which may be a member function, static data member,
607 /// member class or member enumeration.
608 class MemberSpecializationInfo {
609 // The member declaration from which this member was instantiated, and the
610 // manner in which the instantiation occurred (in the lower two bits).
611 llvm::PointerIntPair<NamedDecl *, 2> MemberAndTSK;
613 // The point at which this member was first instantiated.
614 SourceLocation PointOfInstantiation;
618 MemberSpecializationInfo(NamedDecl *IF, TemplateSpecializationKind TSK,
619 SourceLocation POI = SourceLocation())
620 : MemberAndTSK(IF, TSK - 1), PointOfInstantiation(POI) {
621 assert(TSK != TSK_Undeclared &&
622 "Cannot encode undeclared template specializations for members");
625 /// Retrieve the member declaration from which this member was
627 NamedDecl *getInstantiatedFrom() const { return MemberAndTSK.getPointer(); }
629 /// Determine what kind of template specialization this is.
630 TemplateSpecializationKind getTemplateSpecializationKind() const {
631 return (TemplateSpecializationKind)(MemberAndTSK.getInt() + 1);
634 bool isExplicitSpecialization() const {
635 return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
638 /// Set the template specialization kind.
639 void setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
640 assert(TSK != TSK_Undeclared &&
641 "Cannot encode undeclared template specializations for members");
642 MemberAndTSK.setInt(TSK - 1);
645 /// Retrieve the first point of instantiation of this member.
646 /// If the point of instantiation is an invalid location, then this member
647 /// has not yet been instantiated.
648 SourceLocation getPointOfInstantiation() const {
649 return PointOfInstantiation;
652 /// Set the first point of instantiation.
653 void setPointOfInstantiation(SourceLocation POI) {
654 PointOfInstantiation = POI;
658 /// Provides information about a dependent function-template
659 /// specialization declaration.
661 /// Since explicit function template specialization and instantiation
662 /// declarations can only appear in namespace scope, and you can only
663 /// specialize a member of a fully-specialized class, the only way to
664 /// get one of these is in a friend declaration like the following:
667 /// template \<class T> void foo(T);
668 /// template \<class T> class A {
669 /// friend void foo<>(T);
672 class DependentFunctionTemplateSpecializationInfo final
673 : private llvm::TrailingObjects<DependentFunctionTemplateSpecializationInfo,
675 FunctionTemplateDecl *> {
676 /// The number of potential template candidates.
677 unsigned NumTemplates;
679 /// The number of template arguments.
682 /// The locations of the left and right angle brackets.
683 SourceRange AngleLocs;
685 size_t numTrailingObjects(OverloadToken<TemplateArgumentLoc>) const {
688 size_t numTrailingObjects(OverloadToken<FunctionTemplateDecl *>) const {
692 DependentFunctionTemplateSpecializationInfo(
693 const UnresolvedSetImpl &Templates,
694 const TemplateArgumentListInfo &TemplateArgs);
697 friend TrailingObjects;
699 static DependentFunctionTemplateSpecializationInfo *
700 Create(ASTContext &Context, const UnresolvedSetImpl &Templates,
701 const TemplateArgumentListInfo &TemplateArgs);
703 /// Returns the number of function templates that this might
704 /// be a specialization of.
705 unsigned getNumTemplates() const { return NumTemplates; }
707 /// Returns the i'th template candidate.
708 FunctionTemplateDecl *getTemplate(unsigned I) const {
709 assert(I < getNumTemplates() && "template index out of range");
710 return getTrailingObjects<FunctionTemplateDecl *>()[I];
713 /// Returns the explicit template arguments that were given.
714 const TemplateArgumentLoc *getTemplateArgs() const {
715 return getTrailingObjects<TemplateArgumentLoc>();
718 /// Returns the number of explicit template arguments that were given.
719 unsigned getNumTemplateArgs() const { return NumArgs; }
721 /// Returns the nth template argument.
722 const TemplateArgumentLoc &getTemplateArg(unsigned I) const {
723 assert(I < getNumTemplateArgs() && "template arg index out of range");
724 return getTemplateArgs()[I];
727 SourceLocation getLAngleLoc() const {
728 return AngleLocs.getBegin();
731 SourceLocation getRAngleLoc() const {
732 return AngleLocs.getEnd();
736 /// Declaration of a redeclarable template.
737 class RedeclarableTemplateDecl : public TemplateDecl,
738 public Redeclarable<RedeclarableTemplateDecl>
740 using redeclarable_base = Redeclarable<RedeclarableTemplateDecl>;
742 RedeclarableTemplateDecl *getNextRedeclarationImpl() override {
743 return getNextRedeclaration();
746 RedeclarableTemplateDecl *getPreviousDeclImpl() override {
747 return getPreviousDecl();
750 RedeclarableTemplateDecl *getMostRecentDeclImpl() override {
751 return getMostRecentDecl();
755 template <typename EntryType> struct SpecEntryTraits {
756 using DeclType = EntryType;
758 static DeclType *getDecl(EntryType *D) {
762 static ArrayRef<TemplateArgument> getTemplateArgs(EntryType *D) {
763 return D->getTemplateArgs().asArray();
767 template <typename EntryType, typename SETraits = SpecEntryTraits<EntryType>,
768 typename DeclType = typename SETraits::DeclType>
770 : llvm::iterator_adaptor_base<
771 SpecIterator<EntryType, SETraits, DeclType>,
772 typename llvm::FoldingSetVector<EntryType>::iterator,
773 typename std::iterator_traits<typename llvm::FoldingSetVector<
774 EntryType>::iterator>::iterator_category,
775 DeclType *, ptrdiff_t, DeclType *, DeclType *> {
776 SpecIterator() = default;
777 explicit SpecIterator(
778 typename llvm::FoldingSetVector<EntryType>::iterator SetIter)
779 : SpecIterator::iterator_adaptor_base(std::move(SetIter)) {}
781 DeclType *operator*() const {
782 return SETraits::getDecl(&*this->I)->getMostRecentDecl();
785 DeclType *operator->() const { return **this; }
788 template <typename EntryType>
789 static SpecIterator<EntryType>
790 makeSpecIterator(llvm::FoldingSetVector<EntryType> &Specs, bool isEnd) {
791 return SpecIterator<EntryType>(isEnd ? Specs.end() : Specs.begin());
794 void loadLazySpecializationsImpl() const;
796 template <class EntryType> typename SpecEntryTraits<EntryType>::DeclType*
797 findSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs,
798 ArrayRef<TemplateArgument> Args, void *&InsertPos);
800 template <class Derived, class EntryType>
801 void addSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs,
802 EntryType *Entry, void *InsertPos);
805 CommonBase() : InstantiatedFromMember(nullptr, false) {}
807 /// The template from which this was most
808 /// directly instantiated (or null).
810 /// The boolean value indicates whether this template
811 /// was explicitly specialized.
812 llvm::PointerIntPair<RedeclarableTemplateDecl*, 1, bool>
813 InstantiatedFromMember;
815 /// If non-null, points to an array of specializations (including
816 /// partial specializations) known only by their external declaration IDs.
818 /// The first value in the array is the number of specializations/partial
819 /// specializations that follow.
820 uint32_t *LazySpecializations = nullptr;
823 /// Pointer to the common data shared by all declarations of this
825 mutable CommonBase *Common = nullptr;
827 /// Retrieves the "common" pointer shared by all (re-)declarations of
828 /// the same template. Calling this routine may implicitly allocate memory
829 /// for the common pointer.
830 CommonBase *getCommonPtr() const;
832 virtual CommonBase *newCommon(ASTContext &C) const = 0;
834 // Construct a template decl with name, parameters, and templated element.
835 RedeclarableTemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK,
836 ASTContext &C, DeclContext *DC, SourceLocation L,
837 DeclarationName Name, TemplateParameterList *Params,
839 : TemplateDecl(CTDI, DK, DC, L, Name, Params, Decl), redeclarable_base(C)
842 RedeclarableTemplateDecl(Kind DK, ASTContext &C, DeclContext *DC,
843 SourceLocation L, DeclarationName Name,
844 TemplateParameterList *Params, NamedDecl *Decl)
845 : RedeclarableTemplateDecl(nullptr, DK, C, DC, L, Name, Params, Decl) {}
848 friend class ASTDeclReader;
849 friend class ASTDeclWriter;
850 friend class ASTReader;
851 template <class decl_type> friend class RedeclarableTemplate;
853 /// Retrieves the canonical declaration of this template.
854 RedeclarableTemplateDecl *getCanonicalDecl() override {
855 return getFirstDecl();
857 const RedeclarableTemplateDecl *getCanonicalDecl() const {
858 return getFirstDecl();
861 /// Determines whether this template was a specialization of a
864 /// In the following example, the function template \c X<int>::f and the
865 /// member template \c X<int>::Inner are member specializations.
868 /// template<typename T>
870 /// template<typename U> void f(T, U);
871 /// template<typename U> struct Inner;
874 /// template<> template<typename T>
875 /// void X<int>::f(int, T);
876 /// template<> template<typename T>
877 /// struct X<int>::Inner { /* ... */ };
879 bool isMemberSpecialization() const {
880 return getCommonPtr()->InstantiatedFromMember.getInt();
883 /// Note that this member template is a specialization.
884 void setMemberSpecialization() {
885 assert(getCommonPtr()->InstantiatedFromMember.getPointer() &&
886 "Only member templates can be member template specializations");
887 getCommonPtr()->InstantiatedFromMember.setInt(true);
890 /// Retrieve the member template from which this template was
891 /// instantiated, or nullptr if this template was not instantiated from a
894 /// A template is instantiated from a member template when the member
895 /// template itself is part of a class template (or member thereof). For
899 /// template<typename T>
901 /// template<typename U> void f(T, U);
904 /// void test(X<int> x) {
909 /// \c X<int>::f is a FunctionTemplateDecl that describes the function
913 /// template<typename U> void X<int>::f(int, U);
916 /// which was itself created during the instantiation of \c X<int>. Calling
917 /// getInstantiatedFromMemberTemplate() on this FunctionTemplateDecl will
918 /// retrieve the FunctionTemplateDecl for the original template \c f within
919 /// the class template \c X<T>, i.e.,
922 /// template<typename T>
923 /// template<typename U>
924 /// void X<T>::f(T, U);
926 RedeclarableTemplateDecl *getInstantiatedFromMemberTemplate() const {
927 return getCommonPtr()->InstantiatedFromMember.getPointer();
930 void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD) {
931 assert(!getCommonPtr()->InstantiatedFromMember.getPointer());
932 getCommonPtr()->InstantiatedFromMember.setPointer(TD);
935 using redecl_range = redeclarable_base::redecl_range;
936 using redecl_iterator = redeclarable_base::redecl_iterator;
938 using redeclarable_base::redecls_begin;
939 using redeclarable_base::redecls_end;
940 using redeclarable_base::redecls;
941 using redeclarable_base::getPreviousDecl;
942 using redeclarable_base::getMostRecentDecl;
943 using redeclarable_base::isFirstDecl;
945 // Implement isa/cast/dyncast/etc.
946 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
948 static bool classofKind(Kind K) {
949 return K >= firstRedeclarableTemplate && K <= lastRedeclarableTemplate;
953 template <> struct RedeclarableTemplateDecl::
954 SpecEntryTraits<FunctionTemplateSpecializationInfo> {
955 using DeclType = FunctionDecl;
957 static DeclType *getDecl(FunctionTemplateSpecializationInfo *I) {
961 static ArrayRef<TemplateArgument>
962 getTemplateArgs(FunctionTemplateSpecializationInfo *I) {
963 return I->TemplateArguments->asArray();
967 /// Declaration of a template function.
968 class FunctionTemplateDecl : public RedeclarableTemplateDecl {
970 friend class FunctionDecl;
972 /// Data that is common to all of the declarations of a given
973 /// function template.
974 struct Common : CommonBase {
975 /// The function template specializations for this function
976 /// template, including explicit specializations and instantiations.
977 llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> Specializations;
979 /// The set of "injected" template arguments used within this
980 /// function template.
982 /// This pointer refers to the template arguments (there are as
983 /// many template arguments as template parameaters) for the function
984 /// template, and is allocated lazily, since most function templates do not
985 /// require the use of this information.
986 TemplateArgument *InjectedArgs = nullptr;
991 FunctionTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
992 DeclarationName Name, TemplateParameterList *Params,
994 : RedeclarableTemplateDecl(FunctionTemplate, C, DC, L, Name, Params,
997 CommonBase *newCommon(ASTContext &C) const override;
999 Common *getCommonPtr() const {
1000 return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
1003 /// Retrieve the set of function template specializations of this
1004 /// function template.
1005 llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
1006 getSpecializations() const;
1008 /// Add a specialization of this function template.
1010 /// \param InsertPos Insert position in the FoldingSetVector, must have been
1011 /// retrieved by an earlier call to findSpecialization().
1012 void addSpecialization(FunctionTemplateSpecializationInfo* Info,
1016 friend class ASTDeclReader;
1017 friend class ASTDeclWriter;
1019 /// Load any lazily-loaded specializations from the external source.
1020 void LoadLazySpecializations() const;
1022 /// Get the underlying function declaration of the template.
1023 FunctionDecl *getTemplatedDecl() const {
1024 return static_cast<FunctionDecl *>(TemplatedDecl);
1027 /// Returns whether this template declaration defines the primary
1029 bool isThisDeclarationADefinition() const {
1030 return getTemplatedDecl()->isThisDeclarationADefinition();
1033 /// Return the specialization with the provided arguments if it exists,
1034 /// otherwise return the insertion point.
1035 FunctionDecl *findSpecialization(ArrayRef<TemplateArgument> Args,
1038 FunctionTemplateDecl *getCanonicalDecl() override {
1039 return cast<FunctionTemplateDecl>(
1040 RedeclarableTemplateDecl::getCanonicalDecl());
1042 const FunctionTemplateDecl *getCanonicalDecl() const {
1043 return cast<FunctionTemplateDecl>(
1044 RedeclarableTemplateDecl::getCanonicalDecl());
1047 /// Retrieve the previous declaration of this function template, or
1048 /// nullptr if no such declaration exists.
1049 FunctionTemplateDecl *getPreviousDecl() {
1050 return cast_or_null<FunctionTemplateDecl>(
1051 static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
1053 const FunctionTemplateDecl *getPreviousDecl() const {
1054 return cast_or_null<FunctionTemplateDecl>(
1055 static_cast<const RedeclarableTemplateDecl *>(this)->getPreviousDecl());
1058 FunctionTemplateDecl *getMostRecentDecl() {
1059 return cast<FunctionTemplateDecl>(
1060 static_cast<RedeclarableTemplateDecl *>(this)
1061 ->getMostRecentDecl());
1063 const FunctionTemplateDecl *getMostRecentDecl() const {
1064 return const_cast<FunctionTemplateDecl*>(this)->getMostRecentDecl();
1067 FunctionTemplateDecl *getInstantiatedFromMemberTemplate() const {
1068 return cast_or_null<FunctionTemplateDecl>(
1069 RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
1072 using spec_iterator = SpecIterator<FunctionTemplateSpecializationInfo>;
1073 using spec_range = llvm::iterator_range<spec_iterator>;
1075 spec_range specializations() const {
1076 return spec_range(spec_begin(), spec_end());
1079 spec_iterator spec_begin() const {
1080 return makeSpecIterator(getSpecializations(), false);
1083 spec_iterator spec_end() const {
1084 return makeSpecIterator(getSpecializations(), true);
1087 /// Retrieve the "injected" template arguments that correspond to the
1088 /// template parameters of this function template.
1090 /// Although the C++ standard has no notion of the "injected" template
1091 /// arguments for a function template, the notion is convenient when
1092 /// we need to perform substitutions inside the definition of a function
1094 ArrayRef<TemplateArgument> getInjectedTemplateArgs();
1096 /// Create a function template node.
1097 static FunctionTemplateDecl *Create(ASTContext &C, DeclContext *DC,
1099 DeclarationName Name,
1100 TemplateParameterList *Params,
1103 /// Create an empty function template node.
1104 static FunctionTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1106 // Implement isa/cast/dyncast support
1107 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1108 static bool classofKind(Kind K) { return K == FunctionTemplate; }
1111 //===----------------------------------------------------------------------===//
1112 // Kinds of Template Parameters
1113 //===----------------------------------------------------------------------===//
1115 /// Defines the position of a template parameter within a template
1118 /// Because template parameter can be listed
1119 /// sequentially for out-of-line template members, each template parameter is
1120 /// given a Depth - the nesting of template parameter scopes - and a Position -
1121 /// the occurrence within the parameter list.
1122 /// This class is inheritedly privately by different kinds of template
1123 /// parameters and is not part of the Decl hierarchy. Just a facility.
1124 class TemplateParmPosition {
1126 // FIXME: These probably don't need to be ints. int:5 for depth, int:8 for
1131 TemplateParmPosition(unsigned D, unsigned P) : Depth(D), Position(P) {}
1134 TemplateParmPosition() = delete;
1136 /// Get the nesting depth of the template parameter.
1137 unsigned getDepth() const { return Depth; }
1138 void setDepth(unsigned D) { Depth = D; }
1140 /// Get the position of the template parameter within its parameter list.
1141 unsigned getPosition() const { return Position; }
1142 void setPosition(unsigned P) { Position = P; }
1144 /// Get the index of the template parameter within its parameter list.
1145 unsigned getIndex() const { return Position; }
1148 /// Declaration of a template type parameter.
1150 /// For example, "T" in
1152 /// template<typename T> class vector;
1154 class TemplateTypeParmDecl : public TypeDecl {
1155 /// Sema creates these on the stack during auto type deduction.
1158 /// Whether this template type parameter was declaration with
1159 /// the 'typename' keyword.
1161 /// If false, it was declared with the 'class' keyword.
1164 /// The default template argument, if any.
1165 using DefArgStorage =
1166 DefaultArgStorage<TemplateTypeParmDecl, TypeSourceInfo *>;
1167 DefArgStorage DefaultArgument;
1169 TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc,
1170 SourceLocation IdLoc, IdentifierInfo *Id,
1172 : TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename) {}
1175 static TemplateTypeParmDecl *Create(const ASTContext &C, DeclContext *DC,
1176 SourceLocation KeyLoc,
1177 SourceLocation NameLoc,
1178 unsigned D, unsigned P,
1179 IdentifierInfo *Id, bool Typename,
1180 bool ParameterPack);
1181 static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C,
1184 /// Whether this template type parameter was declared with
1185 /// the 'typename' keyword.
1187 /// If not, it was declared with the 'class' keyword.
1188 bool wasDeclaredWithTypename() const { return Typename; }
1190 const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1192 /// Determine whether this template parameter has a default
1194 bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1196 /// Retrieve the default argument, if any.
1197 QualType getDefaultArgument() const {
1198 return DefaultArgument.get()->getType();
1201 /// Retrieves the default argument's source information, if any.
1202 TypeSourceInfo *getDefaultArgumentInfo() const {
1203 return DefaultArgument.get();
1206 /// Retrieves the location of the default argument declaration.
1207 SourceLocation getDefaultArgumentLoc() const;
1209 /// Determines whether the default argument was inherited
1210 /// from a previous declaration of this template.
1211 bool defaultArgumentWasInherited() const {
1212 return DefaultArgument.isInherited();
1215 /// Set the default argument for this template parameter.
1216 void setDefaultArgument(TypeSourceInfo *DefArg) {
1217 DefaultArgument.set(DefArg);
1220 /// Set that this default argument was inherited from another
1222 void setInheritedDefaultArgument(const ASTContext &C,
1223 TemplateTypeParmDecl *Prev) {
1224 DefaultArgument.setInherited(C, Prev);
1227 /// Removes the default argument of this template parameter.
1228 void removeDefaultArgument() {
1229 DefaultArgument.clear();
1232 /// Set whether this template type parameter was declared with
1233 /// the 'typename' or 'class' keyword.
1234 void setDeclaredWithTypename(bool withTypename) { Typename = withTypename; }
1236 /// Retrieve the depth of the template parameter.
1237 unsigned getDepth() const;
1239 /// Retrieve the index of the template parameter.
1240 unsigned getIndex() const;
1242 /// Returns whether this is a parameter pack.
1243 bool isParameterPack() const;
1245 SourceRange getSourceRange() const override LLVM_READONLY;
1247 // Implement isa/cast/dyncast/etc.
1248 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1249 static bool classofKind(Kind K) { return K == TemplateTypeParm; }
1252 /// NonTypeTemplateParmDecl - Declares a non-type template parameter,
1255 /// template<int Size> class array { };
1257 class NonTypeTemplateParmDecl final
1258 : public DeclaratorDecl,
1259 protected TemplateParmPosition,
1260 private llvm::TrailingObjects<NonTypeTemplateParmDecl,
1261 std::pair<QualType, TypeSourceInfo *>> {
1262 friend class ASTDeclReader;
1263 friend TrailingObjects;
1265 /// The default template argument, if any, and whether or not
1266 /// it was inherited.
1267 using DefArgStorage = DefaultArgStorage<NonTypeTemplateParmDecl, Expr *>;
1268 DefArgStorage DefaultArgument;
1270 // FIXME: Collapse this into TemplateParamPosition; or, just move depth/index
1271 // down here to save memory.
1273 /// Whether this non-type template parameter is a parameter pack.
1276 /// Whether this non-type template parameter is an "expanded"
1277 /// parameter pack, meaning that its type is a pack expansion and we
1278 /// already know the set of types that expansion expands to.
1279 bool ExpandedParameterPack = false;
1281 /// The number of types in an expanded parameter pack.
1282 unsigned NumExpandedTypes = 0;
1284 size_t numTrailingObjects(
1285 OverloadToken<std::pair<QualType, TypeSourceInfo *>>) const {
1286 return NumExpandedTypes;
1289 NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
1290 SourceLocation IdLoc, unsigned D, unsigned P,
1291 IdentifierInfo *Id, QualType T,
1292 bool ParameterPack, TypeSourceInfo *TInfo)
1293 : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
1294 TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
1296 NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
1297 SourceLocation IdLoc, unsigned D, unsigned P,
1298 IdentifierInfo *Id, QualType T,
1299 TypeSourceInfo *TInfo,
1300 ArrayRef<QualType> ExpandedTypes,
1301 ArrayRef<TypeSourceInfo *> ExpandedTInfos);
1304 static NonTypeTemplateParmDecl *
1305 Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1306 SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
1307 QualType T, bool ParameterPack, TypeSourceInfo *TInfo);
1309 static NonTypeTemplateParmDecl *
1310 Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1311 SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
1312 QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
1313 ArrayRef<TypeSourceInfo *> ExpandedTInfos);
1315 static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
1317 static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
1319 unsigned NumExpandedTypes);
1321 using TemplateParmPosition::getDepth;
1322 using TemplateParmPosition::setDepth;
1323 using TemplateParmPosition::getPosition;
1324 using TemplateParmPosition::setPosition;
1325 using TemplateParmPosition::getIndex;
1327 SourceRange getSourceRange() const override LLVM_READONLY;
1329 const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1331 /// Determine whether this template parameter has a default
1333 bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1335 /// Retrieve the default argument, if any.
1336 Expr *getDefaultArgument() const { return DefaultArgument.get(); }
1338 /// Retrieve the location of the default argument, if any.
1339 SourceLocation getDefaultArgumentLoc() const;
1341 /// Determines whether the default argument was inherited
1342 /// from a previous declaration of this template.
1343 bool defaultArgumentWasInherited() const {
1344 return DefaultArgument.isInherited();
1347 /// Set the default argument for this template parameter, and
1348 /// whether that default argument was inherited from another
1350 void setDefaultArgument(Expr *DefArg) { DefaultArgument.set(DefArg); }
1351 void setInheritedDefaultArgument(const ASTContext &C,
1352 NonTypeTemplateParmDecl *Parm) {
1353 DefaultArgument.setInherited(C, Parm);
1356 /// Removes the default argument of this template parameter.
1357 void removeDefaultArgument() { DefaultArgument.clear(); }
1359 /// Whether this parameter is a non-type template parameter pack.
1361 /// If the parameter is a parameter pack, the type may be a
1362 /// \c PackExpansionType. In the following example, the \c Dims parameter
1363 /// is a parameter pack (whose type is 'unsigned').
1366 /// template<typename T, unsigned ...Dims> struct multi_array;
1368 bool isParameterPack() const { return ParameterPack; }
1370 /// Whether this parameter pack is a pack expansion.
1372 /// A non-type template parameter pack is a pack expansion if its type
1373 /// contains an unexpanded parameter pack. In this case, we will have
1374 /// built a PackExpansionType wrapping the type.
1375 bool isPackExpansion() const {
1376 return ParameterPack && getType()->getAs<PackExpansionType>();
1379 /// Whether this parameter is a non-type template parameter pack
1380 /// that has a known list of different types at different positions.
1382 /// A parameter pack is an expanded parameter pack when the original
1383 /// parameter pack's type was itself a pack expansion, and that expansion
1384 /// has already been expanded. For example, given:
1387 /// template<typename ...Types>
1389 /// template<Types ...Values>
1390 /// struct Y { /* ... */ };
1394 /// The parameter pack \c Values has a \c PackExpansionType as its type,
1395 /// which expands \c Types. When \c Types is supplied with template arguments
1396 /// by instantiating \c X, the instantiation of \c Values becomes an
1397 /// expanded parameter pack. For example, instantiating
1398 /// \c X<int, unsigned int> results in \c Values being an expanded parameter
1399 /// pack with expansion types \c int and \c unsigned int.
1401 /// The \c getExpansionType() and \c getExpansionTypeSourceInfo() functions
1402 /// return the expansion types.
1403 bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1405 /// Retrieves the number of expansion types in an expanded parameter
1407 unsigned getNumExpansionTypes() const {
1408 assert(ExpandedParameterPack && "Not an expansion parameter pack");
1409 return NumExpandedTypes;
1412 /// Retrieve a particular expansion type within an expanded parameter
1414 QualType getExpansionType(unsigned I) const {
1415 assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1416 auto TypesAndInfos =
1417 getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1418 return TypesAndInfos[I].first;
1421 /// Retrieve a particular expansion type source info within an
1422 /// expanded parameter pack.
1423 TypeSourceInfo *getExpansionTypeSourceInfo(unsigned I) const {
1424 assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1425 auto TypesAndInfos =
1426 getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1427 return TypesAndInfos[I].second;
1430 // Implement isa/cast/dyncast/etc.
1431 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1432 static bool classofKind(Kind K) { return K == NonTypeTemplateParm; }
1435 /// TemplateTemplateParmDecl - Declares a template template parameter,
1438 /// template <template <typename> class T> class container { };
1440 /// A template template parameter is a TemplateDecl because it defines the
1441 /// name of a template and the template parameters allowable for substitution.
1442 class TemplateTemplateParmDecl final
1443 : public TemplateDecl,
1444 protected TemplateParmPosition,
1445 private llvm::TrailingObjects<TemplateTemplateParmDecl,
1446 TemplateParameterList *> {
1447 /// The default template argument, if any.
1448 using DefArgStorage =
1449 DefaultArgStorage<TemplateTemplateParmDecl, TemplateArgumentLoc *>;
1450 DefArgStorage DefaultArgument;
1452 /// Whether this parameter is a parameter pack.
1455 /// Whether this template template parameter is an "expanded"
1456 /// parameter pack, meaning that it is a pack expansion and we
1457 /// already know the set of template parameters that expansion expands to.
1458 bool ExpandedParameterPack = false;
1460 /// The number of parameters in an expanded parameter pack.
1461 unsigned NumExpandedParams = 0;
1463 TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L,
1464 unsigned D, unsigned P, bool ParameterPack,
1465 IdentifierInfo *Id, TemplateParameterList *Params)
1466 : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
1467 TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
1469 TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L,
1470 unsigned D, unsigned P,
1471 IdentifierInfo *Id, TemplateParameterList *Params,
1472 ArrayRef<TemplateParameterList *> Expansions);
1474 void anchor() override;
1477 friend class ASTDeclReader;
1478 friend class ASTDeclWriter;
1479 friend TrailingObjects;
1481 static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
1482 SourceLocation L, unsigned D,
1483 unsigned P, bool ParameterPack,
1485 TemplateParameterList *Params);
1486 static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
1487 SourceLocation L, unsigned D,
1490 TemplateParameterList *Params,
1491 ArrayRef<TemplateParameterList *> Expansions);
1493 static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
1495 static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
1497 unsigned NumExpansions);
1499 using TemplateParmPosition::getDepth;
1500 using TemplateParmPosition::setDepth;
1501 using TemplateParmPosition::getPosition;
1502 using TemplateParmPosition::setPosition;
1503 using TemplateParmPosition::getIndex;
1505 /// Whether this template template parameter is a template
1509 /// template<template <class T> ...MetaFunctions> struct Apply;
1511 bool isParameterPack() const { return ParameterPack; }
1513 /// Whether this parameter pack is a pack expansion.
1515 /// A template template parameter pack is a pack expansion if its template
1516 /// parameter list contains an unexpanded parameter pack.
1517 bool isPackExpansion() const {
1518 return ParameterPack &&
1519 getTemplateParameters()->containsUnexpandedParameterPack();
1522 /// Whether this parameter is a template template parameter pack that
1523 /// has a known list of different template parameter lists at different
1526 /// A parameter pack is an expanded parameter pack when the original parameter
1527 /// pack's template parameter list was itself a pack expansion, and that
1528 /// expansion has already been expanded. For exampe, given:
1531 /// template<typename...Types> struct Outer {
1532 /// template<template<Types> class...Templates> struct Inner;
1536 /// The parameter pack \c Templates is a pack expansion, which expands the
1537 /// pack \c Types. When \c Types is supplied with template arguments by
1538 /// instantiating \c Outer, the instantiation of \c Templates is an expanded
1540 bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1542 /// Retrieves the number of expansion template parameters in
1543 /// an expanded parameter pack.
1544 unsigned getNumExpansionTemplateParameters() const {
1545 assert(ExpandedParameterPack && "Not an expansion parameter pack");
1546 return NumExpandedParams;
1549 /// Retrieve a particular expansion type within an expanded parameter
1551 TemplateParameterList *getExpansionTemplateParameters(unsigned I) const {
1552 assert(I < NumExpandedParams && "Out-of-range expansion type index");
1553 return getTrailingObjects<TemplateParameterList *>()[I];
1556 const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1558 /// Determine whether this template parameter has a default
1560 bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1562 /// Retrieve the default argument, if any.
1563 const TemplateArgumentLoc &getDefaultArgument() const {
1564 static const TemplateArgumentLoc None;
1565 return DefaultArgument.isSet() ? *DefaultArgument.get() : None;
1568 /// Retrieve the location of the default argument, if any.
1569 SourceLocation getDefaultArgumentLoc() const;
1571 /// Determines whether the default argument was inherited
1572 /// from a previous declaration of this template.
1573 bool defaultArgumentWasInherited() const {
1574 return DefaultArgument.isInherited();
1577 /// Set the default argument for this template parameter, and
1578 /// whether that default argument was inherited from another
1580 void setDefaultArgument(const ASTContext &C,
1581 const TemplateArgumentLoc &DefArg);
1582 void setInheritedDefaultArgument(const ASTContext &C,
1583 TemplateTemplateParmDecl *Prev) {
1584 DefaultArgument.setInherited(C, Prev);
1587 /// Removes the default argument of this template parameter.
1588 void removeDefaultArgument() { DefaultArgument.clear(); }
1590 SourceRange getSourceRange() const override LLVM_READONLY {
1591 SourceLocation End = getLocation();
1592 if (hasDefaultArgument() && !defaultArgumentWasInherited())
1593 End = getDefaultArgument().getSourceRange().getEnd();
1594 return SourceRange(getTemplateParameters()->getTemplateLoc(), End);
1597 // Implement isa/cast/dyncast/etc.
1598 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1599 static bool classofKind(Kind K) { return K == TemplateTemplateParm; }
1602 /// Represents the builtin template declaration which is used to
1603 /// implement __make_integer_seq and other builtin templates. It serves
1604 /// no real purpose beyond existing as a place to hold template parameters.
1605 class BuiltinTemplateDecl : public TemplateDecl {
1606 BuiltinTemplateKind BTK;
1608 BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
1609 DeclarationName Name, BuiltinTemplateKind BTK);
1611 void anchor() override;
1614 // Implement isa/cast/dyncast support
1615 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1616 static bool classofKind(Kind K) { return K == BuiltinTemplate; }
1618 static BuiltinTemplateDecl *Create(const ASTContext &C, DeclContext *DC,
1619 DeclarationName Name,
1620 BuiltinTemplateKind BTK) {
1621 return new (C, DC) BuiltinTemplateDecl(C, DC, Name, BTK);
1624 SourceRange getSourceRange() const override LLVM_READONLY {
1628 BuiltinTemplateKind getBuiltinTemplateKind() const { return BTK; }
1631 /// Represents a class template specialization, which refers to
1632 /// a class template with a given set of template arguments.
1634 /// Class template specializations represent both explicit
1635 /// specialization of class templates, as in the example below, and
1636 /// implicit instantiations of class templates.
1639 /// template<typename T> class array;
1642 /// class array<bool> { }; // class template specialization array<bool>
1644 class ClassTemplateSpecializationDecl
1645 : public CXXRecordDecl, public llvm::FoldingSetNode {
1646 /// Structure that stores information about a class template
1647 /// specialization that was instantiated from a class template partial
1649 struct SpecializedPartialSpecialization {
1650 /// The class template partial specialization from which this
1651 /// class template specialization was instantiated.
1652 ClassTemplatePartialSpecializationDecl *PartialSpecialization;
1654 /// The template argument list deduced for the class template
1655 /// partial specialization itself.
1656 const TemplateArgumentList *TemplateArgs;
1659 /// The template that this specialization specializes
1660 llvm::PointerUnion<ClassTemplateDecl *, SpecializedPartialSpecialization *>
1661 SpecializedTemplate;
1663 /// Further info for explicit template specialization/instantiation.
1664 struct ExplicitSpecializationInfo {
1665 /// The type-as-written.
1666 TypeSourceInfo *TypeAsWritten = nullptr;
1668 /// The location of the extern keyword.
1669 SourceLocation ExternLoc;
1671 /// The location of the template keyword.
1672 SourceLocation TemplateKeywordLoc;
1674 ExplicitSpecializationInfo() = default;
1677 /// Further info for explicit template specialization/instantiation.
1678 /// Does not apply to implicit specializations.
1679 ExplicitSpecializationInfo *ExplicitInfo = nullptr;
1681 /// The template arguments used to describe this specialization.
1682 const TemplateArgumentList *TemplateArgs;
1684 /// The point where this template was instantiated (if any)
1685 SourceLocation PointOfInstantiation;
1687 /// The kind of specialization this declaration refers to.
1688 /// Really a value of type TemplateSpecializationKind.
1689 unsigned SpecializationKind : 3;
1692 ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
1693 DeclContext *DC, SourceLocation StartLoc,
1694 SourceLocation IdLoc,
1695 ClassTemplateDecl *SpecializedTemplate,
1696 ArrayRef<TemplateArgument> Args,
1697 ClassTemplateSpecializationDecl *PrevDecl);
1699 explicit ClassTemplateSpecializationDecl(ASTContext &C, Kind DK);
1702 friend class ASTDeclReader;
1703 friend class ASTDeclWriter;
1705 static ClassTemplateSpecializationDecl *
1706 Create(ASTContext &Context, TagKind TK, DeclContext *DC,
1707 SourceLocation StartLoc, SourceLocation IdLoc,
1708 ClassTemplateDecl *SpecializedTemplate,
1709 ArrayRef<TemplateArgument> Args,
1710 ClassTemplateSpecializationDecl *PrevDecl);
1711 static ClassTemplateSpecializationDecl *
1712 CreateDeserialized(ASTContext &C, unsigned ID);
1714 void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
1715 bool Qualified) const override;
1717 // FIXME: This is broken. CXXRecordDecl::getMostRecentDecl() returns a
1718 // different "most recent" declaration from this function for the same
1719 // declaration, because we don't override getMostRecentDeclImpl(). But
1720 // it's not clear that we should override that, because the most recent
1721 // declaration as a CXXRecordDecl sometimes is the injected-class-name.
1722 ClassTemplateSpecializationDecl *getMostRecentDecl() {
1723 return cast<ClassTemplateSpecializationDecl>(
1724 getMostRecentNonInjectedDecl());
1727 /// Retrieve the template that this specialization specializes.
1728 ClassTemplateDecl *getSpecializedTemplate() const;
1730 /// Retrieve the template arguments of the class template
1732 const TemplateArgumentList &getTemplateArgs() const {
1733 return *TemplateArgs;
1736 /// Determine the kind of specialization that this
1737 /// declaration represents.
1738 TemplateSpecializationKind getSpecializationKind() const {
1739 return static_cast<TemplateSpecializationKind>(SpecializationKind);
1742 bool isExplicitSpecialization() const {
1743 return getSpecializationKind() == TSK_ExplicitSpecialization;
1746 /// True if this declaration is an explicit specialization,
1747 /// explicit instantiation declaration, or explicit instantiation
1749 bool isExplicitInstantiationOrSpecialization() const {
1750 return isTemplateExplicitInstantiationOrSpecialization(
1751 getTemplateSpecializationKind());
1754 void setSpecializationKind(TemplateSpecializationKind TSK) {
1755 SpecializationKind = TSK;
1758 /// Get the point of instantiation (if any), or null if none.
1759 SourceLocation getPointOfInstantiation() const {
1760 return PointOfInstantiation;
1763 void setPointOfInstantiation(SourceLocation Loc) {
1764 assert(Loc.isValid() && "point of instantiation must be valid!");
1765 PointOfInstantiation = Loc;
1768 /// If this class template specialization is an instantiation of
1769 /// a template (rather than an explicit specialization), return the
1770 /// class template or class template partial specialization from which it
1771 /// was instantiated.
1772 llvm::PointerUnion<ClassTemplateDecl *,
1773 ClassTemplatePartialSpecializationDecl *>
1774 getInstantiatedFrom() const {
1775 if (!isTemplateInstantiation(getSpecializationKind()))
1776 return llvm::PointerUnion<ClassTemplateDecl *,
1777 ClassTemplatePartialSpecializationDecl *>();
1779 return getSpecializedTemplateOrPartial();
1782 /// Retrieve the class template or class template partial
1783 /// specialization which was specialized by this.
1784 llvm::PointerUnion<ClassTemplateDecl *,
1785 ClassTemplatePartialSpecializationDecl *>
1786 getSpecializedTemplateOrPartial() const {
1787 if (const auto *PartialSpec =
1788 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1789 return PartialSpec->PartialSpecialization;
1791 return SpecializedTemplate.get<ClassTemplateDecl*>();
1794 /// Retrieve the set of template arguments that should be used
1795 /// to instantiate members of the class template or class template partial
1796 /// specialization from which this class template specialization was
1799 /// \returns For a class template specialization instantiated from the primary
1800 /// template, this function will return the same template arguments as
1801 /// getTemplateArgs(). For a class template specialization instantiated from
1802 /// a class template partial specialization, this function will return the
1803 /// deduced template arguments for the class template partial specialization
1805 const TemplateArgumentList &getTemplateInstantiationArgs() const {
1806 if (const auto *PartialSpec =
1807 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1808 return *PartialSpec->TemplateArgs;
1810 return getTemplateArgs();
1813 /// Note that this class template specialization is actually an
1814 /// instantiation of the given class template partial specialization whose
1815 /// template arguments have been deduced.
1816 void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec,
1817 const TemplateArgumentList *TemplateArgs) {
1818 assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
1819 "Already set to a class template partial specialization!");
1820 auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
1821 PS->PartialSpecialization = PartialSpec;
1822 PS->TemplateArgs = TemplateArgs;
1823 SpecializedTemplate = PS;
1826 /// Note that this class template specialization is an instantiation
1827 /// of the given class template.
1828 void setInstantiationOf(ClassTemplateDecl *TemplDecl) {
1829 assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
1830 "Previously set to a class template partial specialization!");
1831 SpecializedTemplate = TemplDecl;
1834 /// Sets the type of this specialization as it was written by
1835 /// the user. This will be a class template specialization type.
1836 void setTypeAsWritten(TypeSourceInfo *T) {
1838 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1839 ExplicitInfo->TypeAsWritten = T;
1842 /// Gets the type of this specialization as it was written by
1843 /// the user, if it was so written.
1844 TypeSourceInfo *getTypeAsWritten() const {
1845 return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
1848 /// Gets the location of the extern keyword, if present.
1849 SourceLocation getExternLoc() const {
1850 return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
1853 /// Sets the location of the extern keyword.
1854 void setExternLoc(SourceLocation Loc) {
1856 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1857 ExplicitInfo->ExternLoc = Loc;
1860 /// Sets the location of the template keyword.
1861 void setTemplateKeywordLoc(SourceLocation Loc) {
1863 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1864 ExplicitInfo->TemplateKeywordLoc = Loc;
1867 /// Gets the location of the template keyword, if present.
1868 SourceLocation getTemplateKeywordLoc() const {
1869 return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
1872 SourceRange getSourceRange() const override LLVM_READONLY;
1874 void Profile(llvm::FoldingSetNodeID &ID) const {
1875 Profile(ID, TemplateArgs->asArray(), getASTContext());
1879 Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
1880 ASTContext &Context) {
1881 ID.AddInteger(TemplateArgs.size());
1882 for (const TemplateArgument &TemplateArg : TemplateArgs)
1883 TemplateArg.Profile(ID, Context);
1886 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1888 static bool classofKind(Kind K) {
1889 return K >= firstClassTemplateSpecialization &&
1890 K <= lastClassTemplateSpecialization;
1894 class ClassTemplatePartialSpecializationDecl
1895 : public ClassTemplateSpecializationDecl {
1896 /// The list of template parameters
1897 TemplateParameterList* TemplateParams = nullptr;
1899 /// The source info for the template arguments as written.
1900 /// FIXME: redundant with TypeAsWritten?
1901 const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
1903 /// The class template partial specialization from which this
1904 /// class template partial specialization was instantiated.
1906 /// The boolean value will be true to indicate that this class template
1907 /// partial specialization was specialized at this level.
1908 llvm::PointerIntPair<ClassTemplatePartialSpecializationDecl *, 1, bool>
1909 InstantiatedFromMember;
1911 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
1913 SourceLocation StartLoc,
1914 SourceLocation IdLoc,
1915 TemplateParameterList *Params,
1916 ClassTemplateDecl *SpecializedTemplate,
1917 ArrayRef<TemplateArgument> Args,
1918 const ASTTemplateArgumentListInfo *ArgsAsWritten,
1919 ClassTemplatePartialSpecializationDecl *PrevDecl);
1921 ClassTemplatePartialSpecializationDecl(ASTContext &C)
1922 : ClassTemplateSpecializationDecl(C, ClassTemplatePartialSpecialization),
1923 InstantiatedFromMember(nullptr, false) {}
1925 void anchor() override;
1928 friend class ASTDeclReader;
1929 friend class ASTDeclWriter;
1931 static ClassTemplatePartialSpecializationDecl *
1932 Create(ASTContext &Context, TagKind TK, DeclContext *DC,
1933 SourceLocation StartLoc, SourceLocation IdLoc,
1934 TemplateParameterList *Params,
1935 ClassTemplateDecl *SpecializedTemplate,
1936 ArrayRef<TemplateArgument> Args,
1937 const TemplateArgumentListInfo &ArgInfos,
1938 QualType CanonInjectedType,
1939 ClassTemplatePartialSpecializationDecl *PrevDecl);
1941 static ClassTemplatePartialSpecializationDecl *
1942 CreateDeserialized(ASTContext &C, unsigned ID);
1944 ClassTemplatePartialSpecializationDecl *getMostRecentDecl() {
1945 return cast<ClassTemplatePartialSpecializationDecl>(
1946 static_cast<ClassTemplateSpecializationDecl *>(
1947 this)->getMostRecentDecl());
1950 /// Get the list of template parameters
1951 TemplateParameterList *getTemplateParameters() const {
1952 return TemplateParams;
1955 /// Get the template arguments as written.
1956 const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
1957 return ArgsAsWritten;
1960 /// Retrieve the member class template partial specialization from
1961 /// which this particular class template partial specialization was
1965 /// template<typename T>
1967 /// template<typename U> struct Inner;
1968 /// template<typename U> struct Inner<U*> { }; // #1
1971 /// Outer<float>::Inner<int*> ii;
1974 /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
1975 /// end up instantiating the partial specialization
1976 /// \c Outer<float>::Inner<U*>, which itself was instantiated from the class
1977 /// template partial specialization \c Outer<T>::Inner<U*>. Given
1978 /// \c Outer<float>::Inner<U*>, this function would return
1979 /// \c Outer<T>::Inner<U*>.
1980 ClassTemplatePartialSpecializationDecl *getInstantiatedFromMember() const {
1982 cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
1983 return First->InstantiatedFromMember.getPointer();
1985 ClassTemplatePartialSpecializationDecl *
1986 getInstantiatedFromMemberTemplate() const {
1987 return getInstantiatedFromMember();
1990 void setInstantiatedFromMember(
1991 ClassTemplatePartialSpecializationDecl *PartialSpec) {
1992 auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
1993 First->InstantiatedFromMember.setPointer(PartialSpec);
1996 /// Determines whether this class template partial specialization
1997 /// template was a specialization of a member partial specialization.
1999 /// In the following example, the member template partial specialization
2000 /// \c X<int>::Inner<T*> is a member specialization.
2003 /// template<typename T>
2005 /// template<typename U> struct Inner;
2006 /// template<typename U> struct Inner<U*>;
2009 /// template<> template<typename T>
2010 /// struct X<int>::Inner<T*> { /* ... */ };
2012 bool isMemberSpecialization() {
2014 cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2015 return First->InstantiatedFromMember.getInt();
2018 /// Note that this member template is a specialization.
2019 void setMemberSpecialization() {
2020 auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2021 assert(First->InstantiatedFromMember.getPointer() &&
2022 "Only member templates can be member template specializations");
2023 return First->InstantiatedFromMember.setInt(true);
2026 /// Retrieves the injected specialization type for this partial
2027 /// specialization. This is not the same as the type-decl-type for
2028 /// this partial specialization, which is an InjectedClassNameType.
2029 QualType getInjectedSpecializationType() const {
2030 assert(getTypeForDecl() && "partial specialization has no type set!");
2031 return cast<InjectedClassNameType>(getTypeForDecl())
2032 ->getInjectedSpecializationType();
2035 // FIXME: Add Profile support!
2037 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2039 static bool classofKind(Kind K) {
2040 return K == ClassTemplatePartialSpecialization;
2044 /// Declaration of a class template.
2045 class ClassTemplateDecl : public RedeclarableTemplateDecl {
2047 /// Data that is common to all of the declarations of a given
2049 struct Common : CommonBase {
2050 /// The class template specializations for this class
2051 /// template, including explicit specializations and instantiations.
2052 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> Specializations;
2054 /// The class template partial specializations for this class
2056 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
2057 PartialSpecializations;
2059 /// The injected-class-name type for this class template.
2060 QualType InjectedClassNameType;
2065 /// Retrieve the set of specializations of this class template.
2066 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
2067 getSpecializations() const;
2069 /// Retrieve the set of partial specializations of this class
2071 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
2072 getPartialSpecializations();
2074 ClassTemplateDecl(ConstrainedTemplateDeclInfo *CTDI, ASTContext &C,
2075 DeclContext *DC, SourceLocation L, DeclarationName Name,
2076 TemplateParameterList *Params, NamedDecl *Decl)
2077 : RedeclarableTemplateDecl(CTDI, ClassTemplate, C, DC, L, Name, Params,
2080 ClassTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
2081 DeclarationName Name, TemplateParameterList *Params,
2083 : ClassTemplateDecl(nullptr, C, DC, L, Name, Params, Decl) {}
2085 CommonBase *newCommon(ASTContext &C) const override;
2087 Common *getCommonPtr() const {
2088 return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2092 friend class ASTDeclReader;
2093 friend class ASTDeclWriter;
2095 /// Load any lazily-loaded specializations from the external source.
2096 void LoadLazySpecializations() const;
2098 /// Get the underlying class declarations of the template.
2099 CXXRecordDecl *getTemplatedDecl() const {
2100 return static_cast<CXXRecordDecl *>(TemplatedDecl);
2103 /// Returns whether this template declaration defines the primary
2105 bool isThisDeclarationADefinition() const {
2106 return getTemplatedDecl()->isThisDeclarationADefinition();
2109 // FIXME: remove default argument for AssociatedConstraints
2110 /// Create a class template node.
2111 static ClassTemplateDecl *Create(ASTContext &C, DeclContext *DC,
2113 DeclarationName Name,
2114 TemplateParameterList *Params,
2116 Expr *AssociatedConstraints = nullptr);
2118 /// Create an empty class template node.
2119 static ClassTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2121 /// Return the specialization with the provided arguments if it exists,
2122 /// otherwise return the insertion point.
2123 ClassTemplateSpecializationDecl *
2124 findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2126 /// Insert the specified specialization knowing that it is not already
2127 /// in. InsertPos must be obtained from findSpecialization.
2128 void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos);
2130 ClassTemplateDecl *getCanonicalDecl() override {
2131 return cast<ClassTemplateDecl>(
2132 RedeclarableTemplateDecl::getCanonicalDecl());
2134 const ClassTemplateDecl *getCanonicalDecl() const {
2135 return cast<ClassTemplateDecl>(
2136 RedeclarableTemplateDecl::getCanonicalDecl());
2139 /// Retrieve the previous declaration of this class template, or
2140 /// nullptr if no such declaration exists.
2141 ClassTemplateDecl *getPreviousDecl() {
2142 return cast_or_null<ClassTemplateDecl>(
2143 static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2145 const ClassTemplateDecl *getPreviousDecl() const {
2146 return cast_or_null<ClassTemplateDecl>(
2147 static_cast<const RedeclarableTemplateDecl *>(
2148 this)->getPreviousDecl());
2151 ClassTemplateDecl *getMostRecentDecl() {
2152 return cast<ClassTemplateDecl>(
2153 static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
2155 const ClassTemplateDecl *getMostRecentDecl() const {
2156 return const_cast<ClassTemplateDecl*>(this)->getMostRecentDecl();
2159 ClassTemplateDecl *getInstantiatedFromMemberTemplate() const {
2160 return cast_or_null<ClassTemplateDecl>(
2161 RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
2164 /// Return the partial specialization with the provided arguments if it
2165 /// exists, otherwise return the insertion point.
2166 ClassTemplatePartialSpecializationDecl *
2167 findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2169 /// Insert the specified partial specialization knowing that it is not
2170 /// already in. InsertPos must be obtained from findPartialSpecialization.
2171 void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D,
2174 /// Retrieve the partial specializations as an ordered list.
2175 void getPartialSpecializations(
2176 SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS);
2178 /// Find a class template partial specialization with the given
2181 /// \param T a dependent type that names a specialization of this class
2184 /// \returns the class template partial specialization that exactly matches
2185 /// the type \p T, or nullptr if no such partial specialization exists.
2186 ClassTemplatePartialSpecializationDecl *findPartialSpecialization(QualType T);
2188 /// Find a class template partial specialization which was instantiated
2189 /// from the given member partial specialization.
2191 /// \param D a member class template partial specialization.
2193 /// \returns the class template partial specialization which was instantiated
2194 /// from the given member partial specialization, or nullptr if no such
2195 /// partial specialization exists.
2196 ClassTemplatePartialSpecializationDecl *
2197 findPartialSpecInstantiatedFromMember(
2198 ClassTemplatePartialSpecializationDecl *D);
2200 /// Retrieve the template specialization type of the
2201 /// injected-class-name for this class template.
2203 /// The injected-class-name for a class template \c X is \c
2204 /// X<template-args>, where \c template-args is formed from the
2205 /// template arguments that correspond to the template parameters of
2206 /// \c X. For example:
2209 /// template<typename T, int N>
2211 /// typedef array this_type; // "array" is equivalent to "array<T, N>"
2214 QualType getInjectedClassNameSpecialization();
2216 using spec_iterator = SpecIterator<ClassTemplateSpecializationDecl>;
2217 using spec_range = llvm::iterator_range<spec_iterator>;
2219 spec_range specializations() const {
2220 return spec_range(spec_begin(), spec_end());
2223 spec_iterator spec_begin() const {
2224 return makeSpecIterator(getSpecializations(), false);
2227 spec_iterator spec_end() const {
2228 return makeSpecIterator(getSpecializations(), true);
2231 // Implement isa/cast/dyncast support
2232 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2233 static bool classofKind(Kind K) { return K == ClassTemplate; }
2236 /// Declaration of a friend template.
2240 /// template \<typename T> class A {
2241 /// friend class MyVector<T>; // not a friend template
2242 /// template \<typename U> friend class B; // not a friend template
2243 /// template \<typename U> friend class Foo<T>::Nested; // friend template
2247 /// \note This class is not currently in use. All of the above
2248 /// will yield a FriendDecl, not a FriendTemplateDecl.
2249 class FriendTemplateDecl : public Decl {
2250 virtual void anchor();
2253 using FriendUnion = llvm::PointerUnion<NamedDecl *,TypeSourceInfo *>;
2256 // The number of template parameters; always non-zero.
2257 unsigned NumParams = 0;
2259 // The parameter list.
2260 TemplateParameterList **Params = nullptr;
2262 // The declaration that's a friend of this class.
2265 // Location of the 'friend' specifier.
2266 SourceLocation FriendLoc;
2268 FriendTemplateDecl(DeclContext *DC, SourceLocation Loc,
2269 MutableArrayRef<TemplateParameterList *> Params,
2270 FriendUnion Friend, SourceLocation FriendLoc)
2271 : Decl(Decl::FriendTemplate, DC, Loc), NumParams(Params.size()),
2272 Params(Params.data()), Friend(Friend), FriendLoc(FriendLoc) {}
2274 FriendTemplateDecl(EmptyShell Empty) : Decl(Decl::FriendTemplate, Empty) {}
2277 friend class ASTDeclReader;
2279 static FriendTemplateDecl *
2280 Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc,
2281 MutableArrayRef<TemplateParameterList *> Params, FriendUnion Friend,
2282 SourceLocation FriendLoc);
2284 static FriendTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2286 /// If this friend declaration names a templated type (or
2287 /// a dependent member type of a templated type), return that
2288 /// type; otherwise return null.
2289 TypeSourceInfo *getFriendType() const {
2290 return Friend.dyn_cast<TypeSourceInfo*>();
2293 /// If this friend declaration names a templated function (or
2294 /// a member function of a templated type), return that type;
2295 /// otherwise return null.
2296 NamedDecl *getFriendDecl() const {
2297 return Friend.dyn_cast<NamedDecl*>();
2300 /// Retrieves the location of the 'friend' keyword.
2301 SourceLocation getFriendLoc() const {
2305 TemplateParameterList *getTemplateParameterList(unsigned i) const {
2306 assert(i <= NumParams);
2310 unsigned getNumTemplateParameters() const {
2314 // Implement isa/cast/dyncast/etc.
2315 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2316 static bool classofKind(Kind K) { return K == Decl::FriendTemplate; }
2319 /// Declaration of an alias template.
2323 /// template \<typename T> using V = std::map<T*, int, MyCompare<T>>;
2325 class TypeAliasTemplateDecl : public RedeclarableTemplateDecl {
2327 using Common = CommonBase;
2329 TypeAliasTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
2330 DeclarationName Name, TemplateParameterList *Params,
2332 : RedeclarableTemplateDecl(TypeAliasTemplate, C, DC, L, Name, Params,
2335 CommonBase *newCommon(ASTContext &C) const override;
2337 Common *getCommonPtr() {
2338 return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2342 friend class ASTDeclReader;
2343 friend class ASTDeclWriter;
2345 /// Get the underlying function declaration of the template.
2346 TypeAliasDecl *getTemplatedDecl() const {
2347 return static_cast<TypeAliasDecl *>(TemplatedDecl);
2351 TypeAliasTemplateDecl *getCanonicalDecl() override {
2352 return cast<TypeAliasTemplateDecl>(
2353 RedeclarableTemplateDecl::getCanonicalDecl());
2355 const TypeAliasTemplateDecl *getCanonicalDecl() const {
2356 return cast<TypeAliasTemplateDecl>(
2357 RedeclarableTemplateDecl::getCanonicalDecl());
2360 /// Retrieve the previous declaration of this function template, or
2361 /// nullptr if no such declaration exists.
2362 TypeAliasTemplateDecl *getPreviousDecl() {
2363 return cast_or_null<TypeAliasTemplateDecl>(
2364 static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2366 const TypeAliasTemplateDecl *getPreviousDecl() const {
2367 return cast_or_null<TypeAliasTemplateDecl>(
2368 static_cast<const RedeclarableTemplateDecl *>(
2369 this)->getPreviousDecl());
2372 TypeAliasTemplateDecl *getInstantiatedFromMemberTemplate() const {
2373 return cast_or_null<TypeAliasTemplateDecl>(
2374 RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
2377 /// Create a function template node.
2378 static TypeAliasTemplateDecl *Create(ASTContext &C, DeclContext *DC,
2380 DeclarationName Name,
2381 TemplateParameterList *Params,
2384 /// Create an empty alias template node.
2385 static TypeAliasTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2387 // Implement isa/cast/dyncast support
2388 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2389 static bool classofKind(Kind K) { return K == TypeAliasTemplate; }
2392 /// Declaration of a function specialization at template class scope.
2394 /// This is a non-standard extension needed to support MSVC.
2398 /// template <class T>
2400 /// template <class U> void foo(U a) { }
2401 /// template<> void foo(int a) { }
2405 /// "template<> foo(int a)" will be saved in Specialization as a normal
2406 /// CXXMethodDecl. Then during an instantiation of class A, it will be
2407 /// transformed into an actual function specialization.
2408 class ClassScopeFunctionSpecializationDecl : public Decl {
2409 CXXMethodDecl *Specialization;
2410 bool HasExplicitTemplateArgs;
2411 TemplateArgumentListInfo TemplateArgs;
2413 ClassScopeFunctionSpecializationDecl(DeclContext *DC, SourceLocation Loc,
2414 CXXMethodDecl *FD, bool Args,
2415 TemplateArgumentListInfo TemplArgs)
2416 : Decl(Decl::ClassScopeFunctionSpecialization, DC, Loc),
2417 Specialization(FD), HasExplicitTemplateArgs(Args),
2418 TemplateArgs(std::move(TemplArgs)) {}
2420 ClassScopeFunctionSpecializationDecl(EmptyShell Empty)
2421 : Decl(Decl::ClassScopeFunctionSpecialization, Empty) {}
2423 virtual void anchor();
2426 friend class ASTDeclReader;
2427 friend class ASTDeclWriter;
2429 CXXMethodDecl *getSpecialization() const { return Specialization; }
2430 bool hasExplicitTemplateArgs() const { return HasExplicitTemplateArgs; }
2431 const TemplateArgumentListInfo& templateArgs() const { return TemplateArgs; }
2433 static ClassScopeFunctionSpecializationDecl *Create(ASTContext &C,
2437 bool HasExplicitTemplateArgs,
2438 TemplateArgumentListInfo TemplateArgs) {
2439 return new (C, DC) ClassScopeFunctionSpecializationDecl(
2440 DC, Loc, FD, HasExplicitTemplateArgs, std::move(TemplateArgs));
2443 static ClassScopeFunctionSpecializationDecl *
2444 CreateDeserialized(ASTContext &Context, unsigned ID);
2446 // Implement isa/cast/dyncast/etc.
2447 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2449 static bool classofKind(Kind K) {
2450 return K == Decl::ClassScopeFunctionSpecialization;
2454 /// Implementation of inline functions that require the template declarations
2455 inline AnyFunctionDecl::AnyFunctionDecl(FunctionTemplateDecl *FTD)
2458 /// Represents a variable template specialization, which refers to
2459 /// a variable template with a given set of template arguments.
2461 /// Variable template specializations represent both explicit
2462 /// specializations of variable templates, as in the example below, and
2463 /// implicit instantiations of variable templates.
2466 /// template<typename T> constexpr T pi = T(3.1415926535897932385);
2469 /// constexpr float pi<float>; // variable template specialization pi<float>
2471 class VarTemplateSpecializationDecl : public VarDecl,
2472 public llvm::FoldingSetNode {
2474 /// Structure that stores information about a variable template
2475 /// specialization that was instantiated from a variable template partial
2477 struct SpecializedPartialSpecialization {
2478 /// The variable template partial specialization from which this
2479 /// variable template specialization was instantiated.
2480 VarTemplatePartialSpecializationDecl *PartialSpecialization;
2482 /// The template argument list deduced for the variable template
2483 /// partial specialization itself.
2484 const TemplateArgumentList *TemplateArgs;
2487 /// The template that this specialization specializes.
2488 llvm::PointerUnion<VarTemplateDecl *, SpecializedPartialSpecialization *>
2489 SpecializedTemplate;
2491 /// Further info for explicit template specialization/instantiation.
2492 struct ExplicitSpecializationInfo {
2493 /// The type-as-written.
2494 TypeSourceInfo *TypeAsWritten = nullptr;
2496 /// The location of the extern keyword.
2497 SourceLocation ExternLoc;
2499 /// The location of the template keyword.
2500 SourceLocation TemplateKeywordLoc;
2502 ExplicitSpecializationInfo() = default;
2505 /// Further info for explicit template specialization/instantiation.
2506 /// Does not apply to implicit specializations.
2507 ExplicitSpecializationInfo *ExplicitInfo = nullptr;
2509 /// The template arguments used to describe this specialization.
2510 const TemplateArgumentList *TemplateArgs;
2511 TemplateArgumentListInfo TemplateArgsInfo;
2513 /// The point where this template was instantiated (if any).
2514 SourceLocation PointOfInstantiation;
2516 /// The kind of specialization this declaration refers to.
2517 /// Really a value of type TemplateSpecializationKind.
2518 unsigned SpecializationKind : 3;
2520 /// Whether this declaration is a complete definition of the
2521 /// variable template specialization. We can't otherwise tell apart
2522 /// an instantiated declaration from an instantiated definition with
2524 unsigned IsCompleteDefinition : 1;
2527 VarTemplateSpecializationDecl(Kind DK, ASTContext &Context, DeclContext *DC,
2528 SourceLocation StartLoc, SourceLocation IdLoc,
2529 VarTemplateDecl *SpecializedTemplate,
2530 QualType T, TypeSourceInfo *TInfo,
2532 ArrayRef<TemplateArgument> Args);
2534 explicit VarTemplateSpecializationDecl(Kind DK, ASTContext &Context);
2537 friend class ASTDeclReader;
2538 friend class ASTDeclWriter;
2539 friend class VarDecl;
2541 static VarTemplateSpecializationDecl *
2542 Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2543 SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
2544 TypeSourceInfo *TInfo, StorageClass S,
2545 ArrayRef<TemplateArgument> Args);
2546 static VarTemplateSpecializationDecl *CreateDeserialized(ASTContext &C,
2549 void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
2550 bool Qualified) const override;
2552 VarTemplateSpecializationDecl *getMostRecentDecl() {
2553 VarDecl *Recent = static_cast<VarDecl *>(this)->getMostRecentDecl();
2554 return cast<VarTemplateSpecializationDecl>(Recent);
2557 /// Retrieve the template that this specialization specializes.
2558 VarTemplateDecl *getSpecializedTemplate() const;
2560 /// Retrieve the template arguments of the variable template
2562 const TemplateArgumentList &getTemplateArgs() const { return *TemplateArgs; }
2564 // TODO: Always set this when creating the new specialization?
2565 void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo);
2567 const TemplateArgumentListInfo &getTemplateArgsInfo() const {
2568 return TemplateArgsInfo;
2571 /// Determine the kind of specialization that this
2572 /// declaration represents.
2573 TemplateSpecializationKind getSpecializationKind() const {
2574 return static_cast<TemplateSpecializationKind>(SpecializationKind);
2577 bool isExplicitSpecialization() const {
2578 return getSpecializationKind() == TSK_ExplicitSpecialization;
2581 /// True if this declaration is an explicit specialization,
2582 /// explicit instantiation declaration, or explicit instantiation
2584 bool isExplicitInstantiationOrSpecialization() const {
2585 return isTemplateExplicitInstantiationOrSpecialization(
2586 getTemplateSpecializationKind());
2589 void setSpecializationKind(TemplateSpecializationKind TSK) {
2590 SpecializationKind = TSK;
2593 /// Get the point of instantiation (if any), or null if none.
2594 SourceLocation getPointOfInstantiation() const {
2595 return PointOfInstantiation;
2598 void setPointOfInstantiation(SourceLocation Loc) {
2599 assert(Loc.isValid() && "point of instantiation must be valid!");
2600 PointOfInstantiation = Loc;
2603 void setCompleteDefinition() { IsCompleteDefinition = true; }
2605 /// If this variable template specialization is an instantiation of
2606 /// a template (rather than an explicit specialization), return the
2607 /// variable template or variable template partial specialization from which
2608 /// it was instantiated.
2609 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2610 getInstantiatedFrom() const {
2611 if (!isTemplateInstantiation(getSpecializationKind()))
2612 return llvm::PointerUnion<VarTemplateDecl *,
2613 VarTemplatePartialSpecializationDecl *>();
2615 return getSpecializedTemplateOrPartial();
2618 /// Retrieve the variable template or variable template partial
2619 /// specialization which was specialized by this.
2620 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2621 getSpecializedTemplateOrPartial() const {
2622 if (const auto *PartialSpec =
2623 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2624 return PartialSpec->PartialSpecialization;
2626 return SpecializedTemplate.get<VarTemplateDecl *>();
2629 /// Retrieve the set of template arguments that should be used
2630 /// to instantiate the initializer of the variable template or variable
2631 /// template partial specialization from which this variable template
2632 /// specialization was instantiated.
2634 /// \returns For a variable template specialization instantiated from the
2635 /// primary template, this function will return the same template arguments
2636 /// as getTemplateArgs(). For a variable template specialization instantiated
2637 /// from a variable template partial specialization, this function will the
2638 /// return deduced template arguments for the variable template partial
2639 /// specialization itself.
2640 const TemplateArgumentList &getTemplateInstantiationArgs() const {
2641 if (const auto *PartialSpec =
2642 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2643 return *PartialSpec->TemplateArgs;
2645 return getTemplateArgs();
2648 /// Note that this variable template specialization is actually an
2649 /// instantiation of the given variable template partial specialization whose
2650 /// template arguments have been deduced.
2651 void setInstantiationOf(VarTemplatePartialSpecializationDecl *PartialSpec,
2652 const TemplateArgumentList *TemplateArgs) {
2653 assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
2654 "Already set to a variable template partial specialization!");
2655 auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
2656 PS->PartialSpecialization = PartialSpec;
2657 PS->TemplateArgs = TemplateArgs;
2658 SpecializedTemplate = PS;
2661 /// Note that this variable template specialization is an instantiation
2662 /// of the given variable template.
2663 void setInstantiationOf(VarTemplateDecl *TemplDecl) {
2664 assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
2665 "Previously set to a variable template partial specialization!");
2666 SpecializedTemplate = TemplDecl;
2669 /// Sets the type of this specialization as it was written by
2671 void setTypeAsWritten(TypeSourceInfo *T) {
2673 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2674 ExplicitInfo->TypeAsWritten = T;
2677 /// Gets the type of this specialization as it was written by
2678 /// the user, if it was so written.
2679 TypeSourceInfo *getTypeAsWritten() const {
2680 return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
2683 /// Gets the location of the extern keyword, if present.
2684 SourceLocation getExternLoc() const {
2685 return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
2688 /// Sets the location of the extern keyword.
2689 void setExternLoc(SourceLocation Loc) {
2691 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2692 ExplicitInfo->ExternLoc = Loc;
2695 /// Sets the location of the template keyword.
2696 void setTemplateKeywordLoc(SourceLocation Loc) {
2698 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2699 ExplicitInfo->TemplateKeywordLoc = Loc;
2702 /// Gets the location of the template keyword, if present.
2703 SourceLocation getTemplateKeywordLoc() const {
2704 return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
2707 void Profile(llvm::FoldingSetNodeID &ID) const {
2708 Profile(ID, TemplateArgs->asArray(), getASTContext());
2711 static void Profile(llvm::FoldingSetNodeID &ID,
2712 ArrayRef<TemplateArgument> TemplateArgs,
2713 ASTContext &Context) {
2714 ID.AddInteger(TemplateArgs.size());
2715 for (const TemplateArgument &TemplateArg : TemplateArgs)
2716 TemplateArg.Profile(ID, Context);
2719 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2721 static bool classofKind(Kind K) {
2722 return K >= firstVarTemplateSpecialization &&
2723 K <= lastVarTemplateSpecialization;
2727 class VarTemplatePartialSpecializationDecl
2728 : public VarTemplateSpecializationDecl {
2729 /// The list of template parameters
2730 TemplateParameterList *TemplateParams = nullptr;
2732 /// The source info for the template arguments as written.
2733 /// FIXME: redundant with TypeAsWritten?
2734 const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
2736 /// The variable template partial specialization from which this
2737 /// variable template partial specialization was instantiated.
2739 /// The boolean value will be true to indicate that this variable template
2740 /// partial specialization was specialized at this level.
2741 llvm::PointerIntPair<VarTemplatePartialSpecializationDecl *, 1, bool>
2742 InstantiatedFromMember;
2744 VarTemplatePartialSpecializationDecl(
2745 ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2746 SourceLocation IdLoc, TemplateParameterList *Params,
2747 VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
2748 StorageClass S, ArrayRef<TemplateArgument> Args,
2749 const ASTTemplateArgumentListInfo *ArgInfos);
2751 VarTemplatePartialSpecializationDecl(ASTContext &Context)
2752 : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization,
2754 InstantiatedFromMember(nullptr, false) {}
2756 void anchor() override;
2759 friend class ASTDeclReader;
2760 friend class ASTDeclWriter;
2762 static VarTemplatePartialSpecializationDecl *
2763 Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2764 SourceLocation IdLoc, TemplateParameterList *Params,
2765 VarTemplateDecl *SpecializedTemplate, QualType T,
2766 TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args,
2767 const TemplateArgumentListInfo &ArgInfos);
2769 static VarTemplatePartialSpecializationDecl *CreateDeserialized(ASTContext &C,
2772 VarTemplatePartialSpecializationDecl *getMostRecentDecl() {
2773 return cast<VarTemplatePartialSpecializationDecl>(
2774 static_cast<VarTemplateSpecializationDecl *>(
2775 this)->getMostRecentDecl());
2778 /// Get the list of template parameters
2779 TemplateParameterList *getTemplateParameters() const {
2780 return TemplateParams;
2783 /// Get the template arguments as written.
2784 const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
2785 return ArgsAsWritten;
2788 /// Retrieve the member variable template partial specialization from
2789 /// which this particular variable template partial specialization was
2793 /// template<typename T>
2795 /// template<typename U> U Inner;
2796 /// template<typename U> U* Inner<U*> = (U*)(0); // #1
2799 /// template int* Outer<float>::Inner<int*>;
2802 /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
2803 /// end up instantiating the partial specialization
2804 /// \c Outer<float>::Inner<U*>, which itself was instantiated from the
2805 /// variable template partial specialization \c Outer<T>::Inner<U*>. Given
2806 /// \c Outer<float>::Inner<U*>, this function would return
2807 /// \c Outer<T>::Inner<U*>.
2808 VarTemplatePartialSpecializationDecl *getInstantiatedFromMember() const {
2810 cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2811 return First->InstantiatedFromMember.getPointer();
2815 setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec) {
2816 auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2817 First->InstantiatedFromMember.setPointer(PartialSpec);
2820 /// Determines whether this variable template partial specialization
2821 /// was a specialization of a member partial specialization.
2823 /// In the following example, the member template partial specialization
2824 /// \c X<int>::Inner<T*> is a member specialization.
2827 /// template<typename T>
2829 /// template<typename U> U Inner;
2830 /// template<typename U> U* Inner<U*> = (U*)(0);
2833 /// template<> template<typename T>
2834 /// U* X<int>::Inner<T*> = (T*)(0) + 1;
2836 bool isMemberSpecialization() {
2838 cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2839 return First->InstantiatedFromMember.getInt();
2842 /// Note that this member template is a specialization.
2843 void setMemberSpecialization() {
2844 auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2845 assert(First->InstantiatedFromMember.getPointer() &&
2846 "Only member templates can be member template specializations");
2847 return First->InstantiatedFromMember.setInt(true);
2850 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2852 static bool classofKind(Kind K) {
2853 return K == VarTemplatePartialSpecialization;
2857 /// Declaration of a variable template.
2858 class VarTemplateDecl : public RedeclarableTemplateDecl {
2860 /// Data that is common to all of the declarations of a given
2861 /// variable template.
2862 struct Common : CommonBase {
2863 /// The variable template specializations for this variable
2864 /// template, including explicit specializations and instantiations.
2865 llvm::FoldingSetVector<VarTemplateSpecializationDecl> Specializations;
2867 /// The variable template partial specializations for this variable
2869 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>
2870 PartialSpecializations;
2875 /// Retrieve the set of specializations of this variable template.
2876 llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
2877 getSpecializations() const;
2879 /// Retrieve the set of partial specializations of this class
2881 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
2882 getPartialSpecializations();
2884 VarTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
2885 DeclarationName Name, TemplateParameterList *Params,
2887 : RedeclarableTemplateDecl(VarTemplate, C, DC, L, Name, Params, Decl) {}
2889 CommonBase *newCommon(ASTContext &C) const override;
2891 Common *getCommonPtr() const {
2892 return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2896 friend class ASTDeclReader;
2897 friend class ASTDeclWriter;
2899 /// Load any lazily-loaded specializations from the external source.
2900 void LoadLazySpecializations() const;
2902 /// Get the underlying variable declarations of the template.
2903 VarDecl *getTemplatedDecl() const {
2904 return static_cast<VarDecl *>(TemplatedDecl);
2907 /// Returns whether this template declaration defines the primary
2908 /// variable pattern.
2909 bool isThisDeclarationADefinition() const {
2910 return getTemplatedDecl()->isThisDeclarationADefinition();
2913 VarTemplateDecl *getDefinition();
2915 /// Create a variable template node.
2916 static VarTemplateDecl *Create(ASTContext &C, DeclContext *DC,
2917 SourceLocation L, DeclarationName Name,
2918 TemplateParameterList *Params,
2921 /// Create an empty variable template node.
2922 static VarTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2924 /// Return the specialization with the provided arguments if it exists,
2925 /// otherwise return the insertion point.
2926 VarTemplateSpecializationDecl *
2927 findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2929 /// Insert the specified specialization knowing that it is not already
2930 /// in. InsertPos must be obtained from findSpecialization.
2931 void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos);
2933 VarTemplateDecl *getCanonicalDecl() override {
2934 return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
2936 const VarTemplateDecl *getCanonicalDecl() const {
2937 return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
2940 /// Retrieve the previous declaration of this variable template, or
2941 /// nullptr if no such declaration exists.
2942 VarTemplateDecl *getPreviousDecl() {
2943 return cast_or_null<VarTemplateDecl>(
2944 static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2946 const VarTemplateDecl *getPreviousDecl() const {
2947 return cast_or_null<VarTemplateDecl>(
2948 static_cast<const RedeclarableTemplateDecl *>(
2949 this)->getPreviousDecl());
2952 VarTemplateDecl *getMostRecentDecl() {
2953 return cast<VarTemplateDecl>(
2954 static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
2956 const VarTemplateDecl *getMostRecentDecl() const {
2957 return const_cast<VarTemplateDecl *>(this)->getMostRecentDecl();
2960 VarTemplateDecl *getInstantiatedFromMemberTemplate() const {
2961 return cast_or_null<VarTemplateDecl>(
2962 RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
2965 /// Return the partial specialization with the provided arguments if it
2966 /// exists, otherwise return the insertion point.
2967 VarTemplatePartialSpecializationDecl *
2968 findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2970 /// Insert the specified partial specialization knowing that it is not
2971 /// already in. InsertPos must be obtained from findPartialSpecialization.
2972 void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D,
2975 /// Retrieve the partial specializations as an ordered list.
2976 void getPartialSpecializations(
2977 SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS);
2979 /// Find a variable template partial specialization which was
2981 /// from the given member partial specialization.
2983 /// \param D a member variable template partial specialization.
2985 /// \returns the variable template partial specialization which was
2987 /// from the given member partial specialization, or nullptr if no such
2988 /// partial specialization exists.
2989 VarTemplatePartialSpecializationDecl *findPartialSpecInstantiatedFromMember(
2990 VarTemplatePartialSpecializationDecl *D);
2992 using spec_iterator = SpecIterator<VarTemplateSpecializationDecl>;
2993 using spec_range = llvm::iterator_range<spec_iterator>;
2995 spec_range specializations() const {
2996 return spec_range(spec_begin(), spec_end());
2999 spec_iterator spec_begin() const {
3000 return makeSpecIterator(getSpecializations(), false);
3003 spec_iterator spec_end() const {
3004 return makeSpecIterator(getSpecializations(), true);
3007 // Implement isa/cast/dyncast support
3008 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3009 static bool classofKind(Kind K) { return K == VarTemplate; }
3012 inline NamedDecl *getAsNamedDecl(TemplateParameter P) {
3013 if (auto *PD = P.dyn_cast<TemplateTypeParmDecl *>())
3015 if (auto *PD = P.dyn_cast<NonTypeTemplateParmDecl *>())
3017 return P.get<TemplateTemplateParmDecl *>();
3020 inline TemplateDecl *getAsTypeTemplateDecl(Decl *D) {
3021 auto *TD = dyn_cast<TemplateDecl>(D);
3022 return TD && (isa<ClassTemplateDecl>(TD) ||
3023 isa<ClassTemplatePartialSpecializationDecl>(TD) ||
3024 isa<TypeAliasTemplateDecl>(TD) ||
3025 isa<TemplateTemplateParmDecl>(TD))
3030 } // namespace clang
3032 #endif // LLVM_CLANG_AST_DECLTEMPLATE_H