1//===- DeclTemplate.h - Classes for representing C++ templates --*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10/// \file
11/// Defines the C++ template declaration subclasses.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_AST_DECLTEMPLATE_H
16#define LLVM_CLANG_AST_DECLTEMPLATE_H
17
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"
37#include <cassert>
38#include <cstddef>
39#include <cstdint>
40#include <iterator>
41#include <utility>
42
43namespace clang {
44
45enum BuiltinTemplateKind : int;
46class ClassTemplateDecl;
47class ClassTemplatePartialSpecializationDecl;
48class Expr;
49class FunctionTemplateDecl;
50class IdentifierInfo;
51class NonTypeTemplateParmDecl;
52class TemplateDecl;
53class TemplateTemplateParmDecl;
54class TemplateTypeParmDecl;
55class UnresolvedSetImpl;
56class VarTemplateDecl;
57class VarTemplatePartialSpecializationDecl;
58
59/// Stores a template parameter of any kind.
60using TemplateParameter =
61 llvm::PointerUnion3<TemplateTypeParmDecl *, NonTypeTemplateParmDecl *,
62 TemplateTemplateParmDecl *>;
63
64NamedDecl *getAsNamedDecl(TemplateParameter P);
65
66/// Stores a list of template parameters for a TemplateDecl and its
67/// derived classes.
68class TemplateParameterList final
69 : private llvm::TrailingObjects<TemplateParameterList, NamedDecl *,
70 Expr *> {
71 /// The location of the 'template' keyword.
72 SourceLocation TemplateLoc;
73
74 /// The locations of the '<' and '>' angle brackets.
75 SourceLocation LAngleLoc, RAngleLoc;
76
77 /// The number of template parameters in this template
78 /// parameter list.
79 unsigned NumParams : 30;
80
81 /// Whether this template parameter list contains an unexpanded parameter
82 /// pack.
83 unsigned ContainsUnexpandedParameterPack : 1;
84
85 /// Whether this template parameter list has an associated requires-clause
86 unsigned HasRequiresClause : 1;
87
88protected:
89 TemplateParameterList(SourceLocation TemplateLoc, SourceLocation LAngleLoc,
90 ArrayRef<NamedDecl *> Params, SourceLocation RAngleLoc,
91 Expr *RequiresClause);
92
93 size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
94 return NumParams;
95 }
96
97 size_t numTrailingObjects(OverloadToken<Expr *>) const {
98 return HasRequiresClause;
99 }
100
101public:
102 template <size_t N, bool HasRequiresClause>
103 friend class FixedSizeTemplateParameterListStorage;
104 friend TrailingObjects;
105
106 static TemplateParameterList *Create(const ASTContext &C,
107 SourceLocation TemplateLoc,
108 SourceLocation LAngleLoc,
109 ArrayRef<NamedDecl *> Params,
110 SourceLocation RAngleLoc,
111 Expr *RequiresClause);
112
113 /// Iterates through the template parameters in this list.
114 using iterator = NamedDecl **;
115
116 /// Iterates through the template parameters in this list.
117 using const_iterator = NamedDecl * const *;
118
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; }
123
124 unsigned size() const { return NumParams; }
125
126 ArrayRef<NamedDecl*> asArray() {
127 return llvm::makeArrayRef(begin(), end());
128 }
129 ArrayRef<const NamedDecl*> asArray() const {
130 return llvm::makeArrayRef(begin(), size());
131 }
132
133 NamedDecl* getParam(unsigned Idx) {
134 assert(Idx < size() && "Template parameter index out-of-range");
135 return begin()[Idx];
136 }
137 const NamedDecl* getParam(unsigned Idx) const {
138 assert(Idx < size() && "Template parameter index out-of-range");
139 return begin()[Idx];
140 }
141
142 /// Returns the minimum number of arguments needed to form a
143 /// template specialization.
144 ///
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;
148
149 /// Get the depth of this template parameter list in the set of
150 /// template parameter lists.
151 ///
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;
155
156 /// Determine whether this template parameter list contains an
157 /// unexpanded parameter pack.
158 bool containsUnexpandedParameterPack() const {
159 return ContainsUnexpandedParameterPack;
160 }
161
162 /// The constraint-expression of the associated requires-clause.
163 Expr *getRequiresClause() {
164 return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
165 }
166
167 /// The constraint-expression of the associated requires-clause.
168 const Expr *getRequiresClause() const {
169 return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
170 }
171
172 SourceLocation getTemplateLoc() const { return TemplateLoc; }
173 SourceLocation getLAngleLoc() const { return LAngleLoc; }
174 SourceLocation getRAngleLoc() const { return RAngleLoc; }
175
176 SourceRange getSourceRange() const LLVM_READONLY {
177 return SourceRange(TemplateLoc, RAngleLoc);
178 }
179
180public:
181 // FIXME: workaround for MSVC 2013; remove when no longer needed
182 using FixedSizeStorageOwner = TrailingObjects::FixedSizeStorageOwner;
183};
184
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.
188template <size_t N, bool HasRequiresClause>
189class FixedSizeTemplateParameterListStorage
190 : public TemplateParameterList::FixedSizeStorageOwner {
191 typename TemplateParameterList::FixedSizeStorage<
192 NamedDecl *, Expr *>::with_counts<
193 N, HasRequiresClause ? 1u : 0u
194 >::type storage;
195
196public:
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))) {}
207};
208
209/// A template argument list.
210class TemplateArgumentList final
211 : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {
212 /// The template argument list.
213 const TemplateArgument *Arguments;
214
215 /// The number of template arguments in this template
216 /// argument list.
217 unsigned NumArguments;
218
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);
222
223public:
224 friend TrailingObjects;
225
226 TemplateArgumentList(const TemplateArgumentList &) = delete;
227 TemplateArgumentList &operator=(const TemplateArgumentList &) = delete;
228
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 };
232
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);
237
238 /// Construct a new, temporary template argument list on the stack.
239 ///
240 /// The template argument list does not own the template arguments
241 /// provided.
242 explicit TemplateArgumentList(OnStackType, ArrayRef<TemplateArgument> Args)
243 : Arguments(Args.data()), NumArguments(Args.size()) {}
244
245 /// Produces a shallow copy of the given template argument list.
246 ///
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
250 /// way.
251 explicit TemplateArgumentList(const TemplateArgumentList *Other)
252 : Arguments(Other->data()), NumArguments(Other->size()) {}
253
254 /// Retrieve the template argument at a given index.
255 const TemplateArgument &get(unsigned Idx) const {
256 assert(Idx < NumArguments && "Invalid template argument index");
257 return data()[Idx];
258 }
259
260 /// Retrieve the template argument at a given index.
261 const TemplateArgument &operator[](unsigned Idx) const { return get(Idx); }
262
263 /// Produce this as an array ref.
264 ArrayRef<TemplateArgument> asArray() const {
265 return llvm::makeArrayRef(data(), size());
266 }
267
268 /// Retrieve the number of template arguments in this
269 /// template argument list.
270 unsigned size() const { return NumArguments; }
271
272 /// Retrieve a pointer to the template argument list.
273 const TemplateArgument *data() const { return Arguments; }
274};
275
276void *allocateDefaultArgStorageChain(const ASTContext &C);
277
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
280/// argument.
281///
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.
286template<typename ParmDecl, typename ArgType>
287class 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.
291 struct Chain {
292 ParmDecl *PrevDeclWithDefaultArg;
293 ArgType Value;
294 };
295 static_assert(sizeof(Chain) == sizeof(void *) * 2,
296 "non-pointer argument type?");
297
298 llvm::PointerUnion3<ArgType, ParmDecl*, Chain*> ValueOrInherited;
299
300 static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {
301 const DefaultArgStorage &Storage = Parm->getDefaultArgStorage();
302 if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl *>())
303 Parm = Prev;
304 assert(!Parm->getDefaultArgStorage()
305 .ValueOrInherited.template is<ParmDecl *>() &&
306 "should only be one level of indirection");
307 return Parm;
308 }
309
310public:
311 DefaultArgStorage() : ValueOrInherited(ArgType()) {}
312
313 /// Determine whether there is a default argument for this parameter.
314 bool isSet() const { return !ValueOrInherited.isNull(); }
315
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*>(); }
319
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 *>())
327 return C->Value;
328 return Storage->ValueOrInherited.template get<ArgType>();
329 }
330
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 *>())
335 return D;
336 if (const auto *C = ValueOrInherited.template dyn_cast<Chain *>())
337 return C->PrevDeclWithDefaultArg;
338 return nullptr;
339 }
340
341 /// Set the default argument.
342 void set(ArgType Arg) {
343 assert(!isSet() && "default argument already set");
344 ValueOrInherited = Arg;
345 }
346
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);
351 if (!isSet())
352 ValueOrInherited = InheritedFrom;
353 else
354 ValueOrInherited = new (allocateDefaultArgStorageChain(C))
355 Chain{InheritedFrom, ValueOrInherited.template get<ArgType>()};
356 }
357
358 /// Remove the default argument, even if it was inherited.
359 void clear() {
360 ValueOrInherited = ArgType();
361 }
362};
363
364//===----------------------------------------------------------------------===//
365// Kinds of Templates
366//===----------------------------------------------------------------------===//
367
368/// Stores the template parameter list and associated constraints for
369/// \c TemplateDecl objects that track associated constraints.
370class ConstrainedTemplateDeclInfo {
371 friend TemplateDecl;
372
373public:
374 ConstrainedTemplateDeclInfo() = default;
375
376 TemplateParameterList *getTemplateParameters() const {
377 return TemplateParams;
378 }
379
380 Expr *getAssociatedConstraints() const { return AssociatedConstraints; }
381
382protected:
383 void setTemplateParameters(TemplateParameterList *TParams) {
384 TemplateParams = TParams;
385 }
386
387 void setAssociatedConstraints(Expr *AC) { AssociatedConstraints = AC; }
388
389 TemplateParameterList *TemplateParams = nullptr;
390 Expr *AssociatedConstraints = nullptr;
391};
392
393
394/// The base class of all kinds of template declarations (e.g.,
395/// class, function, etc.).
396///
397/// The TemplateDecl class stores the list of template parameters and a
398/// reference to the templated scoped declaration: the underlying AST node.
399class TemplateDecl : public NamedDecl {
400 void anchor() override;
401
402protected:
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);
411 }
412
413 TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,
414 TemplateParameterList *Params)
415 : TemplateDecl(nullptr, DK, DC, L, Name, Params) {}
416
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);
424 }
425
426 TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,
427 TemplateParameterList *Params, NamedDecl *Decl)
428 : TemplateDecl(nullptr, DK, DC, L, Name, Params, Decl) {}
429
430public:
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 *>();
437 }
438
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;
443 }
444
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;
450 }
451
452 /// Get the underlying, templated declaration.
453 NamedDecl *getTemplatedDecl() const { return TemplatedDecl; }
454
455 // Implement isa/cast/dyncast/etc.
456 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
457
458 static bool classofKind(Kind K) {
459 return K >= firstTemplate && K <= lastTemplate;
460 }
461
462 SourceRange getSourceRange() const override LLVM_READONLY {
463 return SourceRange(getTemplateParameters()->getTemplateLoc(),
464 TemplatedDecl->getSourceRange().getEnd());
465 }
466
467protected:
468 NamedDecl *TemplatedDecl;
469
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 *>
476 TemplateParams;
477
478 void setTemplateParameters(TemplateParameterList *TParams) {
479 if (auto *const CTDI =
480 TemplateParams.dyn_cast<ConstrainedTemplateDeclInfo *>()) {
481 CTDI->setTemplateParameters(TParams);
482 } else {
483 TemplateParams = TParams;
484 }
485 }
486
487 void setAssociatedConstraints(Expr *AC) {
488 assert(isCanonicalDecl() &&
489 "Attaching associated constraints to non-canonical Decl");
490 TemplateParams.get<ConstrainedTemplateDeclInfo *>()
491 ->setAssociatedConstraints(AC);
492 }
493
494public:
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;
502 }
503};
504
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.
508class FunctionTemplateSpecializationInfo : public llvm::FoldingSetNode {
509 FunctionTemplateSpecializationInfo(FunctionDecl *FD,
510 FunctionTemplateDecl *Template,
511 TemplateSpecializationKind TSK,
512 const TemplateArgumentList *TemplateArgs,
513 const ASTTemplateArgumentListInfo *TemplateArgsAsWritten,
514 SourceLocation POI)
515 : Function(FD), Template(Template, TSK - 1),
516 TemplateArguments(TemplateArgs),
517 TemplateArgumentsAsWritten(TemplateArgsAsWritten),
518 PointOfInstantiation(POI) {}
519
520public:
521 static FunctionTemplateSpecializationInfo *
522 Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template,
523 TemplateSpecializationKind TSK,
524 const TemplateArgumentList *TemplateArgs,
525 const TemplateArgumentListInfo *TemplateArgsAsWritten,
526 SourceLocation POI);
527
528 /// The function template specialization that this structure
529 /// describes.
530 FunctionDecl *Function;
531
532 /// The function template from which this function template
533 /// specialization was generated.
534 ///
535 /// The two bits contain the top 4 values of TemplateSpecializationKind.
536 llvm::PointerIntPair<FunctionTemplateDecl *, 2> Template;
537
538 /// The template arguments used to produce the function template
539 /// specialization from the function template.
540 const TemplateArgumentList *TemplateArguments;
541
542 /// The template arguments as written in the sources, if provided.
543 const ASTTemplateArgumentListInfo *TemplateArgumentsAsWritten;
544
545 /// The point at which this function template specialization was
546 /// first instantiated.
547 SourceLocation PointOfInstantiation;
548
549 /// Retrieve the template from which this function was specialized.
550 FunctionTemplateDecl *getTemplate() const { return Template.getPointer(); }
551
552 /// Determine what kind of template specialization this is.
553 TemplateSpecializationKind getTemplateSpecializationKind() const {
554 return (TemplateSpecializationKind)(Template.getInt() + 1);
555 }
556
557 bool isExplicitSpecialization() const {
558 return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
559 }
560
561 /// True if this declaration is an explicit specialization,
562 /// explicit instantiation declaration, or explicit instantiation
563 /// definition.
564 bool isExplicitInstantiationOrSpecialization() const {
565 return isTemplateExplicitInstantiationOrSpecialization(
566 getTemplateSpecializationKind());
567 }
568
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);
574 }
575
576 /// Retrieve the first point of instantiation of this function
577 /// template specialization.
578 ///
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;
583 }
584
585 /// Set the (first) point of instantiation of this function template
586 /// specialization.
587 void setPointOfInstantiation(SourceLocation POI) {
588 PointOfInstantiation = POI;
589 }
590
591 void Profile(llvm::FoldingSetNodeID &ID) {
592 Profile(ID, TemplateArguments->asArray(),
593 Function->getASTContext());
594 }
595
596 static void
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);
602 }
603};
604
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.
608class 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;
612
613 // The point at which this member was first instantiated.
614 SourceLocation PointOfInstantiation;
615
616public:
617 explicit
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");
623 }
624
625 /// Retrieve the member declaration from which this member was
626 /// instantiated.
627 NamedDecl *getInstantiatedFrom() const { return MemberAndTSK.getPointer(); }
628
629 /// Determine what kind of template specialization this is.
630 TemplateSpecializationKind getTemplateSpecializationKind() const {
631 return (TemplateSpecializationKind)(MemberAndTSK.getInt() + 1);
632 }
633
634 bool isExplicitSpecialization() const {
635 return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
636 }
637
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);
643 }
644
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;
650 }
651
652 /// Set the first point of instantiation.
653 void setPointOfInstantiation(SourceLocation POI) {
654 PointOfInstantiation = POI;
655 }
656};
657
658/// Provides information about a dependent function-template
659/// specialization declaration.
660///
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:
665///
666/// \code
667/// template \<class T> void foo(T);
668/// template \<class T> class A {
669/// friend void foo<>(T);
670/// };
671/// \endcode
672class DependentFunctionTemplateSpecializationInfo final
673 : private llvm::TrailingObjects<DependentFunctionTemplateSpecializationInfo,
674 TemplateArgumentLoc,
675 FunctionTemplateDecl *> {
676 /// The number of potential template candidates.
677 unsigned NumTemplates;
678
679 /// The number of template arguments.
680 unsigned NumArgs;
681
682 /// The locations of the left and right angle brackets.
683 SourceRange AngleLocs;
684
685 size_t numTrailingObjects(OverloadToken<TemplateArgumentLoc>) const {
686 return NumArgs;
687 }
688 size_t numTrailingObjects(OverloadToken<FunctionTemplateDecl *>) const {
689 return NumTemplates;
690 }
691
692 DependentFunctionTemplateSpecializationInfo(
693 const UnresolvedSetImpl &Templates,
694 const TemplateArgumentListInfo &TemplateArgs);
695
696public:
697 friend TrailingObjects;
698
699 static DependentFunctionTemplateSpecializationInfo *
700 Create(ASTContext &Context, const UnresolvedSetImpl &Templates,
701 const TemplateArgumentListInfo &TemplateArgs);
702
703 /// Returns the number of function templates that this might
704 /// be a specialization of.
705 unsigned getNumTemplates() const { return NumTemplates; }
706
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];
711 }
712
713 /// Returns the explicit template arguments that were given.
714 const TemplateArgumentLoc *getTemplateArgs() const {
715 return getTrailingObjects<TemplateArgumentLoc>();
716 }
717
718 /// Returns the number of explicit template arguments that were given.
719 unsigned getNumTemplateArgs() const { return NumArgs; }
720
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];
725 }
726
727 SourceLocation getLAngleLoc() const {
728 return AngleLocs.getBegin();
729 }
730
731 SourceLocation getRAngleLoc() const {
732 return AngleLocs.getEnd();
733 }
734};
735
736/// Declaration of a redeclarable template.
737class RedeclarableTemplateDecl : public TemplateDecl,
738 public Redeclarable<RedeclarableTemplateDecl>
739{
740 using redeclarable_base = Redeclarable<RedeclarableTemplateDecl>;
741
742 RedeclarableTemplateDecl *getNextRedeclarationImpl() override {
743 return getNextRedeclaration();
744 }
745
746 RedeclarableTemplateDecl *getPreviousDeclImpl() override {
747 return getPreviousDecl();
748 }
749
750 RedeclarableTemplateDecl *getMostRecentDeclImpl() override {
751 return getMostRecentDecl();
752 }
753
754protected:
755 template <typename EntryType> struct SpecEntryTraits {
756 using DeclType = EntryType;
757
758 static DeclType *getDecl(EntryType *D) {
759 return D;
760 }
761
762 static ArrayRef<TemplateArgument> getTemplateArgs(EntryType *D) {
763 return D->getTemplateArgs().asArray();
764 }
765 };
766
767 template <typename EntryType, typename SETraits = SpecEntryTraits<EntryType>,
768 typename DeclType = typename SETraits::DeclType>
769 struct SpecIterator
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)) {}
780
781 DeclType *operator*() const {
782 return SETraits::getDecl(&*this->I)->getMostRecentDecl();
783 }
784
785 DeclType *operator->() const { return **this; }
786 };
787
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());
792 }
793
794 void loadLazySpecializationsImpl() const;
795
796 template <class EntryType> typename SpecEntryTraits<EntryType>::DeclType*
797 findSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs,
798 ArrayRef<TemplateArgument> Args, void *&InsertPos);
799
800 template <class Derived, class EntryType>
801 void addSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs,
802 EntryType *Entry, void *InsertPos);
803
804 struct CommonBase {
805 CommonBase() : InstantiatedFromMember(nullptr, false) {}
806
807 /// The template from which this was most
808 /// directly instantiated (or null).
809 ///
810 /// The boolean value indicates whether this template
811 /// was explicitly specialized.
812 llvm::PointerIntPair<RedeclarableTemplateDecl*, 1, bool>
813 InstantiatedFromMember;
814
815 /// If non-null, points to an array of specializations (including
816 /// partial specializations) known only by their external declaration IDs.
817 ///
818 /// The first value in the array is the number of specializations/partial
819 /// specializations that follow.
820 uint32_t *LazySpecializations = nullptr;
821 };
822
823 /// Pointer to the common data shared by all declarations of this
824 /// template.
825 mutable CommonBase *Common = nullptr;
826
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;
831
832 virtual CommonBase *newCommon(ASTContext &C) const = 0;
833
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,
838 NamedDecl *Decl)
839 : TemplateDecl(CTDI, DK, DC, L, Name, Params, Decl), redeclarable_base(C)
840 {}
841
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) {}
846
847public:
848 friend class ASTDeclReader;
849 friend class ASTDeclWriter;
850 friend class ASTReader;
851 template <class decl_type> friend class RedeclarableTemplate;
852
853 /// Retrieves the canonical declaration of this template.
854 RedeclarableTemplateDecl *getCanonicalDecl() override {
855 return getFirstDecl();
856 }
857 const RedeclarableTemplateDecl *getCanonicalDecl() const {
858 return getFirstDecl();
859 }
860
861 /// Determines whether this template was a specialization of a
862 /// member template.
863 ///
864 /// In the following example, the function template \c X<int>::f and the
865 /// member template \c X<int>::Inner are member specializations.
866 ///
867 /// \code
868 /// template<typename T>
869 /// struct X {
870 /// template<typename U> void f(T, U);
871 /// template<typename U> struct Inner;
872 /// };
873 ///
874 /// template<> template<typename T>
875 /// void X<int>::f(int, T);
876 /// template<> template<typename T>
877 /// struct X<int>::Inner { /* ... */ };
878 /// \endcode
879 bool isMemberSpecialization() const {
880 return getCommonPtr()->InstantiatedFromMember.getInt();
881 }
882
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);
888 }
889
890 /// Retrieve the member template from which this template was
891 /// instantiated, or nullptr if this template was not instantiated from a
892 /// member template.
893 ///
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
896 /// example, given
897 ///
898 /// \code
899 /// template<typename T>
900 /// struct X {
901 /// template<typename U> void f(T, U);
902 /// };
903 ///
904 /// void test(X<int> x) {
905 /// x.f(1, 'a');
906 /// };
907 /// \endcode
908 ///
909 /// \c X<int>::f is a FunctionTemplateDecl that describes the function
910 /// template
911 ///
912 /// \code
913 /// template<typename U> void X<int>::f(int, U);
914 /// \endcode
915 ///
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.,
920 ///
921 /// \code
922 /// template<typename T>
923 /// template<typename U>
924 /// void X<T>::f(T, U);
925 /// \endcode
926 RedeclarableTemplateDecl *getInstantiatedFromMemberTemplate() const {
927 return getCommonPtr()->InstantiatedFromMember.getPointer();
928 }
929
930 void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD) {
931 assert(!getCommonPtr()->InstantiatedFromMember.getPointer());
932 getCommonPtr()->InstantiatedFromMember.setPointer(TD);
933 }
934
935 using redecl_range = redeclarable_base::redecl_range;
936 using redecl_iterator = redeclarable_base::redecl_iterator;
937
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;
944
945 // Implement isa/cast/dyncast/etc.
946 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
947
948 static bool classofKind(Kind K) {
949 return K >= firstRedeclarableTemplate && K <= lastRedeclarableTemplate;
950 }
951};
952
953template <> struct RedeclarableTemplateDecl::
954SpecEntryTraits<FunctionTemplateSpecializationInfo> {
955 using DeclType = FunctionDecl;
956
957 static DeclType *getDecl(FunctionTemplateSpecializationInfo *I) {
958 return I->Function;
959 }
960
961 static ArrayRef<TemplateArgument>
962 getTemplateArgs(FunctionTemplateSpecializationInfo *I) {
963 return I->TemplateArguments->asArray();
964 }
965};
966
967/// Declaration of a template function.
968class FunctionTemplateDecl : public RedeclarableTemplateDecl {
969protected:
970 friend class FunctionDecl;
971
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;
978
979 /// The set of "injected" template arguments used within this
980 /// function template.
981 ///
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;
987
988 Common() = default;
989 };
990
991 FunctionTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
992 DeclarationName Name, TemplateParameterList *Params,
993 NamedDecl *Decl)
994 : RedeclarableTemplateDecl(FunctionTemplate, C, DC, L, Name, Params,
995 Decl) {}
996
997 CommonBase *newCommon(ASTContext &C) const override;
998
999 Common *getCommonPtr() const {
1000 return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
1001 }
1002
1003 /// Retrieve the set of function template specializations of this
1004 /// function template.
1005 llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
1006 getSpecializations() const;
1007
1008 /// Add a specialization of this function template.
1009 ///
1010 /// \param InsertPos Insert position in the FoldingSetVector, must have been
1011 /// retrieved by an earlier call to findSpecialization().
1012 void addSpecialization(FunctionTemplateSpecializationInfo* Info,
1013 void *InsertPos);
1014
1015public:
1016 friend class ASTDeclReader;
1017 friend class ASTDeclWriter;
1018
1019 /// Load any lazily-loaded specializations from the external source.
1020 void LoadLazySpecializations() const;
1021
1022 /// Get the underlying function declaration of the template.
1023 FunctionDecl *getTemplatedDecl() const {
1024 return static_cast<FunctionDecl *>(TemplatedDecl);
1025 }
1026
1027 /// Returns whether this template declaration defines the primary
1028 /// pattern.
1029 bool isThisDeclarationADefinition() const {
1030 return getTemplatedDecl()->isThisDeclarationADefinition();
1031 }
1032
1033 /// Return the specialization with the provided arguments if it exists,
1034 /// otherwise return the insertion point.
1035 FunctionDecl *findSpecialization(ArrayRef<TemplateArgument> Args,
1036 void *&InsertPos);
1037
1038 FunctionTemplateDecl *getCanonicalDecl() override {
1039 return cast<FunctionTemplateDecl>(
1040 RedeclarableTemplateDecl::getCanonicalDecl());
1041 }
1042 const FunctionTemplateDecl *getCanonicalDecl() const {
1043 return cast<FunctionTemplateDecl>(
1044 RedeclarableTemplateDecl::getCanonicalDecl());
1045 }
1046
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());
1052 }
1053 const FunctionTemplateDecl *getPreviousDecl() const {
1054 return cast_or_null<FunctionTemplateDecl>(
1055 static_cast<const RedeclarableTemplateDecl *>(this)->getPreviousDecl());
1056 }
1057
1058 FunctionTemplateDecl *getMostRecentDecl() {
1059 return cast<FunctionTemplateDecl>(
1060 static_cast<RedeclarableTemplateDecl *>(this)
1061 ->getMostRecentDecl());
1062 }
1063 const FunctionTemplateDecl *getMostRecentDecl() const {
1064 return const_cast<FunctionTemplateDecl*>(this)->getMostRecentDecl();
1065 }
1066
1067 FunctionTemplateDecl *getInstantiatedFromMemberTemplate() const {
1068 return cast_or_null<FunctionTemplateDecl>(
1069 RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
1070 }
1071
1072 using spec_iterator = SpecIterator<FunctionTemplateSpecializationInfo>;
1073 using spec_range = llvm::iterator_range<spec_iterator>;
1074
1075 spec_range specializations() const {
1076 return spec_range(spec_begin(), spec_end());
1077 }
1078
1079 spec_iterator spec_begin() const {
1080 return makeSpecIterator(getSpecializations(), false);
1081 }
1082
1083 spec_iterator spec_end() const {
1084 return makeSpecIterator(getSpecializations(), true);
1085 }
1086
1087 /// Retrieve the "injected" template arguments that correspond to the
1088 /// template parameters of this function template.
1089 ///
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
1093 /// template.
1094 ArrayRef<TemplateArgument> getInjectedTemplateArgs();
1095
1096 /// Merge \p Prev with our RedeclarableTemplateDecl::Common.
1097 void mergePrevDecl(FunctionTemplateDecl *Prev);
1098
1099 /// Create a function template node.
1100 static FunctionTemplateDecl *Create(ASTContext &C, DeclContext *DC,
1101 SourceLocation L,
1102 DeclarationName Name,
1103 TemplateParameterList *Params,
1104 NamedDecl *Decl);
1105
1106 /// Create an empty function template node.
1107 static FunctionTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1108
1109 // Implement isa/cast/dyncast support
1110 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1111 static bool classofKind(Kind K) { return K == FunctionTemplate; }
1112};
1113
1114//===----------------------------------------------------------------------===//
1115// Kinds of Template Parameters
1116//===----------------------------------------------------------------------===//
1117
1118/// Defines the position of a template parameter within a template
1119/// parameter list.
1120///
1121/// Because template parameter can be listed
1122/// sequentially for out-of-line template members, each template parameter is
1123/// given a Depth - the nesting of template parameter scopes - and a Position -
1124/// the occurrence within the parameter list.
1125/// This class is inheritedly privately by different kinds of template
1126/// parameters and is not part of the Decl hierarchy. Just a facility.
1127class TemplateParmPosition {
1128protected:
1129 // FIXME: These probably don't need to be ints. int:5 for depth, int:8 for
1130 // position? Maybe?
1131 unsigned Depth;
1132 unsigned Position;
1133
1134 TemplateParmPosition(unsigned D, unsigned P) : Depth(D), Position(P) {}
1135
1136public:
1137 TemplateParmPosition() = delete;
1138
1139 /// Get the nesting depth of the template parameter.
1140 unsigned getDepth() const { return Depth; }
1141 void setDepth(unsigned D) { Depth = D; }
1142
1143 /// Get the position of the template parameter within its parameter list.
1144 unsigned getPosition() const { return Position; }
1145 void setPosition(unsigned P) { Position = P; }
1146
1147 /// Get the index of the template parameter within its parameter list.
1148 unsigned getIndex() const { return Position; }
1149};
1150
1151/// Declaration of a template type parameter.
1152///
1153/// For example, "T" in
1154/// \code
1155/// template<typename T> class vector;
1156/// \endcode
1157class TemplateTypeParmDecl : public TypeDecl {
1158 /// Sema creates these on the stack during auto type deduction.
1159 friend class Sema;
1160
1161 /// Whether this template type parameter was declaration with
1162 /// the 'typename' keyword.
1163 ///
1164 /// If false, it was declared with the 'class' keyword.
1165 bool Typename : 1;
1166
1167 /// The default template argument, if any.
1168 using DefArgStorage =
1169 DefaultArgStorage<TemplateTypeParmDecl, TypeSourceInfo *>;
1170 DefArgStorage DefaultArgument;
1171
1172 TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc,
1173 SourceLocation IdLoc, IdentifierInfo *Id,
1174 bool Typename)
1175 : TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename) {}
1176
1177public:
1178 static TemplateTypeParmDecl *Create(const ASTContext &C, DeclContext *DC,
1179 SourceLocation KeyLoc,
1180 SourceLocation NameLoc,
1181 unsigned D, unsigned P,
1182 IdentifierInfo *Id, bool Typename,
1183 bool ParameterPack);
1184 static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C,
1185 unsigned ID);
1186
1187 /// Whether this template type parameter was declared with
1188 /// the 'typename' keyword.
1189 ///
1190 /// If not, it was declared with the 'class' keyword.
1191 bool wasDeclaredWithTypename() const { return Typename; }
1192
1193 const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1194
1195 /// Determine whether this template parameter has a default
1196 /// argument.
1197 bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1198
1199 /// Retrieve the default argument, if any.
1200 QualType getDefaultArgument() const {
1201 return DefaultArgument.get()->getType();
1202 }
1203
1204 /// Retrieves the default argument's source information, if any.
1205 TypeSourceInfo *getDefaultArgumentInfo() const {
1206 return DefaultArgument.get();
1207 }
1208
1209 /// Retrieves the location of the default argument declaration.
1210 SourceLocation getDefaultArgumentLoc() const;
1211
1212 /// Determines whether the default argument was inherited
1213 /// from a previous declaration of this template.
1214 bool defaultArgumentWasInherited() const {
1215 return DefaultArgument.isInherited();
1216 }
1217
1218 /// Set the default argument for this template parameter.
1219 void setDefaultArgument(TypeSourceInfo *DefArg) {
1220 DefaultArgument.set(DefArg);
1221 }
1222
1223 /// Set that this default argument was inherited from another
1224 /// parameter.
1225 void setInheritedDefaultArgument(const ASTContext &C,
1226 TemplateTypeParmDecl *Prev) {
1227 DefaultArgument.setInherited(C, Prev);
1228 }
1229
1230 /// Removes the default argument of this template parameter.
1231 void removeDefaultArgument() {
1232 DefaultArgument.clear();
1233 }
1234
1235 /// Set whether this template type parameter was declared with
1236 /// the 'typename' or 'class' keyword.
1237 void setDeclaredWithTypename(bool withTypename) { Typename = withTypename; }
1238
1239 /// Retrieve the depth of the template parameter.
1240 unsigned getDepth() const;
1241
1242 /// Retrieve the index of the template parameter.
1243 unsigned getIndex() const;
1244
1245 /// Returns whether this is a parameter pack.
1246 bool isParameterPack() const;
1247
1248 SourceRange getSourceRange() const override LLVM_READONLY;
1249
1250 // Implement isa/cast/dyncast/etc.
1251 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1252 static bool classofKind(Kind K) { return K == TemplateTypeParm; }
1253};
1254
1255/// NonTypeTemplateParmDecl - Declares a non-type template parameter,
1256/// e.g., "Size" in
1257/// @code
1258/// template<int Size> class array { };
1259/// @endcode
1260class NonTypeTemplateParmDecl final
1261 : public DeclaratorDecl,
1262 protected TemplateParmPosition,
1263 private llvm::TrailingObjects<NonTypeTemplateParmDecl,
1264 std::pair<QualType, TypeSourceInfo *>> {
1265 friend class ASTDeclReader;
1266 friend TrailingObjects;
1267
1268 /// The default template argument, if any, and whether or not
1269 /// it was inherited.
1270 using DefArgStorage = DefaultArgStorage<NonTypeTemplateParmDecl, Expr *>;
1271 DefArgStorage DefaultArgument;
1272
1273 // FIXME: Collapse this into TemplateParamPosition; or, just move depth/index
1274 // down here to save memory.
1275
1276 /// Whether this non-type template parameter is a parameter pack.
1277 bool ParameterPack;
1278
1279 /// Whether this non-type template parameter is an "expanded"
1280 /// parameter pack, meaning that its type is a pack expansion and we
1281 /// already know the set of types that expansion expands to.
1282 bool ExpandedParameterPack = false;
1283
1284 /// The number of types in an expanded parameter pack.
1285 unsigned NumExpandedTypes = 0;
1286
1287 size_t numTrailingObjects(
1288 OverloadToken<std::pair<QualType, TypeSourceInfo *>>) const {
1289 return NumExpandedTypes;
1290 }
1291
1292 NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
1293 SourceLocation IdLoc, unsigned D, unsigned P,
1294 IdentifierInfo *Id, QualType T,
1295 bool ParameterPack, TypeSourceInfo *TInfo)
1296 : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
1297 TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
1298
1299 NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
1300 SourceLocation IdLoc, unsigned D, unsigned P,
1301 IdentifierInfo *Id, QualType T,
1302 TypeSourceInfo *TInfo,
1303 ArrayRef<QualType> ExpandedTypes,
1304 ArrayRef<TypeSourceInfo *> ExpandedTInfos);
1305
1306public:
1307 static NonTypeTemplateParmDecl *
1308 Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1309 SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
1310 QualType T, bool ParameterPack, TypeSourceInfo *TInfo);
1311
1312 static NonTypeTemplateParmDecl *
1313 Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1314 SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
1315 QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
1316 ArrayRef<TypeSourceInfo *> ExpandedTInfos);
1317
1318 static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
1319 unsigned ID);
1320 static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
1321 unsigned ID,
1322 unsigned NumExpandedTypes);
1323
1324 using TemplateParmPosition::getDepth;
1325 using TemplateParmPosition::setDepth;
1326 using TemplateParmPosition::getPosition;
1327 using TemplateParmPosition::setPosition;
1328 using TemplateParmPosition::getIndex;
1329
1330 SourceRange getSourceRange() const override LLVM_READONLY;
1331
1332 const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1333
1334 /// Determine whether this template parameter has a default
1335 /// argument.
1336 bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1337
1338 /// Retrieve the default argument, if any.
1339 Expr *getDefaultArgument() const { return DefaultArgument.get(); }
1340
1341 /// Retrieve the location of the default argument, if any.
1342 SourceLocation getDefaultArgumentLoc() const;
1343
1344 /// Determines whether the default argument was inherited
1345 /// from a previous declaration of this template.
1346 bool defaultArgumentWasInherited() const {
1347 return DefaultArgument.isInherited();
1348 }
1349
1350 /// Set the default argument for this template parameter, and
1351 /// whether that default argument was inherited from another
1352 /// declaration.
1353 void setDefaultArgument(Expr *DefArg) { DefaultArgument.set(DefArg); }
1354 void setInheritedDefaultArgument(const ASTContext &C,
1355 NonTypeTemplateParmDecl *Parm) {
1356 DefaultArgument.setInherited(C, Parm);
1357 }
1358
1359 /// Removes the default argument of this template parameter.
1360 void removeDefaultArgument() { DefaultArgument.clear(); }
1361
1362 /// Whether this parameter is a non-type template parameter pack.
1363 ///
1364 /// If the parameter is a parameter pack, the type may be a
1365 /// \c PackExpansionType. In the following example, the \c Dims parameter
1366 /// is a parameter pack (whose type is 'unsigned').
1367 ///
1368 /// \code
1369 /// template<typename T, unsigned ...Dims> struct multi_array;
1370 /// \endcode
1371 bool isParameterPack() const { return ParameterPack; }
1372
1373 /// Whether this parameter pack is a pack expansion.
1374 ///
1375 /// A non-type template parameter pack is a pack expansion if its type
1376 /// contains an unexpanded parameter pack. In this case, we will have
1377 /// built a PackExpansionType wrapping the type.
1378 bool isPackExpansion() const {
1379 return ParameterPack && getType()->getAs<PackExpansionType>();
1380 }
1381
1382 /// Whether this parameter is a non-type template parameter pack
1383 /// that has a known list of different types at different positions.
1384 ///
1385 /// A parameter pack is an expanded parameter pack when the original
1386 /// parameter pack's type was itself a pack expansion, and that expansion
1387 /// has already been expanded. For example, given:
1388 ///
1389 /// \code
1390 /// template<typename ...Types>
1391 /// struct X {
1392 /// template<Types ...Values>
1393 /// struct Y { /* ... */ };
1394 /// };
1395 /// \endcode
1396 ///
1397 /// The parameter pack \c Values has a \c PackExpansionType as its type,
1398 /// which expands \c Types. When \c Types is supplied with template arguments
1399 /// by instantiating \c X, the instantiation of \c Values becomes an
1400 /// expanded parameter pack. For example, instantiating
1401 /// \c X<int, unsigned int> results in \c Values being an expanded parameter
1402 /// pack with expansion types \c int and \c unsigned int.
1403 ///
1404 /// The \c getExpansionType() and \c getExpansionTypeSourceInfo() functions
1405 /// return the expansion types.
1406 bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1407
1408 /// Retrieves the number of expansion types in an expanded parameter
1409 /// pack.
1410 unsigned getNumExpansionTypes() const {
1411 assert(ExpandedParameterPack && "Not an expansion parameter pack");
1412 return NumExpandedTypes;
1413 }
1414
1415 /// Retrieve a particular expansion type within an expanded parameter
1416 /// pack.
1417 QualType getExpansionType(unsigned I) const {
1418 assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1419 auto TypesAndInfos =
1420 getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1421 return TypesAndInfos[I].first;
1422 }
1423
1424 /// Retrieve a particular expansion type source info within an
1425 /// expanded parameter pack.
1426 TypeSourceInfo *getExpansionTypeSourceInfo(unsigned I) const {
1427 assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1428 auto TypesAndInfos =
1429 getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1430 return TypesAndInfos[I].second;
1431 }
1432
1433 // Implement isa/cast/dyncast/etc.
1434 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1435 static bool classofKind(Kind K) { return K == NonTypeTemplateParm; }
1436};
1437
1438/// TemplateTemplateParmDecl - Declares a template template parameter,
1439/// e.g., "T" in
1440/// @code
1441/// template <template <typename> class T> class container { };
1442/// @endcode
1443/// A template template parameter is a TemplateDecl because it defines the
1444/// name of a template and the template parameters allowable for substitution.
1445class TemplateTemplateParmDecl final
1446 : public TemplateDecl,
1447 protected TemplateParmPosition,
1448 private llvm::TrailingObjects<TemplateTemplateParmDecl,
1449 TemplateParameterList *> {
1450 /// The default template argument, if any.
1451 using DefArgStorage =
1452 DefaultArgStorage<TemplateTemplateParmDecl, TemplateArgumentLoc *>;
1453 DefArgStorage DefaultArgument;
1454
1455 /// Whether this parameter is a parameter pack.
1456 bool ParameterPack;
1457
1458 /// Whether this template template parameter is an "expanded"
1459 /// parameter pack, meaning that it is a pack expansion and we
1460 /// already know the set of template parameters that expansion expands to.
1461 bool ExpandedParameterPack = false;
1462
1463 /// The number of parameters in an expanded parameter pack.
1464 unsigned NumExpandedParams = 0;
1465
1466 TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L,
1467 unsigned D, unsigned P, bool ParameterPack,
1468 IdentifierInfo *Id, TemplateParameterList *Params)
1469 : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
1470 TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
1471
1472 TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L,
1473 unsigned D, unsigned P,
1474 IdentifierInfo *Id, TemplateParameterList *Params,
1475 ArrayRef<TemplateParameterList *> Expansions);
1476
1477 void anchor() override;
1478
1479public:
1480 friend class ASTDeclReader;
1481 friend class ASTDeclWriter;
1482 friend TrailingObjects;
1483
1484 static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
1485 SourceLocation L, unsigned D,
1486 unsigned P, bool ParameterPack,
1487 IdentifierInfo *Id,
1488 TemplateParameterList *Params);
1489 static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
1490 SourceLocation L, unsigned D,
1491 unsigned P,
1492 IdentifierInfo *Id,
1493 TemplateParameterList *Params,
1494 ArrayRef<TemplateParameterList *> Expansions);
1495
1496 static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
1497 unsigned ID);
1498 static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
1499 unsigned ID,
1500 unsigned NumExpansions);
1501
1502 using TemplateParmPosition::getDepth;
1503 using TemplateParmPosition::setDepth;
1504 using TemplateParmPosition::getPosition;
1505 using TemplateParmPosition::setPosition;
1506 using TemplateParmPosition::getIndex;
1507
1508 /// Whether this template template parameter is a template
1509 /// parameter pack.
1510 ///
1511 /// \code
1512 /// template<template <class T> ...MetaFunctions> struct Apply;
1513 /// \endcode
1514 bool isParameterPack() const { return ParameterPack; }
1515
1516 /// Whether this parameter pack is a pack expansion.
1517 ///
1518 /// A template template parameter pack is a pack expansion if its template
1519 /// parameter list contains an unexpanded parameter pack.
1520 bool isPackExpansion() const {
1521 return ParameterPack &&
1522 getTemplateParameters()->containsUnexpandedParameterPack();
1523 }
1524
1525 /// Whether this parameter is a template template parameter pack that
1526 /// has a known list of different template parameter lists at different
1527 /// positions.
1528 ///
1529 /// A parameter pack is an expanded parameter pack when the original parameter
1530 /// pack's template parameter list was itself a pack expansion, and that
1531 /// expansion has already been expanded. For exampe, given:
1532 ///
1533 /// \code
1534 /// template<typename...Types> struct Outer {
1535 /// template<template<Types> class...Templates> struct Inner;
1536 /// };
1537 /// \endcode
1538 ///
1539 /// The parameter pack \c Templates is a pack expansion, which expands the
1540 /// pack \c Types. When \c Types is supplied with template arguments by
1541 /// instantiating \c Outer, the instantiation of \c Templates is an expanded
1542 /// parameter pack.
1543 bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1544
1545 /// Retrieves the number of expansion template parameters in
1546 /// an expanded parameter pack.
1547 unsigned getNumExpansionTemplateParameters() const {
1548 assert(ExpandedParameterPack && "Not an expansion parameter pack");
1549 return NumExpandedParams;
1550 }
1551
1552 /// Retrieve a particular expansion type within an expanded parameter
1553 /// pack.
1554 TemplateParameterList *getExpansionTemplateParameters(unsigned I) const {
1555 assert(I < NumExpandedParams && "Out-of-range expansion type index");
1556 return getTrailingObjects<TemplateParameterList *>()[I];
1557 }
1558
1559 const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1560
1561 /// Determine whether this template parameter has a default
1562 /// argument.
1563 bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1564
1565 /// Retrieve the default argument, if any.
1566 const TemplateArgumentLoc &getDefaultArgument() const {
1567 static const TemplateArgumentLoc None;
1568 return DefaultArgument.isSet() ? *DefaultArgument.get() : None;
1569 }
1570
1571 /// Retrieve the location of the default argument, if any.
1572 SourceLocation getDefaultArgumentLoc() const;
1573
1574 /// Determines whether the default argument was inherited
1575 /// from a previous declaration of this template.
1576 bool defaultArgumentWasInherited() const {
1577 return DefaultArgument.isInherited();
1578 }
1579
1580 /// Set the default argument for this template parameter, and
1581 /// whether that default argument was inherited from another
1582 /// declaration.
1583 void setDefaultArgument(const ASTContext &C,
1584 const TemplateArgumentLoc &DefArg);
1585 void setInheritedDefaultArgument(const ASTContext &C,
1586 TemplateTemplateParmDecl *Prev) {
1587 DefaultArgument.setInherited(C, Prev);
1588 }
1589
1590 /// Removes the default argument of this template parameter.
1591 void removeDefaultArgument() { DefaultArgument.clear(); }
1592
1593 SourceRange getSourceRange() const override LLVM_READONLY {
1594 SourceLocation End = getLocation();
1595 if (hasDefaultArgument() && !defaultArgumentWasInherited())
1596 End = getDefaultArgument().getSourceRange().getEnd();
1597 return SourceRange(getTemplateParameters()->getTemplateLoc(), End);
1598 }
1599
1600 // Implement isa/cast/dyncast/etc.
1601 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1602 static bool classofKind(Kind K) { return K == TemplateTemplateParm; }
1603};
1604
1605/// Represents the builtin template declaration which is used to
1606/// implement __make_integer_seq and other builtin templates. It serves
1607/// no real purpose beyond existing as a place to hold template parameters.
1608class BuiltinTemplateDecl : public TemplateDecl {
1609 BuiltinTemplateKind BTK;
1610
1611 BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
1612 DeclarationName Name, BuiltinTemplateKind BTK);
1613
1614 void anchor() override;
1615
1616public:
1617 // Implement isa/cast/dyncast support
1618 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1619 static bool classofKind(Kind K) { return K == BuiltinTemplate; }
1620
1621 static BuiltinTemplateDecl *Create(const ASTContext &C, DeclContext *DC,
1622 DeclarationName Name,
1623 BuiltinTemplateKind BTK) {
1624 return new (C, DC) BuiltinTemplateDecl(C, DC, Name, BTK);
1625 }
1626
1627 SourceRange getSourceRange() const override LLVM_READONLY {
1628 return {};
1629 }
1630
1631 BuiltinTemplateKind getBuiltinTemplateKind() const { return BTK; }
1632};
1633
1634/// Represents a class template specialization, which refers to
1635/// a class template with a given set of template arguments.
1636///
1637/// Class template specializations represent both explicit
1638/// specialization of class templates, as in the example below, and
1639/// implicit instantiations of class templates.
1640///
1641/// \code
1642/// template<typename T> class array;
1643///
1644/// template<>
1645/// class array<bool> { }; // class template specialization array<bool>
1646/// \endcode
1647class ClassTemplateSpecializationDecl
1648 : public CXXRecordDecl, public llvm::FoldingSetNode {
1649 /// Structure that stores information about a class template
1650 /// specialization that was instantiated from a class template partial
1651 /// specialization.
1652 struct SpecializedPartialSpecialization {
1653 /// The class template partial specialization from which this
1654 /// class template specialization was instantiated.
1655 ClassTemplatePartialSpecializationDecl *PartialSpecialization;
1656
1657 /// The template argument list deduced for the class template
1658 /// partial specialization itself.
1659 const TemplateArgumentList *TemplateArgs;
1660 };
1661
1662 /// The template that this specialization specializes
1663 llvm::PointerUnion<ClassTemplateDecl *, SpecializedPartialSpecialization *>
1664 SpecializedTemplate;
1665
1666 /// Further info for explicit template specialization/instantiation.
1667 struct ExplicitSpecializationInfo {
1668 /// The type-as-written.
1669 TypeSourceInfo *TypeAsWritten = nullptr;
1670
1671 /// The location of the extern keyword.
1672 SourceLocation ExternLoc;
1673
1674 /// The location of the template keyword.
1675 SourceLocation TemplateKeywordLoc;
1676
1677 ExplicitSpecializationInfo() = default;
1678 };
1679
1680 /// Further info for explicit template specialization/instantiation.
1681 /// Does not apply to implicit specializations.
1682 ExplicitSpecializationInfo *ExplicitInfo = nullptr;
1683
1684 /// The template arguments used to describe this specialization.
1685 const TemplateArgumentList *TemplateArgs;
1686
1687 /// The point where this template was instantiated (if any)
1688 SourceLocation PointOfInstantiation;
1689
1690 /// The kind of specialization this declaration refers to.
1691 /// Really a value of type TemplateSpecializationKind.
1692 unsigned SpecializationKind : 3;
1693
1694protected:
1695 ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
1696 DeclContext *DC, SourceLocation StartLoc,
1697 SourceLocation IdLoc,
1698 ClassTemplateDecl *SpecializedTemplate,
1699 ArrayRef<TemplateArgument> Args,
1700 ClassTemplateSpecializationDecl *PrevDecl);
1701
1702 explicit ClassTemplateSpecializationDecl(ASTContext &C, Kind DK);
1703
1704public:
1705 friend class ASTDeclReader;
1706 friend class ASTDeclWriter;
1707
1708 static ClassTemplateSpecializationDecl *
1709 Create(ASTContext &Context, TagKind TK, DeclContext *DC,
1710 SourceLocation StartLoc, SourceLocation IdLoc,
1711 ClassTemplateDecl *SpecializedTemplate,
1712 ArrayRef<TemplateArgument> Args,
1713 ClassTemplateSpecializationDecl *PrevDecl);
1714 static ClassTemplateSpecializationDecl *
1715 CreateDeserialized(ASTContext &C, unsigned ID);
1716
1717 void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
1718 bool Qualified) const override;
1719
1720 // FIXME: This is broken. CXXRecordDecl::getMostRecentDecl() returns a
1721 // different "most recent" declaration from this function for the same
1722 // declaration, because we don't override getMostRecentDeclImpl(). But
1723 // it's not clear that we should override that, because the most recent
1724 // declaration as a CXXRecordDecl sometimes is the injected-class-name.
1725 ClassTemplateSpecializationDecl *getMostRecentDecl() {
1726 return cast<ClassTemplateSpecializationDecl>(
1727 getMostRecentNonInjectedDecl());
1728 }
1729
1730 /// Retrieve the template that this specialization specializes.
1731 ClassTemplateDecl *getSpecializedTemplate() const;
1732
1733 /// Retrieve the template arguments of the class template
1734 /// specialization.
1735 const TemplateArgumentList &getTemplateArgs() const {
1736 return *TemplateArgs;
1737 }
1738
1739 /// Determine the kind of specialization that this
1740 /// declaration represents.
1741 TemplateSpecializationKind getSpecializationKind() const {
1742 return static_cast<TemplateSpecializationKind>(SpecializationKind);
1743 }
1744
1745 bool isExplicitSpecialization() const {
1746 return getSpecializationKind() == TSK_ExplicitSpecialization;
1747 }
1748
1749 /// True if this declaration is an explicit specialization,
1750 /// explicit instantiation declaration, or explicit instantiation
1751 /// definition.
1752 bool isExplicitInstantiationOrSpecialization() const {
1753 return isTemplateExplicitInstantiationOrSpecialization(
1754 getTemplateSpecializationKind());
1755 }
1756
1757 void setSpecializationKind(TemplateSpecializationKind TSK) {
1758 SpecializationKind = TSK;
1759 }
1760
1761 /// Get the point of instantiation (if any), or null if none.
1762 SourceLocation getPointOfInstantiation() const {
1763 return PointOfInstantiation;
1764 }
1765
1766 void setPointOfInstantiation(SourceLocation Loc) {
1767 assert(Loc.isValid() && "point of instantiation must be valid!");
1768 PointOfInstantiation = Loc;
1769 }
1770
1771 /// If this class template specialization is an instantiation of
1772 /// a template (rather than an explicit specialization), return the
1773 /// class template or class template partial specialization from which it
1774 /// was instantiated.
1775 llvm::PointerUnion<ClassTemplateDecl *,
1776 ClassTemplatePartialSpecializationDecl *>
1777 getInstantiatedFrom() const {
1778 if (!isTemplateInstantiation(getSpecializationKind()))
1779 return llvm::PointerUnion<ClassTemplateDecl *,
1780 ClassTemplatePartialSpecializationDecl *>();
1781
1782 return getSpecializedTemplateOrPartial();
1783 }
1784
1785 /// Retrieve the class template or class template partial
1786 /// specialization which was specialized by this.
1787 llvm::PointerUnion<ClassTemplateDecl *,
1788 ClassTemplatePartialSpecializationDecl *>
1789 getSpecializedTemplateOrPartial() const {
1790 if (const auto *PartialSpec =
1791 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1792 return PartialSpec->PartialSpecialization;
1793
1794 return SpecializedTemplate.get<ClassTemplateDecl*>();
1795 }
1796
1797 /// Retrieve the set of template arguments that should be used
1798 /// to instantiate members of the class template or class template partial
1799 /// specialization from which this class template specialization was
1800 /// instantiated.
1801 ///
1802 /// \returns For a class template specialization instantiated from the primary
1803 /// template, this function will return the same template arguments as
1804 /// getTemplateArgs(). For a class template specialization instantiated from
1805 /// a class template partial specialization, this function will return the
1806 /// deduced template arguments for the class template partial specialization
1807 /// itself.
1808 const TemplateArgumentList &getTemplateInstantiationArgs() const {
1809 if (const auto *PartialSpec =
1810 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1811 return *PartialSpec->TemplateArgs;
1812
1813 return getTemplateArgs();
1814 }
1815
1816 /// Note that this class template specialization is actually an
1817 /// instantiation of the given class template partial specialization whose
1818 /// template arguments have been deduced.
1819 void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec,
1820 const TemplateArgumentList *TemplateArgs) {
1821 assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
1822 "Already set to a class template partial specialization!");
1823 auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
1824 PS->PartialSpecialization = PartialSpec;
1825 PS->TemplateArgs = TemplateArgs;
1826 SpecializedTemplate = PS;
1827 }
1828
1829 /// Note that this class template specialization is an instantiation
1830 /// of the given class template.
1831 void setInstantiationOf(ClassTemplateDecl *TemplDecl) {
1832 assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
1833 "Previously set to a class template partial specialization!");
1834 SpecializedTemplate = TemplDecl;
1835 }
1836
1837 /// Sets the type of this specialization as it was written by
1838 /// the user. This will be a class template specialization type.
1839 void setTypeAsWritten(TypeSourceInfo *T) {
1840 if (!ExplicitInfo)
1841 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1842 ExplicitInfo->TypeAsWritten = T;
1843 }
1844
1845 /// Gets the type of this specialization as it was written by
1846 /// the user, if it was so written.
1847 TypeSourceInfo *getTypeAsWritten() const {
1848 return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
1849 }
1850
1851 /// Gets the location of the extern keyword, if present.
1852 SourceLocation getExternLoc() const {
1853 return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
1854 }
1855
1856 /// Sets the location of the extern keyword.
1857 void setExternLoc(SourceLocation Loc) {
1858 if (!ExplicitInfo)
1859 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1860 ExplicitInfo->ExternLoc = Loc;
1861 }
1862
1863 /// Sets the location of the template keyword.
1864 void setTemplateKeywordLoc(SourceLocation Loc) {
1865 if (!ExplicitInfo)
1866 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1867 ExplicitInfo->TemplateKeywordLoc = Loc;
1868 }
1869
1870 /// Gets the location of the template keyword, if present.
1871 SourceLocation getTemplateKeywordLoc() const {
1872 return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
1873 }
1874
1875 SourceRange getSourceRange() const override LLVM_READONLY;
1876
1877 void Profile(llvm::FoldingSetNodeID &ID) const {
1878 Profile(ID, TemplateArgs->asArray(), getASTContext());
1879 }
1880
1881 static void
1882 Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
1883 ASTContext &Context) {
1884 ID.AddInteger(TemplateArgs.size());
1885 for (const TemplateArgument &TemplateArg : TemplateArgs)
1886 TemplateArg.Profile(ID, Context);
1887 }
1888
1889 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1890
1891 static bool classofKind(Kind K) {
1892 return K >= firstClassTemplateSpecialization &&
1893 K <= lastClassTemplateSpecialization;
1894 }
1895};
1896
1897class ClassTemplatePartialSpecializationDecl
1898 : public ClassTemplateSpecializationDecl {
1899 /// The list of template parameters
1900 TemplateParameterList* TemplateParams = nullptr;
1901
1902 /// The source info for the template arguments as written.
1903 /// FIXME: redundant with TypeAsWritten?
1904 const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
1905
1906 /// The class template partial specialization from which this
1907 /// class template partial specialization was instantiated.
1908 ///
1909 /// The boolean value will be true to indicate that this class template
1910 /// partial specialization was specialized at this level.
1911 llvm::PointerIntPair<ClassTemplatePartialSpecializationDecl *, 1, bool>
1912 InstantiatedFromMember;
1913
1914 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
1915 DeclContext *DC,
1916 SourceLocation StartLoc,
1917 SourceLocation IdLoc,
1918 TemplateParameterList *Params,
1919 ClassTemplateDecl *SpecializedTemplate,
1920 ArrayRef<TemplateArgument> Args,
1921 const ASTTemplateArgumentListInfo *ArgsAsWritten,
1922 ClassTemplatePartialSpecializationDecl *PrevDecl);
1923
1924 ClassTemplatePartialSpecializationDecl(ASTContext &C)
1925 : ClassTemplateSpecializationDecl(C, ClassTemplatePartialSpecialization),
1926 InstantiatedFromMember(nullptr, false) {}
1927
1928 void anchor() override;
1929
1930public:
1931 friend class ASTDeclReader;
1932 friend class ASTDeclWriter;
1933
1934 static ClassTemplatePartialSpecializationDecl *
1935 Create(ASTContext &Context, TagKind TK, DeclContext *DC,
1936 SourceLocation StartLoc, SourceLocation IdLoc,
1937 TemplateParameterList *Params,
1938 ClassTemplateDecl *SpecializedTemplate,
1939 ArrayRef<TemplateArgument> Args,
1940 const TemplateArgumentListInfo &ArgInfos,
1941 QualType CanonInjectedType,
1942 ClassTemplatePartialSpecializationDecl *PrevDecl);
1943
1944 static ClassTemplatePartialSpecializationDecl *
1945 CreateDeserialized(ASTContext &C, unsigned ID);
1946
1947 ClassTemplatePartialSpecializationDecl *getMostRecentDecl() {
1948 return cast<ClassTemplatePartialSpecializationDecl>(
1949 static_cast<ClassTemplateSpecializationDecl *>(
1950 this)->getMostRecentDecl());
1951 }
1952
1953 /// Get the list of template parameters
1954 TemplateParameterList *getTemplateParameters() const {
1955 return TemplateParams;
1956 }
1957
1958 /// Get the template arguments as written.
1959 const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
1960 return ArgsAsWritten;
1961 }
1962
1963 /// Retrieve the member class template partial specialization from
1964 /// which this particular class template partial specialization was
1965 /// instantiated.
1966 ///
1967 /// \code
1968 /// template<typename T>
1969 /// struct Outer {
1970 /// template<typename U> struct Inner;
1971 /// template<typename U> struct Inner<U*> { }; // #1
1972 /// };
1973 ///
1974 /// Outer<float>::Inner<int*> ii;
1975 /// \endcode
1976 ///
1977 /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
1978 /// end up instantiating the partial specialization
1979 /// \c Outer<float>::Inner<U*>, which itself was instantiated from the class
1980 /// template partial specialization \c Outer<T>::Inner<U*>. Given
1981 /// \c Outer<float>::Inner<U*>, this function would return
1982 /// \c Outer<T>::Inner<U*>.
1983 ClassTemplatePartialSpecializationDecl *getInstantiatedFromMember() const {
1984 const auto *First =
1985 cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
1986 return First->InstantiatedFromMember.getPointer();
1987 }
1988 ClassTemplatePartialSpecializationDecl *
1989 getInstantiatedFromMemberTemplate() const {
1990 return getInstantiatedFromMember();
1991 }
1992
1993 void setInstantiatedFromMember(
1994 ClassTemplatePartialSpecializationDecl *PartialSpec) {
1995 auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
1996 First->InstantiatedFromMember.setPointer(PartialSpec);
1997 }
1998
1999 /// Determines whether this class template partial specialization
2000 /// template was a specialization of a member partial specialization.
2001 ///
2002 /// In the following example, the member template partial specialization
2003 /// \c X<int>::Inner<T*> is a member specialization.
2004 ///
2005 /// \code
2006 /// template<typename T>
2007 /// struct X {
2008 /// template<typename U> struct Inner;
2009 /// template<typename U> struct Inner<U*>;
2010 /// };
2011 ///
2012 /// template<> template<typename T>
2013 /// struct X<int>::Inner<T*> { /* ... */ };
2014 /// \endcode
2015 bool isMemberSpecialization() {
2016 const auto *First =
2017 cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2018 return First->InstantiatedFromMember.getInt();
2019 }
2020
2021 /// Note that this member template is a specialization.
2022 void setMemberSpecialization() {
2023 auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2024 assert(First->InstantiatedFromMember.getPointer() &&
2025 "Only member templates can be member template specializations");
2026 return First->InstantiatedFromMember.setInt(true);
2027 }
2028
2029 /// Retrieves the injected specialization type for this partial
2030 /// specialization. This is not the same as the type-decl-type for
2031 /// this partial specialization, which is an InjectedClassNameType.
2032 QualType getInjectedSpecializationType() const {
2033 assert(getTypeForDecl() && "partial specialization has no type set!");
2034 return cast<InjectedClassNameType>(getTypeForDecl())
2035 ->getInjectedSpecializationType();
2036 }
2037
2038 // FIXME: Add Profile support!
2039
2040 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2041
2042 static bool classofKind(Kind K) {
2043 return K == ClassTemplatePartialSpecialization;
2044 }
2045};
2046
2047/// Declaration of a class template.
2048class ClassTemplateDecl : public RedeclarableTemplateDecl {
2049protected:
2050 /// Data that is common to all of the declarations of a given
2051 /// class template.
2052 struct Common : CommonBase {
2053 /// The class template specializations for this class
2054 /// template, including explicit specializations and instantiations.
2055 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> Specializations;
2056
2057 /// The class template partial specializations for this class
2058 /// template.
2059 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
2060 PartialSpecializations;
2061
2062 /// The injected-class-name type for this class template.
2063 QualType InjectedClassNameType;
2064
2065 Common() = default;
2066 };
2067
2068 /// Retrieve the set of specializations of this class template.
2069 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
2070 getSpecializations() const;
2071
2072 /// Retrieve the set of partial specializations of this class
2073 /// template.
2074 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
2075 getPartialSpecializations();
2076
2077 ClassTemplateDecl(ConstrainedTemplateDeclInfo *CTDI, ASTContext &C,
2078 DeclContext *DC, SourceLocation L, DeclarationName Name,
2079 TemplateParameterList *Params, NamedDecl *Decl)
2080 : RedeclarableTemplateDecl(CTDI, ClassTemplate, C, DC, L, Name, Params,
2081 Decl) {}
2082
2083 ClassTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
2084 DeclarationName Name, TemplateParameterList *Params,
2085 NamedDecl *Decl)
2086 : ClassTemplateDecl(nullptr, C, DC, L, Name, Params, Decl) {}
2087
2088 CommonBase *newCommon(ASTContext &C) const override;
2089
2090 Common *getCommonPtr() const {
2091 return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2092 }
2093
2094public:
2095 friend class ASTDeclReader;
2096 friend class ASTDeclWriter;
2097
2098 /// Load any lazily-loaded specializations from the external source.
2099 void LoadLazySpecializations() const;
2100
2101 /// Get the underlying class declarations of the template.
2102 CXXRecordDecl *getTemplatedDecl() const {
2103 return static_cast<CXXRecordDecl *>(TemplatedDecl);
2104 }
2105
2106 /// Returns whether this template declaration defines the primary
2107 /// class pattern.
2108 bool isThisDeclarationADefinition() const {
2109 return getTemplatedDecl()->isThisDeclarationADefinition();
2110 }
2111
2112 // FIXME: remove default argument for AssociatedConstraints
2113 /// Create a class template node.
2114 static ClassTemplateDecl *Create(ASTContext &C, DeclContext *DC,
2115 SourceLocation L,
2116 DeclarationName Name,
2117 TemplateParameterList *Params,
2118 NamedDecl *Decl,
2119 Expr *AssociatedConstraints = nullptr);
2120
2121 /// Create an empty class template node.
2122 static ClassTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2123
2124 /// Return the specialization with the provided arguments if it exists,
2125 /// otherwise return the insertion point.
2126 ClassTemplateSpecializationDecl *
2127 findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2128
2129 /// Insert the specified specialization knowing that it is not already
2130 /// in. InsertPos must be obtained from findSpecialization.
2131 void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos);
2132
2133 ClassTemplateDecl *getCanonicalDecl() override {
2134 return cast<ClassTemplateDecl>(
2135 RedeclarableTemplateDecl::getCanonicalDecl());
2136 }
2137 const ClassTemplateDecl *getCanonicalDecl() const {
2138 return cast<ClassTemplateDecl>(
2139 RedeclarableTemplateDecl::getCanonicalDecl());
2140 }
2141
2142 /// Retrieve the previous declaration of this class template, or
2143 /// nullptr if no such declaration exists.
2144 ClassTemplateDecl *getPreviousDecl() {
2145 return cast_or_null<ClassTemplateDecl>(
2146 static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2147 }
2148 const ClassTemplateDecl *getPreviousDecl() const {
2149 return cast_or_null<ClassTemplateDecl>(
2150 static_cast<const RedeclarableTemplateDecl *>(
2151 this)->getPreviousDecl());
2152 }
2153
2154 ClassTemplateDecl *getMostRecentDecl() {
2155 return cast<ClassTemplateDecl>(
2156 static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
2157 }
2158 const ClassTemplateDecl *getMostRecentDecl() const {
2159 return const_cast<ClassTemplateDecl*>(this)->getMostRecentDecl();
2160 }
2161
2162 ClassTemplateDecl *getInstantiatedFromMemberTemplate() const {
2163 return cast_or_null<ClassTemplateDecl>(
2164 RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
2165 }
2166
2167 /// Return the partial specialization with the provided arguments if it
2168 /// exists, otherwise return the insertion point.
2169 ClassTemplatePartialSpecializationDecl *
2170 findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2171
2172 /// Insert the specified partial specialization knowing that it is not
2173 /// already in. InsertPos must be obtained from findPartialSpecialization.
2174 void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D,
2175 void *InsertPos);
2176
2177 /// Retrieve the partial specializations as an ordered list.
2178 void getPartialSpecializations(
2179 SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS);
2180
2181 /// Find a class template partial specialization with the given
2182 /// type T.
2183 ///
2184 /// \param T a dependent type that names a specialization of this class
2185 /// template.
2186 ///
2187 /// \returns the class template partial specialization that exactly matches
2188 /// the type \p T, or nullptr if no such partial specialization exists.
2189 ClassTemplatePartialSpecializationDecl *findPartialSpecialization(QualType T);
2190
2191 /// Find a class template partial specialization which was instantiated
2192 /// from the given member partial specialization.
2193 ///
2194 /// \param D a member class template partial specialization.
2195 ///
2196 /// \returns the class template partial specialization which was instantiated
2197 /// from the given member partial specialization, or nullptr if no such
2198 /// partial specialization exists.
2199 ClassTemplatePartialSpecializationDecl *
2200 findPartialSpecInstantiatedFromMember(
2201 ClassTemplatePartialSpecializationDecl *D);
2202
2203 /// Retrieve the template specialization type of the
2204 /// injected-class-name for this class template.
2205 ///
2206 /// The injected-class-name for a class template \c X is \c
2207 /// X<template-args>, where \c template-args is formed from the
2208 /// template arguments that correspond to the template parameters of
2209 /// \c X. For example:
2210 ///
2211 /// \code
2212 /// template<typename T, int N>
2213 /// struct array {
2214 /// typedef array this_type; // "array" is equivalent to "array<T, N>"
2215 /// };
2216 /// \endcode
2217 QualType getInjectedClassNameSpecialization();
2218
2219 using spec_iterator = SpecIterator<ClassTemplateSpecializationDecl>;
2220 using spec_range = llvm::iterator_range<spec_iterator>;
2221
2222 spec_range specializations() const {
2223 return spec_range(spec_begin(), spec_end());
2224 }
2225
2226 spec_iterator spec_begin() const {
2227 return makeSpecIterator(getSpecializations(), false);
2228 }
2229
2230 spec_iterator spec_end() const {
2231 return makeSpecIterator(getSpecializations(), true);
2232 }
2233
2234 // Implement isa/cast/dyncast support
2235 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2236 static bool classofKind(Kind K) { return K == ClassTemplate; }
2237};
2238
2239/// Declaration of a friend template.
2240///
2241/// For example:
2242/// \code
2243/// template \<typename T> class A {
2244/// friend class MyVector<T>; // not a friend template
2245/// template \<typename U> friend class B; // not a friend template
2246/// template \<typename U> friend class Foo<T>::Nested; // friend template
2247/// };
2248/// \endcode
2249///
2250/// \note This class is not currently in use. All of the above
2251/// will yield a FriendDecl, not a FriendTemplateDecl.
2252class FriendTemplateDecl : public Decl {
2253 virtual void anchor();
2254
2255public:
2256 using FriendUnion = llvm::PointerUnion<NamedDecl *,TypeSourceInfo *>;
2257
2258private:
2259 // The number of template parameters; always non-zero.
2260 unsigned NumParams = 0;
2261
2262 // The parameter list.
2263 TemplateParameterList **Params = nullptr;
2264
2265 // The declaration that's a friend of this class.
2266 FriendUnion Friend;
2267
2268 // Location of the 'friend' specifier.
2269 SourceLocation FriendLoc;
2270
2271 FriendTemplateDecl(DeclContext *DC, SourceLocation Loc,
2272 MutableArrayRef<TemplateParameterList *> Params,
2273 FriendUnion Friend, SourceLocation FriendLoc)
2274 : Decl(Decl::FriendTemplate, DC, Loc), NumParams(Params.size()),
2275 Params(Params.data()), Friend(Friend), FriendLoc(FriendLoc) {}
2276
2277 FriendTemplateDecl(EmptyShell Empty) : Decl(Decl::FriendTemplate, Empty) {}
2278
2279public:
2280 friend class ASTDeclReader;
2281
2282 static FriendTemplateDecl *
2283 Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc,
2284 MutableArrayRef<TemplateParameterList *> Params, FriendUnion Friend,
2285 SourceLocation FriendLoc);
2286
2287 static FriendTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2288
2289 /// If this friend declaration names a templated type (or
2290 /// a dependent member type of a templated type), return that
2291 /// type; otherwise return null.
2292 TypeSourceInfo *getFriendType() const {
2293 return Friend.dyn_cast<TypeSourceInfo*>();
2294 }
2295
2296 /// If this friend declaration names a templated function (or
2297 /// a member function of a templated type), return that type;
2298 /// otherwise return null.
2299 NamedDecl *getFriendDecl() const {
2300 return Friend.dyn_cast<NamedDecl*>();
2301 }
2302
2303 /// Retrieves the location of the 'friend' keyword.
2304 SourceLocation getFriendLoc() const {
2305 return FriendLoc;
2306 }
2307
2308 TemplateParameterList *getTemplateParameterList(unsigned i) const {
2309 assert(i <= NumParams);
2310 return Params[i];
2311 }
2312
2313 unsigned getNumTemplateParameters() const {
2314 return NumParams;
2315 }
2316
2317 // Implement isa/cast/dyncast/etc.
2318 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2319 static bool classofKind(Kind K) { return K == Decl::FriendTemplate; }
2320};
2321
2322/// Declaration of an alias template.
2323///
2324/// For example:
2325/// \code
2326/// template \<typename T> using V = std::map<T*, int, MyCompare<T>>;
2327/// \endcode
2328class TypeAliasTemplateDecl : public RedeclarableTemplateDecl {
2329protected:
2330 using Common = CommonBase;
2331
2332 TypeAliasTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
2333 DeclarationName Name, TemplateParameterList *Params,
2334 NamedDecl *Decl)
2335 : RedeclarableTemplateDecl(TypeAliasTemplate, C, DC, L, Name, Params,
2336 Decl) {}
2337
2338 CommonBase *newCommon(ASTContext &C) const override;
2339
2340 Common *getCommonPtr() {
2341 return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2342 }
2343
2344public:
2345 friend class ASTDeclReader;
2346 friend class ASTDeclWriter;
2347
2348 /// Get the underlying function declaration of the template.
2349 TypeAliasDecl *getTemplatedDecl() const {
2350 return static_cast<TypeAliasDecl *>(TemplatedDecl);
2351 }
2352
2353
2354 TypeAliasTemplateDecl *getCanonicalDecl() override {
2355 return cast<TypeAliasTemplateDecl>(
2356 RedeclarableTemplateDecl::getCanonicalDecl());
2357 }
2358 const TypeAliasTemplateDecl *getCanonicalDecl() const {
2359 return cast<TypeAliasTemplateDecl>(
2360 RedeclarableTemplateDecl::getCanonicalDecl());
2361 }
2362
2363 /// Retrieve the previous declaration of this function template, or
2364 /// nullptr if no such declaration exists.
2365 TypeAliasTemplateDecl *getPreviousDecl() {
2366 return cast_or_null<TypeAliasTemplateDecl>(
2367 static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2368 }
2369 const TypeAliasTemplateDecl *getPreviousDecl() const {
2370 return cast_or_null<TypeAliasTemplateDecl>(
2371 static_cast<const RedeclarableTemplateDecl *>(
2372 this)->getPreviousDecl());
2373 }
2374
2375 TypeAliasTemplateDecl *getInstantiatedFromMemberTemplate() const {
2376 return cast_or_null<TypeAliasTemplateDecl>(
2377 RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
2378 }
2379
2380 /// Create a function template node.
2381 static TypeAliasTemplateDecl *Create(ASTContext &C, DeclContext *DC,
2382 SourceLocation L,
2383 DeclarationName Name,
2384 TemplateParameterList *Params,
2385 NamedDecl *Decl);
2386
2387 /// Create an empty alias template node.
2388 static TypeAliasTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2389
2390 // Implement isa/cast/dyncast support
2391 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2392 static bool classofKind(Kind K) { return K == TypeAliasTemplate; }
2393};
2394
2395/// Declaration of a function specialization at template class scope.
2396///
2397/// This is a non-standard extension needed to support MSVC.
2398///
2399/// For example:
2400/// \code
2401/// template <class T>
2402/// class A {
2403/// template <class U> void foo(U a) { }
2404/// template<> void foo(int a) { }
2405/// }
2406/// \endcode
2407///
2408/// "template<> foo(int a)" will be saved in Specialization as a normal
2409/// CXXMethodDecl. Then during an instantiation of class A, it will be
2410/// transformed into an actual function specialization.
2411class ClassScopeFunctionSpecializationDecl : public Decl {
2412 CXXMethodDecl *Specialization;
2413 bool HasExplicitTemplateArgs;
2414 TemplateArgumentListInfo TemplateArgs;
2415
2416 ClassScopeFunctionSpecializationDecl(DeclContext *DC, SourceLocation Loc,
2417 CXXMethodDecl *FD, bool Args,
2418 TemplateArgumentListInfo TemplArgs)
2419 : Decl(Decl::ClassScopeFunctionSpecialization, DC, Loc),
2420 Specialization(FD), HasExplicitTemplateArgs(Args),
2421 TemplateArgs(std::move(TemplArgs)) {}
2422
2423 ClassScopeFunctionSpecializationDecl(EmptyShell Empty)
2424 : Decl(Decl::ClassScopeFunctionSpecialization, Empty) {}
2425
2426 virtual void anchor();
2427
2428public:
2429 friend class ASTDeclReader;
2430 friend class ASTDeclWriter;
2431
2432 CXXMethodDecl *getSpecialization() const { return Specialization; }
2433 bool hasExplicitTemplateArgs() const { return HasExplicitTemplateArgs; }
2434 const TemplateArgumentListInfo& templateArgs() const { return TemplateArgs; }
2435
2436 static ClassScopeFunctionSpecializationDecl *Create(ASTContext &C,
2437 DeclContext *DC,
2438 SourceLocation Loc,
2439 CXXMethodDecl *FD,
2440 bool HasExplicitTemplateArgs,
2441 TemplateArgumentListInfo TemplateArgs) {
2442 return new (C, DC) ClassScopeFunctionSpecializationDecl(
2443 DC, Loc, FD, HasExplicitTemplateArgs, std::move(TemplateArgs));
2444 }
2445
2446 static ClassScopeFunctionSpecializationDecl *
2447 CreateDeserialized(ASTContext &Context, unsigned ID);
2448
2449 // Implement isa/cast/dyncast/etc.
2450 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2451
2452 static bool classofKind(Kind K) {
2453 return K == Decl::ClassScopeFunctionSpecialization;
2454 }
2455};
2456
2457/// Implementation of inline functions that require the template declarations
2458inline AnyFunctionDecl::AnyFunctionDecl(FunctionTemplateDecl *FTD)
2459 : Function(FTD) {}
2460
2461/// Represents a variable template specialization, which refers to
2462/// a variable template with a given set of template arguments.
2463///
2464/// Variable template specializations represent both explicit
2465/// specializations of variable templates, as in the example below, and
2466/// implicit instantiations of variable templates.
2467///
2468/// \code
2469/// template<typename T> constexpr T pi = T(3.1415926535897932385);
2470///
2471/// template<>
2472/// constexpr float pi<float>; // variable template specialization pi<float>
2473/// \endcode
2474class VarTemplateSpecializationDecl : public VarDecl,
2475 public llvm::FoldingSetNode {
2476
2477 /// Structure that stores information about a variable template
2478 /// specialization that was instantiated from a variable template partial
2479 /// specialization.
2480 struct SpecializedPartialSpecialization {
2481 /// The variable template partial specialization from which this
2482 /// variable template specialization was instantiated.
2483 VarTemplatePartialSpecializationDecl *PartialSpecialization;
2484
2485 /// The template argument list deduced for the variable template
2486 /// partial specialization itself.
2487 const TemplateArgumentList *TemplateArgs;
2488 };
2489
2490 /// The template that this specialization specializes.
2491 llvm::PointerUnion<VarTemplateDecl *, SpecializedPartialSpecialization *>
2492 SpecializedTemplate;
2493
2494 /// Further info for explicit template specialization/instantiation.
2495 struct ExplicitSpecializationInfo {
2496 /// The type-as-written.
2497 TypeSourceInfo *TypeAsWritten = nullptr;
2498
2499 /// The location of the extern keyword.
2500 SourceLocation ExternLoc;
2501
2502 /// The location of the template keyword.
2503 SourceLocation TemplateKeywordLoc;
2504
2505 ExplicitSpecializationInfo() = default;
2506 };
2507
2508 /// Further info for explicit template specialization/instantiation.
2509 /// Does not apply to implicit specializations.
2510 ExplicitSpecializationInfo *ExplicitInfo = nullptr;
2511
2512 /// The template arguments used to describe this specialization.
2513 const TemplateArgumentList *TemplateArgs;
2514 TemplateArgumentListInfo TemplateArgsInfo;
2515
2516 /// The point where this template was instantiated (if any).
2517 SourceLocation PointOfInstantiation;
2518
2519 /// The kind of specialization this declaration refers to.
2520 /// Really a value of type TemplateSpecializationKind.
2521 unsigned SpecializationKind : 3;
2522
2523 /// Whether this declaration is a complete definition of the
2524 /// variable template specialization. We can't otherwise tell apart
2525 /// an instantiated declaration from an instantiated definition with
2526 /// no initializer.
2527 unsigned IsCompleteDefinition : 1;
2528
2529protected:
2530 VarTemplateSpecializationDecl(Kind DK, ASTContext &Context, DeclContext *DC,
2531 SourceLocation StartLoc, SourceLocation IdLoc,
2532 VarTemplateDecl *SpecializedTemplate,
2533 QualType T, TypeSourceInfo *TInfo,
2534 StorageClass S,
2535 ArrayRef<TemplateArgument> Args);
2536
2537 explicit VarTemplateSpecializationDecl(Kind DK, ASTContext &Context);
2538
2539public:
2540 friend class ASTDeclReader;
2541 friend class ASTDeclWriter;
2542 friend class VarDecl;
2543
2544 static VarTemplateSpecializationDecl *
2545 Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2546 SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
2547 TypeSourceInfo *TInfo, StorageClass S,
2548 ArrayRef<TemplateArgument> Args);
2549 static VarTemplateSpecializationDecl *CreateDeserialized(ASTContext &C,
2550 unsigned ID);
2551
2552 void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
2553 bool Qualified) const override;
2554
2555 VarTemplateSpecializationDecl *getMostRecentDecl() {
2556 VarDecl *Recent = static_cast<VarDecl *>(this)->getMostRecentDecl();
2557 return cast<VarTemplateSpecializationDecl>(Recent);
2558 }
2559
2560 /// Retrieve the template that this specialization specializes.
2561 VarTemplateDecl *getSpecializedTemplate() const;
2562
2563 /// Retrieve the template arguments of the variable template
2564 /// specialization.
2565 const TemplateArgumentList &getTemplateArgs() const { return *TemplateArgs; }
2566
2567 // TODO: Always set this when creating the new specialization?
2568 void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo);
2569
2570 const TemplateArgumentListInfo &getTemplateArgsInfo() const {
2571 return TemplateArgsInfo;
2572 }
2573
2574 /// Determine the kind of specialization that this
2575 /// declaration represents.
2576 TemplateSpecializationKind getSpecializationKind() const {
2577 return static_cast<TemplateSpecializationKind>(SpecializationKind);
2578 }
2579
2580 bool isExplicitSpecialization() const {
2581 return getSpecializationKind() == TSK_ExplicitSpecialization;
2582 }
2583
2584 /// True if this declaration is an explicit specialization,
2585 /// explicit instantiation declaration, or explicit instantiation
2586 /// definition.
2587 bool isExplicitInstantiationOrSpecialization() const {
2588 return isTemplateExplicitInstantiationOrSpecialization(
2589 getTemplateSpecializationKind());
2590 }
2591
2592 void setSpecializationKind(TemplateSpecializationKind TSK) {
2593 SpecializationKind = TSK;
2594 }
2595
2596 /// Get the point of instantiation (if any), or null if none.
2597 SourceLocation getPointOfInstantiation() const {
2598 return PointOfInstantiation;
2599 }
2600
2601 void setPointOfInstantiation(SourceLocation Loc) {
2602 assert(Loc.isValid() && "point of instantiation must be valid!");
2603 PointOfInstantiation = Loc;
2604 }
2605
2606 void setCompleteDefinition() { IsCompleteDefinition = true; }
2607
2608 /// If this variable template specialization is an instantiation of
2609 /// a template (rather than an explicit specialization), return the
2610 /// variable template or variable template partial specialization from which
2611 /// it was instantiated.
2612 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2613 getInstantiatedFrom() const {
2614 if (!isTemplateInstantiation(getSpecializationKind()))
2615 return llvm::PointerUnion<VarTemplateDecl *,
2616 VarTemplatePartialSpecializationDecl *>();
2617
2618 return getSpecializedTemplateOrPartial();
2619 }
2620
2621 /// Retrieve the variable template or variable template partial
2622 /// specialization which was specialized by this.
2623 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2624 getSpecializedTemplateOrPartial() const {
2625 if (const auto *PartialSpec =
2626 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2627 return PartialSpec->PartialSpecialization;
2628
2629 return SpecializedTemplate.get<VarTemplateDecl *>();
2630 }
2631
2632 /// Retrieve the set of template arguments that should be used
2633 /// to instantiate the initializer of the variable template or variable
2634 /// template partial specialization from which this variable template
2635 /// specialization was instantiated.
2636 ///
2637 /// \returns For a variable template specialization instantiated from the
2638 /// primary template, this function will return the same template arguments
2639 /// as getTemplateArgs(). For a variable template specialization instantiated
2640 /// from a variable template partial specialization, this function will the
2641 /// return deduced template arguments for the variable template partial
2642 /// specialization itself.
2643 const TemplateArgumentList &getTemplateInstantiationArgs() const {
2644 if (const auto *PartialSpec =
2645 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2646 return *PartialSpec->TemplateArgs;
2647
2648 return getTemplateArgs();
2649 }
2650
2651 /// Note that this variable template specialization is actually an
2652 /// instantiation of the given variable template partial specialization whose
2653 /// template arguments have been deduced.
2654 void setInstantiationOf(VarTemplatePartialSpecializationDecl *PartialSpec,
2655 const TemplateArgumentList *TemplateArgs) {
2656 assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
2657 "Already set to a variable template partial specialization!");
2658 auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
2659 PS->PartialSpecialization = PartialSpec;
2660 PS->TemplateArgs = TemplateArgs;
2661 SpecializedTemplate = PS;
2662 }
2663
2664 /// Note that this variable template specialization is an instantiation
2665 /// of the given variable template.
2666 void setInstantiationOf(VarTemplateDecl *TemplDecl) {
2667 assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
2668 "Previously set to a variable template partial specialization!");
2669 SpecializedTemplate = TemplDecl;
2670 }
2671
2672 /// Sets the type of this specialization as it was written by
2673 /// the user.
2674 void setTypeAsWritten(TypeSourceInfo *T) {
2675 if (!ExplicitInfo)
2676 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2677 ExplicitInfo->TypeAsWritten = T;
2678 }
2679
2680 /// Gets the type of this specialization as it was written by
2681 /// the user, if it was so written.
2682 TypeSourceInfo *getTypeAsWritten() const {
2683 return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
2684 }
2685
2686 /// Gets the location of the extern keyword, if present.
2687 SourceLocation getExternLoc() const {
2688 return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
2689 }
2690
2691 /// Sets the location of the extern keyword.
2692 void setExternLoc(SourceLocation Loc) {
2693 if (!ExplicitInfo)
2694 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2695 ExplicitInfo->ExternLoc = Loc;
2696 }
2697
2698 /// Sets the location of the template keyword.
2699 void setTemplateKeywordLoc(SourceLocation Loc) {
2700 if (!ExplicitInfo)
2701 ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2702 ExplicitInfo->TemplateKeywordLoc = Loc;
2703 }
2704
2705 /// Gets the location of the template keyword, if present.
2706 SourceLocation getTemplateKeywordLoc() const {
2707 return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
2708 }
2709
2710 void Profile(llvm::FoldingSetNodeID &ID) const {
2711 Profile(ID, TemplateArgs->asArray(), getASTContext());
2712 }
2713
2714 static void Profile(llvm::FoldingSetNodeID &ID,
2715 ArrayRef<TemplateArgument> TemplateArgs,
2716 ASTContext &Context) {
2717 ID.AddInteger(TemplateArgs.size());
2718 for (const TemplateArgument &TemplateArg : TemplateArgs)
2719 TemplateArg.Profile(ID, Context);
2720 }
2721
2722 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2723
2724 static bool classofKind(Kind K) {
2725 return K >= firstVarTemplateSpecialization &&
2726 K <= lastVarTemplateSpecialization;
2727 }
2728};
2729
2730class VarTemplatePartialSpecializationDecl
2731 : public VarTemplateSpecializationDecl {
2732 /// The list of template parameters
2733 TemplateParameterList *TemplateParams = nullptr;
2734
2735 /// The source info for the template arguments as written.
2736 /// FIXME: redundant with TypeAsWritten?
2737 const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
2738
2739 /// The variable template partial specialization from which this
2740 /// variable template partial specialization was instantiated.
2741 ///
2742 /// The boolean value will be true to indicate that this variable template
2743 /// partial specialization was specialized at this level.
2744 llvm::PointerIntPair<VarTemplatePartialSpecializationDecl *, 1, bool>
2745 InstantiatedFromMember;
2746
2747 VarTemplatePartialSpecializationDecl(
2748 ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2749 SourceLocation IdLoc, TemplateParameterList *Params,
2750 VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
2751 StorageClass S, ArrayRef<TemplateArgument> Args,
2752 const ASTTemplateArgumentListInfo *ArgInfos);
2753
2754 VarTemplatePartialSpecializationDecl(ASTContext &Context)
2755 : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization,
2756 Context),
2757 InstantiatedFromMember(nullptr, false) {}
2758
2759 void anchor() override;
2760
2761public:
2762 friend class ASTDeclReader;
2763 friend class ASTDeclWriter;
2764
2765 static VarTemplatePartialSpecializationDecl *
2766 Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2767 SourceLocation IdLoc, TemplateParameterList *Params,
2768 VarTemplateDecl *SpecializedTemplate, QualType T,
2769 TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args,
2770 const TemplateArgumentListInfo &ArgInfos);
2771
2772 static VarTemplatePartialSpecializationDecl *CreateDeserialized(ASTContext &C,
2773 unsigned ID);
2774
2775 VarTemplatePartialSpecializationDecl *getMostRecentDecl() {
2776 return cast<VarTemplatePartialSpecializationDecl>(
2777 static_cast<VarTemplateSpecializationDecl *>(
2778 this)->getMostRecentDecl());
2779 }
2780
2781 /// Get the list of template parameters
2782 TemplateParameterList *getTemplateParameters() const {
2783 return TemplateParams;
2784 }
2785
2786 /// Get the template arguments as written.
2787 const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
2788 return ArgsAsWritten;
2789 }
2790
2791 /// Retrieve the member variable template partial specialization from
2792 /// which this particular variable template partial specialization was
2793 /// instantiated.
2794 ///
2795 /// \code
2796 /// template<typename T>
2797 /// struct Outer {
2798 /// template<typename U> U Inner;
2799 /// template<typename U> U* Inner<U*> = (U*)(0); // #1
2800 /// };
2801 ///
2802 /// template int* Outer<float>::Inner<int*>;
2803 /// \endcode
2804 ///
2805 /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
2806 /// end up instantiating the partial specialization
2807 /// \c Outer<float>::Inner<U*>, which itself was instantiated from the
2808 /// variable template partial specialization \c Outer<T>::Inner<U*>. Given
2809 /// \c Outer<float>::Inner<U*>, this function would return
2810 /// \c Outer<T>::Inner<U*>.
2811 VarTemplatePartialSpecializationDecl *getInstantiatedFromMember() const {
2812 const auto *First =
2813 cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2814 return First->InstantiatedFromMember.getPointer();
2815 }
2816
2817 void
2818 setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec) {
2819 auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2820 First->InstantiatedFromMember.setPointer(PartialSpec);
2821 }
2822
2823 /// Determines whether this variable template partial specialization
2824 /// was a specialization of a member partial specialization.
2825 ///
2826 /// In the following example, the member template partial specialization
2827 /// \c X<int>::Inner<T*> is a member specialization.
2828 ///
2829 /// \code
2830 /// template<typename T>
2831 /// struct X {
2832 /// template<typename U> U Inner;
2833 /// template<typename U> U* Inner<U*> = (U*)(0);
2834 /// };
2835 ///
2836 /// template<> template<typename T>
2837 /// U* X<int>::Inner<T*> = (T*)(0) + 1;
2838 /// \endcode
2839 bool isMemberSpecialization() {
2840 const auto *First =
2841 cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2842 return First->InstantiatedFromMember.getInt();
2843 }
2844
2845 /// Note that this member template is a specialization.
2846 void setMemberSpecialization() {
2847 auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2848 assert(First->InstantiatedFromMember.getPointer() &&
2849 "Only member templates can be member template specializations");
2850 return First->InstantiatedFromMember.setInt(true);
2851 }
2852
2853 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2854
2855 static bool classofKind(Kind K) {
2856 return K == VarTemplatePartialSpecialization;
2857 }
2858};
2859
2860/// Declaration of a variable template.
2861class VarTemplateDecl : public RedeclarableTemplateDecl {
2862protected:
2863 /// Data that is common to all of the declarations of a given
2864 /// variable template.
2865 struct Common : CommonBase {
2866 /// The variable template specializations for this variable
2867 /// template, including explicit specializations and instantiations.
2868 llvm::FoldingSetVector<VarTemplateSpecializationDecl> Specializations;
2869
2870 /// The variable template partial specializations for this variable
2871 /// template.
2872 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>
2873 PartialSpecializations;
2874
2875 Common() = default;
2876 };
2877
2878 /// Retrieve the set of specializations of this variable template.
2879 llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
2880 getSpecializations() const;
2881
2882 /// Retrieve the set of partial specializations of this class
2883 /// template.
2884 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
2885 getPartialSpecializations();
2886
2887 VarTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
2888 DeclarationName Name, TemplateParameterList *Params,
2889 NamedDecl *Decl)
2890 : RedeclarableTemplateDecl(VarTemplate, C, DC, L, Name, Params, Decl) {}
2891
2892 CommonBase *newCommon(ASTContext &C) const override;
2893
2894 Common *getCommonPtr() const {
2895 return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2896 }
2897
2898public:
2899 friend class ASTDeclReader;
2900 friend class ASTDeclWriter;
2901
2902 /// Load any lazily-loaded specializations from the external source.
2903 void LoadLazySpecializations() const;
2904
2905 /// Get the underlying variable declarations of the template.
2906 VarDecl *getTemplatedDecl() const {
2907 return static_cast<VarDecl *>(TemplatedDecl);
2908 }
2909
2910 /// Returns whether this template declaration defines the primary
2911 /// variable pattern.
2912 bool isThisDeclarationADefinition() const {
2913 return getTemplatedDecl()->isThisDeclarationADefinition();
2914 }
2915
2916 VarTemplateDecl *getDefinition();
2917
2918 /// Create a variable template node.
2919 static VarTemplateDecl *Create(ASTContext &C, DeclContext *DC,
2920 SourceLocation L, DeclarationName Name,
2921 TemplateParameterList *Params,
2922 VarDecl *Decl);
2923
2924 /// Create an empty variable template node.
2925 static VarTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2926
2927 /// Return the specialization with the provided arguments if it exists,
2928 /// otherwise return the insertion point.
2929 VarTemplateSpecializationDecl *
2930 findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2931
2932 /// Insert the specified specialization knowing that it is not already
2933 /// in. InsertPos must be obtained from findSpecialization.
2934 void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos);
2935
2936 VarTemplateDecl *getCanonicalDecl() override {
2937 return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
2938 }
2939 const VarTemplateDecl *getCanonicalDecl() const {
2940 return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
2941 }
2942
2943 /// Retrieve the previous declaration of this variable template, or
2944 /// nullptr if no such declaration exists.
2945 VarTemplateDecl *getPreviousDecl() {
2946 return cast_or_null<VarTemplateDecl>(
2947 static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2948 }
2949 const VarTemplateDecl *getPreviousDecl() const {
2950 return cast_or_null<VarTemplateDecl>(
2951 static_cast<const RedeclarableTemplateDecl *>(
2952 this)->getPreviousDecl());
2953 }
2954
2955 VarTemplateDecl *getMostRecentDecl() {
2956 return cast<VarTemplateDecl>(
2957 static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
2958 }
2959 const VarTemplateDecl *getMostRecentDecl() const {
2960 return const_cast<VarTemplateDecl *>(this)->getMostRecentDecl();
2961 }
2962
2963 VarTemplateDecl *getInstantiatedFromMemberTemplate() const {
2964 return cast_or_null<VarTemplateDecl>(
2965 RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
2966 }
2967
2968 /// Return the partial specialization with the provided arguments if it
2969 /// exists, otherwise return the insertion point.
2970 VarTemplatePartialSpecializationDecl *
2971 findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2972
2973 /// Insert the specified partial specialization knowing that it is not
2974 /// already in. InsertPos must be obtained from findPartialSpecialization.
2975 void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D,
2976 void *InsertPos);
2977
2978 /// Retrieve the partial specializations as an ordered list.
2979 void getPartialSpecializations(
2980 SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS);
2981
2982 /// Find a variable template partial specialization which was
2983 /// instantiated
2984 /// from the given member partial specialization.
2985 ///
2986 /// \param D a member variable template partial specialization.
2987 ///
2988 /// \returns the variable template partial specialization which was
2989 /// instantiated
2990 /// from the given member partial specialization, or nullptr if no such
2991 /// partial specialization exists.
2992 VarTemplatePartialSpecializationDecl *findPartialSpecInstantiatedFromMember(
2993 VarTemplatePartialSpecializationDecl *D);
2994
2995 using spec_iterator = SpecIterator<VarTemplateSpecializationDecl>;
2996 using spec_range = llvm::iterator_range<spec_iterator>;
2997
2998 spec_range specializations() const {
2999 return spec_range(spec_begin(), spec_end());
3000 }
3001
3002 spec_iterator spec_begin() const {
3003 return makeSpecIterator(getSpecializations(), false);
3004 }
3005
3006 spec_iterator spec_end() const {
3007 return makeSpecIterator(getSpecializations(), true);
3008 }
3009
3010 // Implement isa/cast/dyncast support
3011 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3012 static bool classofKind(Kind K) { return K == VarTemplate; }
3013};
3014
3015inline NamedDecl *getAsNamedDecl(TemplateParameter P) {
3016 if (auto *PD = P.dyn_cast<TemplateTypeParmDecl *>())
3017 return PD;
3018 if (auto *PD = P.dyn_cast<NonTypeTemplateParmDecl *>())
3019 return PD;
3020 return P.get<TemplateTemplateParmDecl *>();
3021}
3022
3023inline TemplateDecl *getAsTypeTemplateDecl(Decl *D) {
3024 auto *TD = dyn_cast<TemplateDecl>(D);
3025 return TD && (isa<ClassTemplateDecl>(TD) ||
3026 isa<ClassTemplatePartialSpecializationDecl>(TD) ||
3027 isa<TypeAliasTemplateDecl>(TD) ||
3028 isa<TemplateTemplateParmDecl>(TD))
3029 ? TD
3030 : nullptr;
3031}
3032
3033} // namespace clang
3034
3035#endif // LLVM_CLANG_AST_DECLTEMPLATE_H
3036