clang  7.0.0svn
DeclTemplate.h
Go to the documentation of this file.
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"
22 #include "clang/AST/Redeclarable.h"
23 #include "clang/AST/TemplateBase.h"
24 #include "clang/AST/Type.h"
25 #include "clang/Basic/LLVM.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 
43 namespace clang {
44 
45 enum BuiltinTemplateKind : int;
46 class ClassTemplateDecl;
47 class ClassTemplatePartialSpecializationDecl;
48 class Expr;
49 class FunctionTemplateDecl;
50 class IdentifierInfo;
51 class NonTypeTemplateParmDecl;
52 class TemplateDecl;
53 class TemplateTemplateParmDecl;
54 class TemplateTypeParmDecl;
55 class UnresolvedSetImpl;
56 class VarTemplateDecl;
57 class VarTemplatePartialSpecializationDecl;
58 
59 /// Stores a template parameter of any kind.
60 using TemplateParameter =
61  llvm::PointerUnion3<TemplateTypeParmDecl *, NonTypeTemplateParmDecl *,
63 
65 
66 /// Stores a list of template parameters for a TemplateDecl and its
67 /// derived classes.
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 
88 protected:
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 
101 public:
102  template <size_t N, bool HasRequiresClause>
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 
127  return llvm::makeArrayRef(begin(), end());
128  }
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.
159  return ContainsUnexpandedParameterPack;
160  }
161 
162  /// The constraint-expression of the associated requires-clause.
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 
180 public:
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.
188 template <size_t N, bool HasRequiresClause>
191  typename TemplateParameterList::FixedSizeStorage<
192  NamedDecl *, Expr *>::with_counts<
193  N, HasRequiresClause ? 1u : 0u
194  >::type storage;
195 
196 public:
198  SourceLocation LAngleLoc,
199  ArrayRef<NamedDecl *> Params,
200  SourceLocation RAngleLoc,
201  Expr *RequiresClause)
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.
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)
222 
223 public:
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,
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.
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.
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.
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 
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.
286 template<typename ParmDecl, typename ArgType>
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 
310 public:
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.
371  friend TemplateDecl;
372 
373 public:
374  ConstrainedTemplateDeclInfo() = default;
375 
377  return TemplateParams;
378  }
379 
380  Expr *getAssociatedConstraints() const { return AssociatedConstraints; }
381 
382 protected:
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.
399 class TemplateDecl : public NamedDecl {
400  void anchor() override;
401 
402 protected:
403  // Construct a template decl with the given name and parameters.
404  // Used when there is no templated element (e.g., for tt-params).
407  TemplateParameterList *Params)
408  : NamedDecl(DK, DC, L, Name), TemplatedDecl(nullptr),
409  TemplateParams(CTDI) {
410  this->setTemplateParameters(Params);
411  }
412 
414  TemplateParameterList *Params)
415  : TemplateDecl(nullptr, DK, DC, L, Name, Params) {}
416 
417  // Construct a template decl with name, parameters, and templated element.
421  : NamedDecl(DK, DC, L, Name), TemplatedDecl(Decl),
422  TemplateParams(CTDI) {
423  this->setTemplateParameters(Params);
424  }
425 
428  : TemplateDecl(nullptr, DK, DC, L, Name, Params, Decl) {}
429 
430 public:
431  /// Get the list of template parameters
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 
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 
467 protected:
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 *,
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 
488  assert(isCanonicalDecl() &&
489  "Attaching associated constraints to non-canonical Decl");
490  TemplateParams.get<ConstrainedTemplateDeclInfo *>()
491  ->setAssociatedConstraints(AC);
492  }
493 
494 public:
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.
508 class FunctionTemplateSpecializationInfo : public llvm::FoldingSetNode {
510  FunctionTemplateDecl *Template,
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 
520 public:
524  const TemplateArgumentList *TemplateArgs,
525  const TemplateArgumentListInfo *TemplateArgsAsWritten,
526  SourceLocation POI);
527 
528  /// The function template specialization that this structure
529  /// describes.
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.
541 
542  /// The template arguments as written in the sources, if provided.
544 
545  /// The point at which this function template specialization was
546  /// first instantiated.
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.
554  return (TemplateSpecializationKind)(Template.getInt() + 1);
555  }
556 
559  }
560 
561  /// True if this declaration is an explicit specialization,
562  /// explicit instantiation declaration, or explicit instantiation
563  /// definition.
567  }
568 
569  /// Set the template specialization kind.
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.
582  return PointOfInstantiation;
583  }
584 
585  /// Set the (first) point of instantiation of this function template
586  /// specialization.
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.
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 
616 public:
617  explicit
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.
631  return (TemplateSpecializationKind)(MemberAndTSK.getInt() + 1);
632  }
633 
636  }
637 
638  /// Set the template specialization kind.
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.
649  return PointOfInstantiation;
650  }
651 
652  /// Set the first point of instantiation.
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
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 
693  const UnresolvedSetImpl &Templates,
694  const TemplateArgumentListInfo &TemplateArgs);
695 
696 public:
698 
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.
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 
728  return AngleLocs.getBegin();
729  }
730 
732  return AngleLocs.getEnd();
733  }
734 };
735 
736 /// Declaration of a redeclarable template.
738  public Redeclarable<RedeclarableTemplateDecl>
739 {
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 
754 protected:
755  template <typename EntryType> struct SpecEntryTraits {
756  using DeclType = EntryType;
757 
758  static DeclType *getDecl(EntryType *D) {
759  return D;
760  }
761 
763  return D->getTemplateArgs().asArray();
764  }
765  };
766 
767  template <typename EntryType, typename SETraits = SpecEntryTraits<EntryType>,
768  typename DeclType = typename SETraits::DeclType>
770  : llvm::iterator_adaptor_base<
771  SpecIterator<EntryType, SETraits, DeclType>,
772  typename llvm::FoldingSetVector<EntryType>::iterator,
773  typename std::iterator_traits<typename llvm::FoldingSetVector<
774  EntryType>::iterator>::iterator_category,
775  DeclType *, ptrdiff_t, DeclType *, DeclType *> {
776  SpecIterator() = default;
777  explicit SpecIterator(
778  typename llvm::FoldingSetVector<EntryType>::iterator SetIter)
779  : SpecIterator::iterator_adaptor_base(std::move(SetIter)) {}
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>
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>
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.
838  NamedDecl *Decl)
839  : TemplateDecl(CTDI, DK, DC, L, Name, Params, Decl), redeclarable_base(C)
840  {}
841 
845  : RedeclarableTemplateDecl(nullptr, DK, C, DC, L, Name, Params, Decl) {}
846 
847 public:
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.
855  return getFirstDecl();
856  }
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.
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
927  return getCommonPtr()->InstantiatedFromMember.getPointer();
928  }
929 
931  assert(!getCommonPtr()->InstantiatedFromMember.getPointer());
932  getCommonPtr()->InstantiatedFromMember.setPointer(TD);
933  }
934 
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 
953 template <> struct RedeclarableTemplateDecl::
954 SpecEntryTraits<FunctionTemplateSpecializationInfo> {
956 
958  return I->Function;
959  }
960 
963  return I->TemplateArguments->asArray();
964  }
965 };
966 
967 /// Declaration of a template function.
969 protected:
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 
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 
1015 public:
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.
1024  return static_cast<FunctionDecl *>(TemplatedDecl);
1025  }
1026 
1027  /// Returns whether this template declaration defines the primary
1028  /// pattern.
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 
1039  return cast<FunctionTemplateDecl>(
1041  }
1043  return cast<FunctionTemplateDecl>(
1045  }
1046 
1047  /// Retrieve the previous declaration of this function template, or
1048  /// nullptr if no such declaration exists.
1050  return cast_or_null<FunctionTemplateDecl>(
1051  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
1052  }
1054  return cast_or_null<FunctionTemplateDecl>(
1055  static_cast<const RedeclarableTemplateDecl *>(this)->getPreviousDecl());
1056  }
1057 
1059  return cast<FunctionTemplateDecl>(
1060  static_cast<RedeclarableTemplateDecl *>(this)
1061  ->getMostRecentDecl());
1062  }
1064  return const_cast<FunctionTemplateDecl*>(this)->getMostRecentDecl();
1065  }
1066 
1068  return cast_or_null<FunctionTemplateDecl>(
1070  }
1071 
1073  using spec_range = llvm::iterator_range<spec_iterator>;
1074 
1076  return spec_range(spec_begin(), spec_end());
1077  }
1078 
1080  return makeSpecIterator(getSpecializations(), false);
1081  }
1082 
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  /// Create a function template node.
1098  SourceLocation L,
1099  DeclarationName Name,
1100  TemplateParameterList *Params,
1101  NamedDecl *Decl);
1102 
1103  /// Create an empty function template node.
1104  static FunctionTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1105 
1106  // Implement isa/cast/dyncast support
1107  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1108  static bool classofKind(Kind K) { return K == FunctionTemplate; }
1109 };
1110 
1111 //===----------------------------------------------------------------------===//
1112 // Kinds of Template Parameters
1113 //===----------------------------------------------------------------------===//
1114 
1115 /// Defines the position of a template parameter within a template
1116 /// parameter list.
1117 ///
1118 /// Because template parameter can be listed
1119 /// sequentially for out-of-line template members, each template parameter is
1120 /// given a Depth - the nesting of template parameter scopes - and a Position -
1121 /// the occurrence within the parameter list.
1122 /// This class is inheritedly privately by different kinds of template
1123 /// parameters and is not part of the Decl hierarchy. Just a facility.
1125 protected:
1126  // FIXME: These probably don't need to be ints. int:5 for depth, int:8 for
1127  // position? Maybe?
1128  unsigned Depth;
1129  unsigned Position;
1130 
1131  TemplateParmPosition(unsigned D, unsigned P) : Depth(D), Position(P) {}
1132 
1133 public:
1134  TemplateParmPosition() = delete;
1135 
1136  /// Get the nesting depth of the template parameter.
1137  unsigned getDepth() const { return Depth; }
1138  void setDepth(unsigned D) { Depth = D; }
1139 
1140  /// Get the position of the template parameter within its parameter list.
1141  unsigned getPosition() const { return Position; }
1142  void setPosition(unsigned P) { Position = P; }
1143 
1144  /// Get the index of the template parameter within its parameter list.
1145  unsigned getIndex() const { return Position; }
1146 };
1147 
1148 /// Declaration of a template type parameter.
1149 ///
1150 /// For example, "T" in
1151 /// \code
1152 /// template<typename T> class vector;
1153 /// \endcode
1154 class TemplateTypeParmDecl : public TypeDecl {
1155  /// Sema creates these on the stack during auto type deduction.
1156  friend class Sema;
1157 
1158  /// Whether this template type parameter was declaration with
1159  /// the 'typename' keyword.
1160  ///
1161  /// If false, it was declared with the 'class' keyword.
1162  bool Typename : 1;
1163 
1164  /// The default template argument, if any.
1165  using DefArgStorage =
1167  DefArgStorage DefaultArgument;
1168 
1169  TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc,
1171  bool Typename)
1172  : TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename) {}
1173 
1174 public:
1175  static TemplateTypeParmDecl *Create(const ASTContext &C, DeclContext *DC,
1176  SourceLocation KeyLoc,
1177  SourceLocation NameLoc,
1178  unsigned D, unsigned P,
1179  IdentifierInfo *Id, bool Typename,
1180  bool ParameterPack);
1181  static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C,
1182  unsigned ID);
1183 
1184  /// Whether this template type parameter was declared with
1185  /// the 'typename' keyword.
1186  ///
1187  /// If not, it was declared with the 'class' keyword.
1188  bool wasDeclaredWithTypename() const { return Typename; }
1189 
1190  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1191 
1192  /// Determine whether this template parameter has a default
1193  /// argument.
1194  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1195 
1196  /// Retrieve the default argument, if any.
1198  return DefaultArgument.get()->getType();
1199  }
1200 
1201  /// Retrieves the default argument's source information, if any.
1203  return DefaultArgument.get();
1204  }
1205 
1206  /// Retrieves the location of the default argument declaration.
1207  SourceLocation getDefaultArgumentLoc() const;
1208 
1209  /// Determines whether the default argument was inherited
1210  /// from a previous declaration of this template.
1212  return DefaultArgument.isInherited();
1213  }
1214 
1215  /// Set the default argument for this template parameter.
1217  DefaultArgument.set(DefArg);
1218  }
1219 
1220  /// Set that this default argument was inherited from another
1221  /// parameter.
1223  TemplateTypeParmDecl *Prev) {
1224  DefaultArgument.setInherited(C, Prev);
1225  }
1226 
1227  /// Removes the default argument of this template parameter.
1229  DefaultArgument.clear();
1230  }
1231 
1232  /// Set whether this template type parameter was declared with
1233  /// the 'typename' or 'class' keyword.
1234  void setDeclaredWithTypename(bool withTypename) { Typename = withTypename; }
1235 
1236  /// Retrieve the depth of the template parameter.
1237  unsigned getDepth() const;
1238 
1239  /// Retrieve the index of the template parameter.
1240  unsigned getIndex() const;
1241 
1242  /// Returns whether this is a parameter pack.
1243  bool isParameterPack() const;
1244 
1245  SourceRange getSourceRange() const override LLVM_READONLY;
1246 
1247  // Implement isa/cast/dyncast/etc.
1248  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1249  static bool classofKind(Kind K) { return K == TemplateTypeParm; }
1250 };
1251 
1252 /// NonTypeTemplateParmDecl - Declares a non-type template parameter,
1253 /// e.g., "Size" in
1254 /// @code
1255 /// template<int Size> class array { };
1256 /// @endcode
1257 class NonTypeTemplateParmDecl final
1258  : public DeclaratorDecl,
1259  protected TemplateParmPosition,
1260  private llvm::TrailingObjects<NonTypeTemplateParmDecl,
1261  std::pair<QualType, TypeSourceInfo *>> {
1262  friend class ASTDeclReader;
1263  friend TrailingObjects;
1264 
1265  /// The default template argument, if any, and whether or not
1266  /// it was inherited.
1268  DefArgStorage DefaultArgument;
1269 
1270  // FIXME: Collapse this into TemplateParamPosition; or, just move depth/index
1271  // down here to save memory.
1272 
1273  /// Whether this non-type template parameter is a parameter pack.
1274  bool ParameterPack;
1275 
1276  /// Whether this non-type template parameter is an "expanded"
1277  /// parameter pack, meaning that its type is a pack expansion and we
1278  /// already know the set of types that expansion expands to.
1279  bool ExpandedParameterPack = false;
1280 
1281  /// The number of types in an expanded parameter pack.
1282  unsigned NumExpandedTypes = 0;
1283 
1284  size_t numTrailingObjects(
1285  OverloadToken<std::pair<QualType, TypeSourceInfo *>>) const {
1286  return NumExpandedTypes;
1287  }
1288 
1289  NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
1290  SourceLocation IdLoc, unsigned D, unsigned P,
1292  bool ParameterPack, TypeSourceInfo *TInfo)
1293  : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
1294  TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
1295 
1296  NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
1297  SourceLocation IdLoc, unsigned D, unsigned P,
1299  TypeSourceInfo *TInfo,
1300  ArrayRef<QualType> ExpandedTypes,
1301  ArrayRef<TypeSourceInfo *> ExpandedTInfos);
1302 
1303 public:
1304  static NonTypeTemplateParmDecl *
1305  Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1306  SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
1307  QualType T, bool ParameterPack, TypeSourceInfo *TInfo);
1308 
1309  static NonTypeTemplateParmDecl *
1310  Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1311  SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
1312  QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
1313  ArrayRef<TypeSourceInfo *> ExpandedTInfos);
1314 
1315  static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
1316  unsigned ID);
1317  static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
1318  unsigned ID,
1319  unsigned NumExpandedTypes);
1320 
1326 
1327  SourceRange getSourceRange() const override LLVM_READONLY;
1328 
1329  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1330 
1331  /// Determine whether this template parameter has a default
1332  /// argument.
1333  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1334 
1335  /// Retrieve the default argument, if any.
1336  Expr *getDefaultArgument() const { return DefaultArgument.get(); }
1337 
1338  /// Retrieve the location of the default argument, if any.
1339  SourceLocation getDefaultArgumentLoc() const;
1340 
1341  /// Determines whether the default argument was inherited
1342  /// from a previous declaration of this template.
1344  return DefaultArgument.isInherited();
1345  }
1346 
1347  /// Set the default argument for this template parameter, and
1348  /// whether that default argument was inherited from another
1349  /// declaration.
1350  void setDefaultArgument(Expr *DefArg) { DefaultArgument.set(DefArg); }
1352  NonTypeTemplateParmDecl *Parm) {
1353  DefaultArgument.setInherited(C, Parm);
1354  }
1355 
1356  /// Removes the default argument of this template parameter.
1357  void removeDefaultArgument() { DefaultArgument.clear(); }
1358 
1359  /// Whether this parameter is a non-type template parameter pack.
1360  ///
1361  /// If the parameter is a parameter pack, the type may be a
1362  /// \c PackExpansionType. In the following example, the \c Dims parameter
1363  /// is a parameter pack (whose type is 'unsigned').
1364  ///
1365  /// \code
1366  /// template<typename T, unsigned ...Dims> struct multi_array;
1367  /// \endcode
1368  bool isParameterPack() const { return ParameterPack; }
1369 
1370  /// Whether this parameter pack is a pack expansion.
1371  ///
1372  /// A non-type template parameter pack is a pack expansion if its type
1373  /// contains an unexpanded parameter pack. In this case, we will have
1374  /// built a PackExpansionType wrapping the type.
1375  bool isPackExpansion() const {
1376  return ParameterPack && getType()->getAs<PackExpansionType>();
1377  }
1378 
1379  /// Whether this parameter is a non-type template parameter pack
1380  /// that has a known list of different types at different positions.
1381  ///
1382  /// A parameter pack is an expanded parameter pack when the original
1383  /// parameter pack's type was itself a pack expansion, and that expansion
1384  /// has already been expanded. For example, given:
1385  ///
1386  /// \code
1387  /// template<typename ...Types>
1388  /// struct X {
1389  /// template<Types ...Values>
1390  /// struct Y { /* ... */ };
1391  /// };
1392  /// \endcode
1393  ///
1394  /// The parameter pack \c Values has a \c PackExpansionType as its type,
1395  /// which expands \c Types. When \c Types is supplied with template arguments
1396  /// by instantiating \c X, the instantiation of \c Values becomes an
1397  /// expanded parameter pack. For example, instantiating
1398  /// \c X<int, unsigned int> results in \c Values being an expanded parameter
1399  /// pack with expansion types \c int and \c unsigned int.
1400  ///
1401  /// The \c getExpansionType() and \c getExpansionTypeSourceInfo() functions
1402  /// return the expansion types.
1403  bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1404 
1405  /// Retrieves the number of expansion types in an expanded parameter
1406  /// pack.
1407  unsigned getNumExpansionTypes() const {
1408  assert(ExpandedParameterPack && "Not an expansion parameter pack");
1409  return NumExpandedTypes;
1410  }
1411 
1412  /// Retrieve a particular expansion type within an expanded parameter
1413  /// pack.
1414  QualType getExpansionType(unsigned I) const {
1415  assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1416  auto TypesAndInfos =
1417  getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1418  return TypesAndInfos[I].first;
1419  }
1420 
1421  /// Retrieve a particular expansion type source info within an
1422  /// expanded parameter pack.
1424  assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1425  auto TypesAndInfos =
1426  getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1427  return TypesAndInfos[I].second;
1428  }
1429 
1430  // Implement isa/cast/dyncast/etc.
1431  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1432  static bool classofKind(Kind K) { return K == NonTypeTemplateParm; }
1433 };
1434 
1435 /// TemplateTemplateParmDecl - Declares a template template parameter,
1436 /// e.g., "T" in
1437 /// @code
1438 /// template <template <typename> class T> class container { };
1439 /// @endcode
1440 /// A template template parameter is a TemplateDecl because it defines the
1441 /// name of a template and the template parameters allowable for substitution.
1443  : public TemplateDecl,
1444  protected TemplateParmPosition,
1445  private llvm::TrailingObjects<TemplateTemplateParmDecl,
1446  TemplateParameterList *> {
1447  /// The default template argument, if any.
1448  using DefArgStorage =
1450  DefArgStorage DefaultArgument;
1451 
1452  /// Whether this parameter is a parameter pack.
1453  bool ParameterPack;
1454 
1455  /// Whether this template template parameter is an "expanded"
1456  /// parameter pack, meaning that it is a pack expansion and we
1457  /// already know the set of template parameters that expansion expands to.
1458  bool ExpandedParameterPack = false;
1459 
1460  /// The number of parameters in an expanded parameter pack.
1461  unsigned NumExpandedParams = 0;
1462 
1464  unsigned D, unsigned P, bool ParameterPack,
1466  : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
1467  TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
1468 
1470  unsigned D, unsigned P,
1473 
1474  void anchor() override;
1475 
1476 public:
1477  friend class ASTDeclReader;
1478  friend class ASTDeclWriter;
1480 
1481  static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
1482  SourceLocation L, unsigned D,
1483  unsigned P, bool ParameterPack,
1484  IdentifierInfo *Id,
1485  TemplateParameterList *Params);
1486  static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
1487  SourceLocation L, unsigned D,
1488  unsigned P,
1489  IdentifierInfo *Id,
1490  TemplateParameterList *Params,
1492 
1493  static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
1494  unsigned ID);
1495  static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
1496  unsigned ID,
1497  unsigned NumExpansions);
1498 
1504 
1505  /// Whether this template template parameter is a template
1506  /// parameter pack.
1507  ///
1508  /// \code
1509  /// template<template <class T> ...MetaFunctions> struct Apply;
1510  /// \endcode
1511  bool isParameterPack() const { return ParameterPack; }
1512 
1513  /// Whether this parameter pack is a pack expansion.
1514  ///
1515  /// A template template parameter pack is a pack expansion if its template
1516  /// parameter list contains an unexpanded parameter pack.
1517  bool isPackExpansion() const {
1518  return ParameterPack &&
1519  getTemplateParameters()->containsUnexpandedParameterPack();
1520  }
1521 
1522  /// Whether this parameter is a template template parameter pack that
1523  /// has a known list of different template parameter lists at different
1524  /// positions.
1525  ///
1526  /// A parameter pack is an expanded parameter pack when the original parameter
1527  /// pack's template parameter list was itself a pack expansion, and that
1528  /// expansion has already been expanded. For exampe, given:
1529  ///
1530  /// \code
1531  /// template<typename...Types> struct Outer {
1532  /// template<template<Types> class...Templates> struct Inner;
1533  /// };
1534  /// \endcode
1535  ///
1536  /// The parameter pack \c Templates is a pack expansion, which expands the
1537  /// pack \c Types. When \c Types is supplied with template arguments by
1538  /// instantiating \c Outer, the instantiation of \c Templates is an expanded
1539  /// parameter pack.
1540  bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1541 
1542  /// Retrieves the number of expansion template parameters in
1543  /// an expanded parameter pack.
1545  assert(ExpandedParameterPack && "Not an expansion parameter pack");
1546  return NumExpandedParams;
1547  }
1548 
1549  /// Retrieve a particular expansion type within an expanded parameter
1550  /// pack.
1552  assert(I < NumExpandedParams && "Out-of-range expansion type index");
1553  return getTrailingObjects<TemplateParameterList *>()[I];
1554  }
1555 
1556  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1557 
1558  /// Determine whether this template parameter has a default
1559  /// argument.
1560  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1561 
1562  /// Retrieve the default argument, if any.
1564  static const TemplateArgumentLoc None;
1565  return DefaultArgument.isSet() ? *DefaultArgument.get() : None;
1566  }
1567 
1568  /// Retrieve the location of the default argument, if any.
1569  SourceLocation getDefaultArgumentLoc() const;
1570 
1571  /// Determines whether the default argument was inherited
1572  /// from a previous declaration of this template.
1574  return DefaultArgument.isInherited();
1575  }
1576 
1577  /// Set the default argument for this template parameter, and
1578  /// whether that default argument was inherited from another
1579  /// declaration.
1580  void setDefaultArgument(const ASTContext &C,
1581  const TemplateArgumentLoc &DefArg);
1583  TemplateTemplateParmDecl *Prev) {
1584  DefaultArgument.setInherited(C, Prev);
1585  }
1586 
1587  /// Removes the default argument of this template parameter.
1588  void removeDefaultArgument() { DefaultArgument.clear(); }
1589 
1590  SourceRange getSourceRange() const override LLVM_READONLY {
1591  SourceLocation End = getLocation();
1592  if (hasDefaultArgument() && !defaultArgumentWasInherited())
1593  End = getDefaultArgument().getSourceRange().getEnd();
1594  return SourceRange(getTemplateParameters()->getTemplateLoc(), End);
1595  }
1596 
1597  // Implement isa/cast/dyncast/etc.
1598  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1599  static bool classofKind(Kind K) { return K == TemplateTemplateParm; }
1600 };
1601 
1602 /// Represents the builtin template declaration which is used to
1603 /// implement __make_integer_seq and other builtin templates. It serves
1604 /// no real purpose beyond existing as a place to hold template parameters.
1606  BuiltinTemplateKind BTK;
1607 
1610 
1611  void anchor() override;
1612 
1613 public:
1614  // Implement isa/cast/dyncast support
1615  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1616  static bool classofKind(Kind K) { return K == BuiltinTemplate; }
1617 
1619  DeclarationName Name,
1620  BuiltinTemplateKind BTK) {
1621  return new (C, DC) BuiltinTemplateDecl(C, DC, Name, BTK);
1622  }
1623 
1624  SourceRange getSourceRange() const override LLVM_READONLY {
1625  return {};
1626  }
1627 
1629 };
1630 
1631 /// Represents a class template specialization, which refers to
1632 /// a class template with a given set of template arguments.
1633 ///
1634 /// Class template specializations represent both explicit
1635 /// specialization of class templates, as in the example below, and
1636 /// implicit instantiations of class templates.
1637 ///
1638 /// \code
1639 /// template<typename T> class array;
1640 ///
1641 /// template<>
1642 /// class array<bool> { }; // class template specialization array<bool>
1643 /// \endcode
1645  : public CXXRecordDecl, public llvm::FoldingSetNode {
1646  /// Structure that stores information about a class template
1647  /// specialization that was instantiated from a class template partial
1648  /// specialization.
1649  struct SpecializedPartialSpecialization {
1650  /// The class template partial specialization from which this
1651  /// class template specialization was instantiated.
1652  ClassTemplatePartialSpecializationDecl *PartialSpecialization;
1653 
1654  /// The template argument list deduced for the class template
1655  /// partial specialization itself.
1656  const TemplateArgumentList *TemplateArgs;
1657  };
1658 
1659  /// The template that this specialization specializes
1660  llvm::PointerUnion<ClassTemplateDecl *, SpecializedPartialSpecialization *>
1661  SpecializedTemplate;
1662 
1663  /// Further info for explicit template specialization/instantiation.
1664  struct ExplicitSpecializationInfo {
1665  /// The type-as-written.
1666  TypeSourceInfo *TypeAsWritten = nullptr;
1667 
1668  /// The location of the extern keyword.
1669  SourceLocation ExternLoc;
1670 
1671  /// The location of the template keyword.
1672  SourceLocation TemplateKeywordLoc;
1673 
1674  ExplicitSpecializationInfo() = default;
1675  };
1676 
1677  /// Further info for explicit template specialization/instantiation.
1678  /// Does not apply to implicit specializations.
1679  ExplicitSpecializationInfo *ExplicitInfo = nullptr;
1680 
1681  /// The template arguments used to describe this specialization.
1682  const TemplateArgumentList *TemplateArgs;
1683 
1684  /// The point where this template was instantiated (if any)
1685  SourceLocation PointOfInstantiation;
1686 
1687  /// The kind of specialization this declaration refers to.
1688  /// Really a value of type TemplateSpecializationKind.
1689  unsigned SpecializationKind : 3;
1690 
1691 protected:
1693  DeclContext *DC, SourceLocation StartLoc,
1694  SourceLocation IdLoc,
1695  ClassTemplateDecl *SpecializedTemplate,
1698 
1700 
1701 public:
1702  friend class ASTDeclReader;
1703  friend class ASTDeclWriter;
1704 
1706  Create(ASTContext &Context, TagKind TK, DeclContext *DC,
1707  SourceLocation StartLoc, SourceLocation IdLoc,
1708  ClassTemplateDecl *SpecializedTemplate,
1712  CreateDeserialized(ASTContext &C, unsigned ID);
1713 
1714  void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
1715  bool Qualified) const override;
1716 
1717  // FIXME: This is broken. CXXRecordDecl::getMostRecentDecl() returns a
1718  // different "most recent" declaration from this function for the same
1719  // declaration, because we don't override getMostRecentDeclImpl(). But
1720  // it's not clear that we should override that, because the most recent
1721  // declaration as a CXXRecordDecl sometimes is the injected-class-name.
1723  return cast<ClassTemplateSpecializationDecl>(
1724  getMostRecentNonInjectedDecl());
1725  }
1726 
1727  /// Retrieve the template that this specialization specializes.
1728  ClassTemplateDecl *getSpecializedTemplate() const;
1729 
1730  /// Retrieve the template arguments of the class template
1731  /// specialization.
1733  return *TemplateArgs;
1734  }
1735 
1736  /// Determine the kind of specialization that this
1737  /// declaration represents.
1739  return static_cast<TemplateSpecializationKind>(SpecializationKind);
1740  }
1741 
1743  return getSpecializationKind() == TSK_ExplicitSpecialization;
1744  }
1745 
1746  /// True if this declaration is an explicit specialization,
1747  /// explicit instantiation declaration, or explicit instantiation
1748  /// definition.
1752  }
1753 
1755  SpecializationKind = TSK;
1756  }
1757 
1758  /// Get the point of instantiation (if any), or null if none.
1760  return PointOfInstantiation;
1761  }
1762 
1764  assert(Loc.isValid() && "point of instantiation must be valid!");
1765  PointOfInstantiation = Loc;
1766  }
1767 
1768  /// If this class template specialization is an instantiation of
1769  /// a template (rather than an explicit specialization), return the
1770  /// class template or class template partial specialization from which it
1771  /// was instantiated.
1772  llvm::PointerUnion<ClassTemplateDecl *,
1775  if (!isTemplateInstantiation(getSpecializationKind()))
1776  return llvm::PointerUnion<ClassTemplateDecl *,
1778 
1779  return getSpecializedTemplateOrPartial();
1780  }
1781 
1782  /// Retrieve the class template or class template partial
1783  /// specialization which was specialized by this.
1784  llvm::PointerUnion<ClassTemplateDecl *,
1787  if (const auto *PartialSpec =
1788  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1789  return PartialSpec->PartialSpecialization;
1790 
1791  return SpecializedTemplate.get<ClassTemplateDecl*>();
1792  }
1793 
1794  /// Retrieve the set of template arguments that should be used
1795  /// to instantiate members of the class template or class template partial
1796  /// specialization from which this class template specialization was
1797  /// instantiated.
1798  ///
1799  /// \returns For a class template specialization instantiated from the primary
1800  /// template, this function will return the same template arguments as
1801  /// getTemplateArgs(). For a class template specialization instantiated from
1802  /// a class template partial specialization, this function will return the
1803  /// deduced template arguments for the class template partial specialization
1804  /// itself.
1806  if (const auto *PartialSpec =
1807  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1808  return *PartialSpec->TemplateArgs;
1809 
1810  return getTemplateArgs();
1811  }
1812 
1813  /// Note that this class template specialization is actually an
1814  /// instantiation of the given class template partial specialization whose
1815  /// template arguments have been deduced.
1817  const TemplateArgumentList *TemplateArgs) {
1818  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
1819  "Already set to a class template partial specialization!");
1820  auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
1821  PS->PartialSpecialization = PartialSpec;
1822  PS->TemplateArgs = TemplateArgs;
1823  SpecializedTemplate = PS;
1824  }
1825 
1826  /// Note that this class template specialization is an instantiation
1827  /// of the given class template.
1828  void setInstantiationOf(ClassTemplateDecl *TemplDecl) {
1829  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
1830  "Previously set to a class template partial specialization!");
1831  SpecializedTemplate = TemplDecl;
1832  }
1833 
1834  /// Sets the type of this specialization as it was written by
1835  /// the user. This will be a class template specialization type.
1837  if (!ExplicitInfo)
1838  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1839  ExplicitInfo->TypeAsWritten = T;
1840  }
1841 
1842  /// Gets the type of this specialization as it was written by
1843  /// the user, if it was so written.
1845  return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
1846  }
1847 
1848  /// Gets the location of the extern keyword, if present.
1850  return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
1851  }
1852 
1853  /// Sets the location of the extern keyword.
1855  if (!ExplicitInfo)
1856  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1857  ExplicitInfo->ExternLoc = Loc;
1858  }
1859 
1860  /// Sets the location of the template keyword.
1862  if (!ExplicitInfo)
1863  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1864  ExplicitInfo->TemplateKeywordLoc = Loc;
1865  }
1866 
1867  /// Gets the location of the template keyword, if present.
1869  return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
1870  }
1871 
1872  SourceRange getSourceRange() const override LLVM_READONLY;
1873 
1874  void Profile(llvm::FoldingSetNodeID &ID) const {
1875  Profile(ID, TemplateArgs->asArray(), getASTContext());
1876  }
1877 
1878  static void
1879  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
1880  ASTContext &Context) {
1881  ID.AddInteger(TemplateArgs.size());
1882  for (const TemplateArgument &TemplateArg : TemplateArgs)
1883  TemplateArg.Profile(ID, Context);
1884  }
1885 
1886  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1887 
1888  static bool classofKind(Kind K) {
1889  return K >= firstClassTemplateSpecialization &&
1890  K <= lastClassTemplateSpecialization;
1891  }
1892 };
1893 
1896  /// The list of template parameters
1897  TemplateParameterList* TemplateParams = nullptr;
1898 
1899  /// The source info for the template arguments as written.
1900  /// FIXME: redundant with TypeAsWritten?
1901  const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
1902 
1903  /// The class template partial specialization from which this
1904  /// class template partial specialization was instantiated.
1905  ///
1906  /// The boolean value will be true to indicate that this class template
1907  /// partial specialization was specialized at this level.
1908  llvm::PointerIntPair<ClassTemplatePartialSpecializationDecl *, 1, bool>
1909  InstantiatedFromMember;
1910 
1912  DeclContext *DC,
1913  SourceLocation StartLoc,
1914  SourceLocation IdLoc,
1915  TemplateParameterList *Params,
1916  ClassTemplateDecl *SpecializedTemplate,
1918  const ASTTemplateArgumentListInfo *ArgsAsWritten,
1920 
1922  : ClassTemplateSpecializationDecl(C, ClassTemplatePartialSpecialization),
1923  InstantiatedFromMember(nullptr, false) {}
1924 
1925  void anchor() override;
1926 
1927 public:
1928  friend class ASTDeclReader;
1929  friend class ASTDeclWriter;
1930 
1932  Create(ASTContext &Context, TagKind TK, DeclContext *DC,
1933  SourceLocation StartLoc, SourceLocation IdLoc,
1934  TemplateParameterList *Params,
1935  ClassTemplateDecl *SpecializedTemplate,
1937  const TemplateArgumentListInfo &ArgInfos,
1938  QualType CanonInjectedType,
1940 
1942  CreateDeserialized(ASTContext &C, unsigned ID);
1943 
1945  return cast<ClassTemplatePartialSpecializationDecl>(
1946  static_cast<ClassTemplateSpecializationDecl *>(
1947  this)->getMostRecentDecl());
1948  }
1949 
1950  /// Get the list of template parameters
1952  return TemplateParams;
1953  }
1954 
1955  /// Get the template arguments as written.
1957  return ArgsAsWritten;
1958  }
1959 
1960  /// Retrieve the member class template partial specialization from
1961  /// which this particular class template partial specialization was
1962  /// instantiated.
1963  ///
1964  /// \code
1965  /// template<typename T>
1966  /// struct Outer {
1967  /// template<typename U> struct Inner;
1968  /// template<typename U> struct Inner<U*> { }; // #1
1969  /// };
1970  ///
1971  /// Outer<float>::Inner<int*> ii;
1972  /// \endcode
1973  ///
1974  /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
1975  /// end up instantiating the partial specialization
1976  /// \c Outer<float>::Inner<U*>, which itself was instantiated from the class
1977  /// template partial specialization \c Outer<T>::Inner<U*>. Given
1978  /// \c Outer<float>::Inner<U*>, this function would return
1979  /// \c Outer<T>::Inner<U*>.
1981  const auto *First =
1982  cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
1983  return First->InstantiatedFromMember.getPointer();
1984  }
1987  return getInstantiatedFromMember();
1988  }
1989 
1992  auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
1993  First->InstantiatedFromMember.setPointer(PartialSpec);
1994  }
1995 
1996  /// Determines whether this class template partial specialization
1997  /// template was a specialization of a member partial specialization.
1998  ///
1999  /// In the following example, the member template partial specialization
2000  /// \c X<int>::Inner<T*> is a member specialization.
2001  ///
2002  /// \code
2003  /// template<typename T>
2004  /// struct X {
2005  /// template<typename U> struct Inner;
2006  /// template<typename U> struct Inner<U*>;
2007  /// };
2008  ///
2009  /// template<> template<typename T>
2010  /// struct X<int>::Inner<T*> { /* ... */ };
2011  /// \endcode
2013  const auto *First =
2014  cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2015  return First->InstantiatedFromMember.getInt();
2016  }
2017 
2018  /// Note that this member template is a specialization.
2020  auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2021  assert(First->InstantiatedFromMember.getPointer() &&
2022  "Only member templates can be member template specializations");
2023  return First->InstantiatedFromMember.setInt(true);
2024  }
2025 
2026  /// Retrieves the injected specialization type for this partial
2027  /// specialization. This is not the same as the type-decl-type for
2028  /// this partial specialization, which is an InjectedClassNameType.
2030  assert(getTypeForDecl() && "partial specialization has no type set!");
2031  return cast<InjectedClassNameType>(getTypeForDecl())
2032  ->getInjectedSpecializationType();
2033  }
2034 
2035  // FIXME: Add Profile support!
2036 
2037  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2038 
2039  static bool classofKind(Kind K) {
2040  return K == ClassTemplatePartialSpecialization;
2041  }
2042 };
2043 
2044 /// Declaration of a class template.
2046 protected:
2047  /// Data that is common to all of the declarations of a given
2048  /// class template.
2049  struct Common : CommonBase {
2050  /// The class template specializations for this class
2051  /// template, including explicit specializations and instantiations.
2052  llvm::FoldingSetVector<ClassTemplateSpecializationDecl> Specializations;
2053 
2054  /// The class template partial specializations for this class
2055  /// template.
2056  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
2058 
2059  /// The injected-class-name type for this class template.
2061 
2062  Common() = default;
2063  };
2064 
2065  /// Retrieve the set of specializations of this class template.
2066  llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
2067  getSpecializations() const;
2068 
2069  /// Retrieve the set of partial specializations of this class
2070  /// template.
2071  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
2072  getPartialSpecializations();
2073 
2077  : RedeclarableTemplateDecl(CTDI, ClassTemplate, C, DC, L, Name, Params,
2078  Decl) {}
2079 
2081  DeclarationName Name, TemplateParameterList *Params,
2082  NamedDecl *Decl)
2083  : ClassTemplateDecl(nullptr, C, DC, L, Name, Params, Decl) {}
2084 
2085  CommonBase *newCommon(ASTContext &C) const override;
2086 
2088  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2089  }
2090 
2091 public:
2092  friend class ASTDeclReader;
2093  friend class ASTDeclWriter;
2094 
2095  /// Load any lazily-loaded specializations from the external source.
2096  void LoadLazySpecializations() const;
2097 
2098  /// Get the underlying class declarations of the template.
2100  return static_cast<CXXRecordDecl *>(TemplatedDecl);
2101  }
2102 
2103  /// Returns whether this template declaration defines the primary
2104  /// class pattern.
2106  return getTemplatedDecl()->isThisDeclarationADefinition();
2107  }
2108 
2109  // FIXME: remove default argument for AssociatedConstraints
2110  /// Create a class template node.
2112  SourceLocation L,
2113  DeclarationName Name,
2114  TemplateParameterList *Params,
2115  NamedDecl *Decl,
2116  Expr *AssociatedConstraints = nullptr);
2117 
2118  /// Create an empty class template node.
2119  static ClassTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2120 
2121  /// Return the specialization with the provided arguments if it exists,
2122  /// otherwise return the insertion point.
2124  findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2125 
2126  /// Insert the specified specialization knowing that it is not already
2127  /// in. InsertPos must be obtained from findSpecialization.
2128  void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos);
2129 
2131  return cast<ClassTemplateDecl>(
2133  }
2135  return cast<ClassTemplateDecl>(
2137  }
2138 
2139  /// Retrieve the previous declaration of this class template, or
2140  /// nullptr if no such declaration exists.
2142  return cast_or_null<ClassTemplateDecl>(
2143  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2144  }
2146  return cast_or_null<ClassTemplateDecl>(
2147  static_cast<const RedeclarableTemplateDecl *>(
2148  this)->getPreviousDecl());
2149  }
2150 
2152  return cast<ClassTemplateDecl>(
2153  static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
2154  }
2156  return const_cast<ClassTemplateDecl*>(this)->getMostRecentDecl();
2157  }
2158 
2160  return cast_or_null<ClassTemplateDecl>(
2162  }
2163 
2164  /// Return the partial specialization with the provided arguments if it
2165  /// exists, otherwise return the insertion point.
2167  findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2168 
2169  /// Insert the specified partial specialization knowing that it is not
2170  /// already in. InsertPos must be obtained from findPartialSpecialization.
2171  void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D,
2172  void *InsertPos);
2173 
2174  /// Retrieve the partial specializations as an ordered list.
2175  void getPartialSpecializations(
2177 
2178  /// Find a class template partial specialization with the given
2179  /// type T.
2180  ///
2181  /// \param T a dependent type that names a specialization of this class
2182  /// template.
2183  ///
2184  /// \returns the class template partial specialization that exactly matches
2185  /// the type \p T, or nullptr if no such partial specialization exists.
2186  ClassTemplatePartialSpecializationDecl *findPartialSpecialization(QualType T);
2187 
2188  /// Find a class template partial specialization which was instantiated
2189  /// from the given member partial specialization.
2190  ///
2191  /// \param D a member class template partial specialization.
2192  ///
2193  /// \returns the class template partial specialization which was instantiated
2194  /// from the given member partial specialization, or nullptr if no such
2195  /// partial specialization exists.
2197  findPartialSpecInstantiatedFromMember(
2199 
2200  /// Retrieve the template specialization type of the
2201  /// injected-class-name for this class template.
2202  ///
2203  /// The injected-class-name for a class template \c X is \c
2204  /// X<template-args>, where \c template-args is formed from the
2205  /// template arguments that correspond to the template parameters of
2206  /// \c X. For example:
2207  ///
2208  /// \code
2209  /// template<typename T, int N>
2210  /// struct array {
2211  /// typedef array this_type; // "array" is equivalent to "array<T, N>"
2212  /// };
2213  /// \endcode
2214  QualType getInjectedClassNameSpecialization();
2215 
2217  using spec_range = llvm::iterator_range<spec_iterator>;
2218 
2220  return spec_range(spec_begin(), spec_end());
2221  }
2222 
2224  return makeSpecIterator(getSpecializations(), false);
2225  }
2226 
2228  return makeSpecIterator(getSpecializations(), true);
2229  }
2230 
2231  // Implement isa/cast/dyncast support
2232  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2233  static bool classofKind(Kind K) { return K == ClassTemplate; }
2234 };
2235 
2236 /// Declaration of a friend template.
2237 ///
2238 /// For example:
2239 /// \code
2240 /// template <typename T> class A {
2241 /// friend class MyVector<T>; // not a friend template
2242 /// template <typename U> friend class B; // not a friend template
2243 /// template <typename U> friend class Foo<T>::Nested; // friend template
2244 /// };
2245 /// \endcode
2246 ///
2247 /// \note This class is not currently in use. All of the above
2248 /// will yield a FriendDecl, not a FriendTemplateDecl.
2249 class FriendTemplateDecl : public Decl {
2250  virtual void anchor();
2251 
2252 public:
2253  using FriendUnion = llvm::PointerUnion<NamedDecl *,TypeSourceInfo *>;
2254 
2255 private:
2256  // The number of template parameters; always non-zero.
2257  unsigned NumParams = 0;
2258 
2259  // The parameter list.
2260  TemplateParameterList **Params = nullptr;
2261 
2262  // The declaration that's a friend of this class.
2263  FriendUnion Friend;
2264 
2265  // Location of the 'friend' specifier.
2266  SourceLocation FriendLoc;
2267 
2270  FriendUnion Friend, SourceLocation FriendLoc)
2271  : Decl(Decl::FriendTemplate, DC, Loc), NumParams(Params.size()),
2272  Params(Params.data()), Friend(Friend), FriendLoc(FriendLoc) {}
2273 
2274  FriendTemplateDecl(EmptyShell Empty) : Decl(Decl::FriendTemplate, Empty) {}
2275 
2276 public:
2277  friend class ASTDeclReader;
2278 
2279  static FriendTemplateDecl *
2280  Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc,
2282  SourceLocation FriendLoc);
2283 
2284  static FriendTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2285 
2286  /// If this friend declaration names a templated type (or
2287  /// a dependent member type of a templated type), return that
2288  /// type; otherwise return null.
2290  return Friend.dyn_cast<TypeSourceInfo*>();
2291  }
2292 
2293  /// If this friend declaration names a templated function (or
2294  /// a member function of a templated type), return that type;
2295  /// otherwise return null.
2297  return Friend.dyn_cast<NamedDecl*>();
2298  }
2299 
2300  /// Retrieves the location of the 'friend' keyword.
2302  return FriendLoc;
2303  }
2304 
2306  assert(i <= NumParams);
2307  return Params[i];
2308  }
2309 
2310  unsigned getNumTemplateParameters() const {
2311  return NumParams;
2312  }
2313 
2314  // Implement isa/cast/dyncast/etc.
2315  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2316  static bool classofKind(Kind K) { return K == Decl::FriendTemplate; }
2317 };
2318 
2319 /// Declaration of an alias template.
2320 ///
2321 /// For example:
2322 /// \code
2323 /// template <typename T> using V = std::map<T*, int, MyCompare<T>>;
2324 /// \endcode
2326 protected:
2328 
2330  DeclarationName Name, TemplateParameterList *Params,
2331  NamedDecl *Decl)
2332  : RedeclarableTemplateDecl(TypeAliasTemplate, C, DC, L, Name, Params,
2333  Decl) {}
2334 
2335  CommonBase *newCommon(ASTContext &C) const override;
2336 
2338  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2339  }
2340 
2341 public:
2342  friend class ASTDeclReader;
2343  friend class ASTDeclWriter;
2344 
2345  /// Get the underlying function declaration of the template.
2347  return static_cast<TypeAliasDecl *>(TemplatedDecl);
2348  }
2349 
2350 
2352  return cast<TypeAliasTemplateDecl>(
2354  }
2356  return cast<TypeAliasTemplateDecl>(
2358  }
2359 
2360  /// Retrieve the previous declaration of this function template, or
2361  /// nullptr if no such declaration exists.
2363  return cast_or_null<TypeAliasTemplateDecl>(
2364  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2365  }
2367  return cast_or_null<TypeAliasTemplateDecl>(
2368  static_cast<const RedeclarableTemplateDecl *>(
2369  this)->getPreviousDecl());
2370  }
2371 
2373  return cast_or_null<TypeAliasTemplateDecl>(
2375  }
2376 
2377  /// Create a function template node.
2379  SourceLocation L,
2380  DeclarationName Name,
2381  TemplateParameterList *Params,
2382  NamedDecl *Decl);
2383 
2384  /// Create an empty alias template node.
2385  static TypeAliasTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2386 
2387  // Implement isa/cast/dyncast support
2388  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2389  static bool classofKind(Kind K) { return K == TypeAliasTemplate; }
2390 };
2391 
2392 /// Declaration of a function specialization at template class scope.
2393 ///
2394 /// This is a non-standard extension needed to support MSVC.
2395 ///
2396 /// For example:
2397 /// \code
2398 /// template <class T>
2399 /// class A {
2400 /// template <class U> void foo(U a) { }
2401 /// template<> void foo(int a) { }
2402 /// }
2403 /// \endcode
2404 ///
2405 /// "template<> foo(int a)" will be saved in Specialization as a normal
2406 /// CXXMethodDecl. Then during an instantiation of class A, it will be
2407 /// transformed into an actual function specialization.
2409  CXXMethodDecl *Specialization;
2410  bool HasExplicitTemplateArgs;
2411  TemplateArgumentListInfo TemplateArgs;
2412 
2414  CXXMethodDecl *FD, bool Args,
2415  TemplateArgumentListInfo TemplArgs)
2416  : Decl(Decl::ClassScopeFunctionSpecialization, DC, Loc),
2417  Specialization(FD), HasExplicitTemplateArgs(Args),
2418  TemplateArgs(std::move(TemplArgs)) {}
2419 
2421  : Decl(Decl::ClassScopeFunctionSpecialization, Empty) {}
2422 
2423  virtual void anchor();
2424 
2425 public:
2426  friend class ASTDeclReader;
2427  friend class ASTDeclWriter;
2428 
2429  CXXMethodDecl *getSpecialization() const { return Specialization; }
2430  bool hasExplicitTemplateArgs() const { return HasExplicitTemplateArgs; }
2431  const TemplateArgumentListInfo& templateArgs() const { return TemplateArgs; }
2432 
2434  DeclContext *DC,
2435  SourceLocation Loc,
2436  CXXMethodDecl *FD,
2437  bool HasExplicitTemplateArgs,
2438  TemplateArgumentListInfo TemplateArgs) {
2439  return new (C, DC) ClassScopeFunctionSpecializationDecl(
2440  DC, Loc, FD, HasExplicitTemplateArgs, std::move(TemplateArgs));
2441  }
2442 
2444  CreateDeserialized(ASTContext &Context, unsigned ID);
2445 
2446  // Implement isa/cast/dyncast/etc.
2447  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2448 
2449  static bool classofKind(Kind K) {
2450  return K == Decl::ClassScopeFunctionSpecialization;
2451  }
2452 };
2453 
2454 /// Implementation of inline functions that require the template declarations
2455 inline AnyFunctionDecl::AnyFunctionDecl(FunctionTemplateDecl *FTD)
2456  : Function(FTD) {}
2457 
2458 /// Represents a variable template specialization, which refers to
2459 /// a variable template with a given set of template arguments.
2460 ///
2461 /// Variable template specializations represent both explicit
2462 /// specializations of variable templates, as in the example below, and
2463 /// implicit instantiations of variable templates.
2464 ///
2465 /// \code
2466 /// template<typename T> constexpr T pi = T(3.1415926535897932385);
2467 ///
2468 /// template<>
2469 /// constexpr float pi<float>; // variable template specialization pi<float>
2470 /// \endcode
2472  public llvm::FoldingSetNode {
2473 
2474  /// Structure that stores information about a variable template
2475  /// specialization that was instantiated from a variable template partial
2476  /// specialization.
2477  struct SpecializedPartialSpecialization {
2478  /// The variable template partial specialization from which this
2479  /// variable template specialization was instantiated.
2480  VarTemplatePartialSpecializationDecl *PartialSpecialization;
2481 
2482  /// The template argument list deduced for the variable template
2483  /// partial specialization itself.
2484  const TemplateArgumentList *TemplateArgs;
2485  };
2486 
2487  /// The template that this specialization specializes.
2488  llvm::PointerUnion<VarTemplateDecl *, SpecializedPartialSpecialization *>
2489  SpecializedTemplate;
2490 
2491  /// Further info for explicit template specialization/instantiation.
2492  struct ExplicitSpecializationInfo {
2493  /// The type-as-written.
2494  TypeSourceInfo *TypeAsWritten = nullptr;
2495 
2496  /// The location of the extern keyword.
2497  SourceLocation ExternLoc;
2498 
2499  /// The location of the template keyword.
2500  SourceLocation TemplateKeywordLoc;
2501 
2502  ExplicitSpecializationInfo() = default;
2503  };
2504 
2505  /// Further info for explicit template specialization/instantiation.
2506  /// Does not apply to implicit specializations.
2507  ExplicitSpecializationInfo *ExplicitInfo = nullptr;
2508 
2509  /// The template arguments used to describe this specialization.
2510  const TemplateArgumentList *TemplateArgs;
2511  TemplateArgumentListInfo TemplateArgsInfo;
2512 
2513  /// The point where this template was instantiated (if any).
2514  SourceLocation PointOfInstantiation;
2515 
2516  /// The kind of specialization this declaration refers to.
2517  /// Really a value of type TemplateSpecializationKind.
2518  unsigned SpecializationKind : 3;
2519 
2520  /// Whether this declaration is a complete definition of the
2521  /// variable template specialization. We can't otherwise tell apart
2522  /// an instantiated declaration from an instantiated definition with
2523  /// no initializer.
2524  unsigned IsCompleteDefinition : 1;
2525 
2526 protected:
2528  SourceLocation StartLoc, SourceLocation IdLoc,
2529  VarTemplateDecl *SpecializedTemplate,
2530  QualType T, TypeSourceInfo *TInfo,
2531  StorageClass S,
2533 
2534  explicit VarTemplateSpecializationDecl(Kind DK, ASTContext &Context);
2535 
2536 public:
2537  friend class ASTDeclReader;
2538  friend class ASTDeclWriter;
2539  friend class VarDecl;
2540 
2542  Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2543  SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
2544  TypeSourceInfo *TInfo, StorageClass S,
2546  static VarTemplateSpecializationDecl *CreateDeserialized(ASTContext &C,
2547  unsigned ID);
2548 
2549  void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
2550  bool Qualified) const override;
2551 
2553  VarDecl *Recent = static_cast<VarDecl *>(this)->getMostRecentDecl();
2554  return cast<VarTemplateSpecializationDecl>(Recent);
2555  }
2556 
2557  /// Retrieve the template that this specialization specializes.
2558  VarTemplateDecl *getSpecializedTemplate() const;
2559 
2560  /// Retrieve the template arguments of the variable template
2561  /// specialization.
2562  const TemplateArgumentList &getTemplateArgs() const { return *TemplateArgs; }
2563 
2564  // TODO: Always set this when creating the new specialization?
2565  void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo);
2566 
2568  return TemplateArgsInfo;
2569  }
2570 
2571  /// Determine the kind of specialization that this
2572  /// declaration represents.
2574  return static_cast<TemplateSpecializationKind>(SpecializationKind);
2575  }
2576 
2578  return getSpecializationKind() == TSK_ExplicitSpecialization;
2579  }
2580 
2581  /// True if this declaration is an explicit specialization,
2582  /// explicit instantiation declaration, or explicit instantiation
2583  /// definition.
2587  }
2588 
2590  SpecializationKind = TSK;
2591  }
2592 
2593  /// Get the point of instantiation (if any), or null if none.
2595  return PointOfInstantiation;
2596  }
2597 
2599  assert(Loc.isValid() && "point of instantiation must be valid!");
2600  PointOfInstantiation = Loc;
2601  }
2602 
2603  void setCompleteDefinition() { IsCompleteDefinition = true; }
2604 
2605  /// If this variable template specialization is an instantiation of
2606  /// a template (rather than an explicit specialization), return the
2607  /// variable template or variable template partial specialization from which
2608  /// it was instantiated.
2609  llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2611  if (!isTemplateInstantiation(getSpecializationKind()))
2612  return llvm::PointerUnion<VarTemplateDecl *,
2614 
2615  return getSpecializedTemplateOrPartial();
2616  }
2617 
2618  /// Retrieve the variable template or variable template partial
2619  /// specialization which was specialized by this.
2620  llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2622  if (const auto *PartialSpec =
2623  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2624  return PartialSpec->PartialSpecialization;
2625 
2626  return SpecializedTemplate.get<VarTemplateDecl *>();
2627  }
2628 
2629  /// Retrieve the set of template arguments that should be used
2630  /// to instantiate the initializer of the variable template or variable
2631  /// template partial specialization from which this variable template
2632  /// specialization was instantiated.
2633  ///
2634  /// \returns For a variable template specialization instantiated from the
2635  /// primary template, this function will return the same template arguments
2636  /// as getTemplateArgs(). For a variable template specialization instantiated
2637  /// from a variable template partial specialization, this function will the
2638  /// return deduced template arguments for the variable template partial
2639  /// specialization itself.
2641  if (const auto *PartialSpec =
2642  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2643  return *PartialSpec->TemplateArgs;
2644 
2645  return getTemplateArgs();
2646  }
2647 
2648  /// Note that this variable template specialization is actually an
2649  /// instantiation of the given variable template partial specialization whose
2650  /// template arguments have been deduced.
2652  const TemplateArgumentList *TemplateArgs) {
2653  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
2654  "Already set to a variable template partial specialization!");
2655  auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
2656  PS->PartialSpecialization = PartialSpec;
2657  PS->TemplateArgs = TemplateArgs;
2658  SpecializedTemplate = PS;
2659  }
2660 
2661  /// Note that this variable template specialization is an instantiation
2662  /// of the given variable template.
2664  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
2665  "Previously set to a variable template partial specialization!");
2666  SpecializedTemplate = TemplDecl;
2667  }
2668 
2669  /// Sets the type of this specialization as it was written by
2670  /// the user.
2672  if (!ExplicitInfo)
2673  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2674  ExplicitInfo->TypeAsWritten = T;
2675  }
2676 
2677  /// Gets the type of this specialization as it was written by
2678  /// the user, if it was so written.
2680  return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
2681  }
2682 
2683  /// Gets the location of the extern keyword, if present.
2685  return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
2686  }
2687 
2688  /// Sets the location of the extern keyword.
2690  if (!ExplicitInfo)
2691  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2692  ExplicitInfo->ExternLoc = Loc;
2693  }
2694 
2695  /// Sets the location of the template keyword.
2697  if (!ExplicitInfo)
2698  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2699  ExplicitInfo->TemplateKeywordLoc = Loc;
2700  }
2701 
2702  /// Gets the location of the template keyword, if present.
2704  return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
2705  }
2706 
2707  void Profile(llvm::FoldingSetNodeID &ID) const {
2708  Profile(ID, TemplateArgs->asArray(), getASTContext());
2709  }
2710 
2711  static void Profile(llvm::FoldingSetNodeID &ID,
2712  ArrayRef<TemplateArgument> TemplateArgs,
2713  ASTContext &Context) {
2714  ID.AddInteger(TemplateArgs.size());
2715  for (const TemplateArgument &TemplateArg : TemplateArgs)
2716  TemplateArg.Profile(ID, Context);
2717  }
2718 
2719  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2720 
2721  static bool classofKind(Kind K) {
2722  return K >= firstVarTemplateSpecialization &&
2723  K <= lastVarTemplateSpecialization;
2724  }
2725 };
2726 
2729  /// The list of template parameters
2730  TemplateParameterList *TemplateParams = nullptr;
2731 
2732  /// The source info for the template arguments as written.
2733  /// FIXME: redundant with TypeAsWritten?
2734  const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
2735 
2736  /// The variable template partial specialization from which this
2737  /// variable template partial specialization was instantiated.
2738  ///
2739  /// The boolean value will be true to indicate that this variable template
2740  /// partial specialization was specialized at this level.
2741  llvm::PointerIntPair<VarTemplatePartialSpecializationDecl *, 1, bool>
2742  InstantiatedFromMember;
2743 
2745  ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2746  SourceLocation IdLoc, TemplateParameterList *Params,
2747  VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
2749  const ASTTemplateArgumentListInfo *ArgInfos);
2750 
2752  : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization,
2753  Context),
2754  InstantiatedFromMember(nullptr, false) {}
2755 
2756  void anchor() override;
2757 
2758 public:
2759  friend class ASTDeclReader;
2760  friend class ASTDeclWriter;
2761 
2763  Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2764  SourceLocation IdLoc, TemplateParameterList *Params,
2765  VarTemplateDecl *SpecializedTemplate, QualType T,
2767  const TemplateArgumentListInfo &ArgInfos);
2768 
2769  static VarTemplatePartialSpecializationDecl *CreateDeserialized(ASTContext &C,
2770  unsigned ID);
2771 
2773  return cast<VarTemplatePartialSpecializationDecl>(
2774  static_cast<VarTemplateSpecializationDecl *>(
2775  this)->getMostRecentDecl());
2776  }
2777 
2778  /// Get the list of template parameters
2780  return TemplateParams;
2781  }
2782 
2783  /// Get the template arguments as written.
2785  return ArgsAsWritten;
2786  }
2787 
2788  /// Retrieve the member variable template partial specialization from
2789  /// which this particular variable template partial specialization was
2790  /// instantiated.
2791  ///
2792  /// \code
2793  /// template<typename T>
2794  /// struct Outer {
2795  /// template<typename U> U Inner;
2796  /// template<typename U> U* Inner<U*> = (U*)(0); // #1
2797  /// };
2798  ///
2799  /// template int* Outer<float>::Inner<int*>;
2800  /// \endcode
2801  ///
2802  /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
2803  /// end up instantiating the partial specialization
2804  /// \c Outer<float>::Inner<U*>, which itself was instantiated from the
2805  /// variable template partial specialization \c Outer<T>::Inner<U*>. Given
2806  /// \c Outer<float>::Inner<U*>, this function would return
2807  /// \c Outer<T>::Inner<U*>.
2809  const auto *First =
2810  cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2811  return First->InstantiatedFromMember.getPointer();
2812  }
2813 
2814  void
2816  auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2817  First->InstantiatedFromMember.setPointer(PartialSpec);
2818  }
2819 
2820  /// Determines whether this variable template partial specialization
2821  /// was a specialization of a member partial specialization.
2822  ///
2823  /// In the following example, the member template partial specialization
2824  /// \c X<int>::Inner<T*> is a member specialization.
2825  ///
2826  /// \code
2827  /// template<typename T>
2828  /// struct X {
2829  /// template<typename U> U Inner;
2830  /// template<typename U> U* Inner<U*> = (U*)(0);
2831  /// };
2832  ///
2833  /// template<> template<typename T>
2834  /// U* X<int>::Inner<T*> = (T*)(0) + 1;
2835  /// \endcode
2837  const auto *First =
2838  cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2839  return First->InstantiatedFromMember.getInt();
2840  }
2841 
2842  /// Note that this member template is a specialization.
2844  auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2845  assert(First->InstantiatedFromMember.getPointer() &&
2846  "Only member templates can be member template specializations");
2847  return First->InstantiatedFromMember.setInt(true);
2848  }
2849 
2850  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2851 
2852  static bool classofKind(Kind K) {
2853  return K == VarTemplatePartialSpecialization;
2854  }
2855 };
2856 
2857 /// Declaration of a variable template.
2859 protected:
2860  /// Data that is common to all of the declarations of a given
2861  /// variable template.
2862  struct Common : CommonBase {
2863  /// The variable template specializations for this variable
2864  /// template, including explicit specializations and instantiations.
2865  llvm::FoldingSetVector<VarTemplateSpecializationDecl> Specializations;
2866 
2867  /// The variable template partial specializations for this variable
2868  /// template.
2869  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>
2871 
2872  Common() = default;
2873  };
2874 
2875  /// Retrieve the set of specializations of this variable template.
2876  llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
2877  getSpecializations() const;
2878 
2879  /// Retrieve the set of partial specializations of this class
2880  /// template.
2881  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
2882  getPartialSpecializations();
2883 
2885  DeclarationName Name, TemplateParameterList *Params,
2886  NamedDecl *Decl)
2887  : RedeclarableTemplateDecl(VarTemplate, C, DC, L, Name, Params, Decl) {}
2888 
2889  CommonBase *newCommon(ASTContext &C) const override;
2890 
2892  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2893  }
2894 
2895 public:
2896  friend class ASTDeclReader;
2897  friend class ASTDeclWriter;
2898 
2899  /// Load any lazily-loaded specializations from the external source.
2900  void LoadLazySpecializations() const;
2901 
2902  /// Get the underlying variable declarations of the template.
2904  return static_cast<VarDecl *>(TemplatedDecl);
2905  }
2906 
2907  /// Returns whether this template declaration defines the primary
2908  /// variable pattern.
2910  return getTemplatedDecl()->isThisDeclarationADefinition();
2911  }
2912 
2914 
2915  /// Create a variable template node.
2916  static VarTemplateDecl *Create(ASTContext &C, DeclContext *DC,
2918  TemplateParameterList *Params,
2919  VarDecl *Decl);
2920 
2921  /// Create an empty variable template node.
2922  static VarTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2923 
2924  /// Return the specialization with the provided arguments if it exists,
2925  /// otherwise return the insertion point.
2927  findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2928 
2929  /// Insert the specified specialization knowing that it is not already
2930  /// in. InsertPos must be obtained from findSpecialization.
2931  void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos);
2932 
2934  return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
2935  }
2937  return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
2938  }
2939 
2940  /// Retrieve the previous declaration of this variable template, or
2941  /// nullptr if no such declaration exists.
2943  return cast_or_null<VarTemplateDecl>(
2944  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2945  }
2947  return cast_or_null<VarTemplateDecl>(
2948  static_cast<const RedeclarableTemplateDecl *>(
2949  this)->getPreviousDecl());
2950  }
2951 
2953  return cast<VarTemplateDecl>(
2954  static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
2955  }
2957  return const_cast<VarTemplateDecl *>(this)->getMostRecentDecl();
2958  }
2959 
2961  return cast_or_null<VarTemplateDecl>(
2963  }
2964 
2965  /// Return the partial specialization with the provided arguments if it
2966  /// exists, otherwise return the insertion point.
2968  findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2969 
2970  /// Insert the specified partial specialization knowing that it is not
2971  /// already in. InsertPos must be obtained from findPartialSpecialization.
2972  void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D,
2973  void *InsertPos);
2974 
2975  /// Retrieve the partial specializations as an ordered list.
2976  void getPartialSpecializations(
2978 
2979  /// Find a variable template partial specialization which was
2980  /// instantiated
2981  /// from the given member partial specialization.
2982  ///
2983  /// \param D a member variable template partial specialization.
2984  ///
2985  /// \returns the variable template partial specialization which was
2986  /// instantiated
2987  /// from the given member partial specialization, or nullptr if no such
2988  /// partial specialization exists.
2989  VarTemplatePartialSpecializationDecl *findPartialSpecInstantiatedFromMember(
2991 
2993  using spec_range = llvm::iterator_range<spec_iterator>;
2994 
2996  return spec_range(spec_begin(), spec_end());
2997  }
2998 
3000  return makeSpecIterator(getSpecializations(), false);
3001  }
3002 
3004  return makeSpecIterator(getSpecializations(), true);
3005  }
3006 
3007  // Implement isa/cast/dyncast support
3008  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3009  static bool classofKind(Kind K) { return K == VarTemplate; }
3010 };
3011 
3013  if (auto *PD = P.dyn_cast<TemplateTypeParmDecl *>())
3014  return PD;
3015  if (auto *PD = P.dyn_cast<NonTypeTemplateParmDecl *>())
3016  return PD;
3017  return P.get<TemplateTemplateParmDecl *>();
3018 }
3019 
3021  auto *TD = dyn_cast<TemplateDecl>(D);
3022  return TD && (isa<ClassTemplateDecl>(TD) ||
3023  isa<ClassTemplatePartialSpecializationDecl>(TD) ||
3024  isa<TypeAliasTemplateDecl>(TD) ||
3025  isa<TemplateTemplateParmDecl>(TD))
3026  ? TD
3027  : nullptr;
3028 }
3029 
3030 } // namespace clang
3031 
3032 #endif // LLVM_CLANG_AST_DECLTEMPLATE_H
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const TemplateArgumentLoc & getTemplateArg(unsigned I) const
Returns the nth template argument.
Definition: DeclTemplate.h:722
void setInstantiationOf(ClassTemplateDecl *TemplDecl)
Note that this class template specialization is an instantiation of the given class template...
static const Decl * getCanonicalDecl(const Decl *D)
spec_iterator spec_begin() const
Represents a function declaration or definition.
Definition: Decl.h:1714
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
Definition: DeclTemplate.h:570
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Definition: DeclTemplate.h:550
unsigned getNumTemplateArgs() const
Returns the number of explicit template arguments that were given.
Definition: DeclTemplate.h:719
RedeclarableTemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK, ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Definition: DeclTemplate.h:835
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this function template specialization.
Definition: DeclTemplate.h:581
llvm::iterator_range< redecl_iterator > redecl_range
Definition: DeclBase.h:942
TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params)
Definition: DeclTemplate.h:413
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration, or explicit instantiation definition.
A (possibly-)qualified type.
Definition: Type.h:655
FunctionDecl * Function
The function template specialization that this structure describes.
Definition: DeclTemplate.h:530
RedeclarableTemplateDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Definition: DeclTemplate.h:842
bool isThisDeclarationADefinition() const
Returns whether this template declaration defines the primary class pattern.
void setDefaultArgument(TypeSourceInfo *DefArg)
Set the default argument for this template parameter.
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
llvm::PointerUnion3< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
Definition: DeclTemplate.h:62
static ClassTemplateDecl * getDefinition(ClassTemplateDecl *D)
VarTemplateSpecializationDecl * getMostRecentDecl()
ArrayRef< const NamedDecl * > asArray() const
Definition: DeclTemplate.h:129
bool isMemberSpecialization()
Determines whether this class template partial specialization template was a specialization of a memb...
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
FixedSizeTemplateParameterListStorage(SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Definition: DeclTemplate.h:197
C Language Family Type Representation.
static ClassScopeFunctionSpecializationDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, CXXMethodDecl *FD, bool HasExplicitTemplateArgs, TemplateArgumentListInfo TemplateArgs)
spec_range specializations() const
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:270
unsigned getNumExpansionTypes() const
Retrieves the number of expansion types in an expanded parameter pack.
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
spec_iterator spec_end() const
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
TypeAliasTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
ArrayRef< NamedDecl * > asArray()
Definition: DeclTemplate.h:126
void setInheritedDefaultArgument(const ASTContext &C, NonTypeTemplateParmDecl *Parm)
StringRef P
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:453
VarTemplatePartialSpecializationDecl * getMostRecentDecl()
const TypeAliasTemplateDecl * getPreviousDecl() const
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
void removeDefaultArgument()
Removes the default argument of this template parameter.
Declaration of a variable template.
size_t numTrailingObjects(OverloadToken< Expr *>) const
Definition: DeclTemplate.h:97
void setSpecializationKind(TemplateSpecializationKind TSK)
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:133
static bool classofKind(Kind K)
A container of type source information.
Definition: Decl.h:86
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
constexpr XRayInstrMask Function
Definition: XRayInstr.h:39
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument&#39;s source information, if any.
const Expr * getRequiresClause() const
Get the constraint-expression from the associated requires-clause (if any)
Definition: DeclTemplate.h:440
static bool classofKind(Kind K)
const ClassTemplateDecl * getCanonicalDecl() const
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
unsigned getDepth() const
Get the nesting depth of the template parameter.
static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef< TemplateArgument > TemplateArgs, ASTContext &Context)
TemplateParameterList * getExpansionTemplateParameters(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
Represents a variable declaration or definition.
Definition: Decl.h:812
Declaration of a redeclarable template.
Definition: DeclTemplate.h:737
TemplateParameterList * getTemplateParameters() const
Definition: DeclTemplate.h:376
NamedDecl *const * const_iterator
Iterates through the template parameters in this list.
Definition: DeclTemplate.h:117
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:553
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
llvm::PointerUnion< TemplateParameterList *, ConstrainedTemplateDeclInfo * > TemplateParams
The template parameter list and optional requires-clause associated with this declaration; alternativ...
Definition: DeclTemplate.h:476
static bool classofKind(Kind K)
const TemplateArgumentLoc * getTemplateArgs() const
Returns the explicit template arguments that were given.
Definition: DeclTemplate.h:714
Represents a variable template specialization, which refers to a variable template with a given set o...
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
SourceLocation getLAngleLoc() const
Definition: DeclTemplate.h:173
TemplateParmPosition(unsigned D, unsigned P)
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:595
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:630
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: DeclTemplate.h:462
Provides information about a dependent function-template specialization declaration.
Definition: DeclTemplate.h:672
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
static bool classof(const Decl *D)
const VarTemplateDecl * getCanonicalDecl() const
static bool classof(const Decl *D)
llvm::iterator_range< spec_iterator > spec_range
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
bool isTemplateExplicitInstantiationOrSpecialization(TemplateSpecializationKind Kind)
True if this template specialization kind is an explicit specialization, explicit instantiation decla...
Definition: Specifiers.h:177
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:85
TemplateArgumentList(const TemplateArgumentList *Other)
Produces a shallow copy of the given template argument list.
Definition: DeclTemplate.h:251
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:150
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
void setInstantiationOf(VarTemplateDecl *TemplDecl)
Note that this variable template specialization is an instantiation of the given variable template...
Defines the position of a template parameter within a template parameter list.
const DefArgStorage & getDefaultArgStorage() const
void * allocateDefaultArgStorageChain(const ASTContext &C)
Definition: Format.h:2031
ClassTemplateSpecializationDecl * getMostRecentDecl()
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
static bool classofKind(Kind K)
Definition: DeclTemplate.h:458
void Profile(llvm::FoldingSetNodeID &ID)
Definition: DeclTemplate.h:591
Stores the template parameter list and associated constraints for TemplateDecl objects that track ass...
Definition: DeclTemplate.h:370
Declaration of a function specialization at template class scope.
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:172
TypeSourceInfo * getFriendType() const
If this friend declaration names a templated type (or a dependent member type of a templated type)...
llvm::iterator_range< spec_iterator > spec_range
TypeAliasTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
void setDefaultArgument(Expr *DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
static bool classof(const Decl *D)
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:508
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
const TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
Definition: DeclTemplate.h:540
FunctionTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Common * getCommonPtr() const
Definition: DeclTemplate.h:999
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization. ...
const RedeclarableTemplateDecl * getCanonicalDecl() const
Definition: DeclTemplate.h:857
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
void set(ArgType Arg)
Set the default argument.
Definition: DeclTemplate.h:342
bool isInherited() const
Determine whether the default argument for this parameter was inherited from a previous declaration o...
Definition: DeclTemplate.h:318
A convenient class for passing around template argument information.
Definition: TemplateBase.h:546
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
static bool classof(const Decl *D)
Definition: DeclTemplate.h:456
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Definition: DeclTemplate.h:879
static bool classofKind(Kind K)
static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef< TemplateArgument > TemplateArgs, ASTContext &Context)
Definition: DeclTemplate.h:597
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
Represents a declaration of a type.
Definition: Decl.h:2820
A set of unresolved declarations.
Definition: UnresolvedSet.h:61
RedeclarableTemplateDecl * getInstantiatedFromMemberTemplate() const
Retrieve the member template from which this template was instantiated, or nullptr if this template w...
Definition: DeclTemplate.h:926
void setInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *PartialSpec)
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this class template specialization is actually an instantiation of the given class template...
const TemplateArgument & operator[](unsigned Idx) const
Retrieve the template argument at a given index.
Definition: DeclTemplate.h:261
void setSpecializationKind(TemplateSpecializationKind TSK)
spec_range specializations() const
ArgType get() const
Get the default argument&#39;s value.
Definition: DeclTemplate.h:322
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMemberTemplate() const
TemplateParameterList * getTemplateParameterList(unsigned i) const
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
static bool classofKind(Kind K)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
QualType getExpansionType(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
SourceLocation PointOfInstantiation
The point at which this function template specialization was first instantiated.
Definition: DeclTemplate.h:547
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
Definition: DeclTemplate.h:273
const TypeAliasTemplateDecl * getCanonicalDecl() const
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
ClassTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > Specializations
The function template specializations for this function template, including explicit specializations ...
Definition: DeclTemplate.h:977
const VarTemplateDecl * getMostRecentDecl() const
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:277
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
Definition: DeclBase.h:102
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:2984
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:688
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
void clear()
Remove the default argument, even if it was inherited.
Definition: DeclTemplate.h:359
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > PartialSpecializations
The class template partial specializations for this class template.
spec_range specializations() const
const NamedDecl * getParam(unsigned Idx) const
Definition: DeclTemplate.h:137
const FunctionTemplateDecl * getMostRecentDecl() const
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
static bool classof(const Decl *D)
QualType getInjectedSpecializationType() const
Retrieves the injected specialization type for this partial specialization.
llvm::iterator_range< spec_iterator > spec_range
Expr - This represents one expression.
Definition: Expr.h:106
CommonBase * getCommonPtr() const
Retrieves the "common" pointer shared by all (re-)declarations of the same template.
void setAssociatedConstraints(Expr *AC)
Definition: DeclTemplate.h:487
SourceLocation End
const VarTemplateDecl * getPreviousDecl() const
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > PartialSpecializations
The variable template partial specializations for this variable template.
Expr * getAssociatedConstraints() const
Definition: DeclTemplate.h:445
void setInherited(const ASTContext &C, ParmDecl *InheritedFrom)
Set that the default argument was inherited from another parameter.
Definition: DeclTemplate.h:348
int Id
Definition: ASTDiff.cpp:191
static bool classof(const Decl *D)
MemberSpecializationInfo(NamedDecl *IF, TemplateSpecializationKind TSK, SourceLocation POI=SourceLocation())
Definition: DeclTemplate.h:618
llvm::PointerIntPair< FunctionTemplateDecl *, 2 > Template
The function template from which this function template specialization was generated.
Definition: DeclTemplate.h:536
llvm::PointerUnion< NamedDecl *, TypeSourceInfo * > FriendUnion
static bool classof(const Decl *D)
#define bool
Definition: stdbool.h:31
spec_iterator spec_end() const
Data that is common to all of the declarations of a given variable template.
spec_iterator spec_end() const
void setMemberSpecialization()
Note that this member template is a specialization.
Definition: DeclTemplate.h:884
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:264
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the class template or class template partial specialization which was specialized by this...
spec_iterator spec_begin() const
int Depth
Definition: ASTDiff.cpp:191
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
static bool classof(const Decl *D)
StorageClass
Storage classes.
Definition: Specifiers.h:206
Declaration of an alias template.
FunctionTemplateDecl * getTemplate(unsigned I) const
Returns the i&#39;th template candidate.
Definition: DeclTemplate.h:708
static ArrayRef< TemplateArgument > getTemplateArgs(EntryType *D)
Definition: DeclTemplate.h:762
void setPointOfInstantiation(SourceLocation Loc)
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
SourceLocation getEnd() const
unsigned getNumExpansionTemplateParameters() const
Retrieves the number of expansion template parameters in an expanded parameter pack.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
BuiltinTemplateKind getBuiltinTemplateKind() const
Data that is common to all of the declarations of a given class template.
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:170
static bool classofKind(Kind K)
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
static DeclType * getDecl(EntryType *D)
Definition: DeclTemplate.h:758
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
TypeSourceInfo * getExpansionTypeSourceInfo(unsigned I) const
Retrieve a particular expansion type source info within an expanded parameter pack.
void setPointOfInstantiation(SourceLocation POI)
Set the (first) point of instantiation of this function template specialization.
Definition: DeclTemplate.h:587
NamedDecl * getInstantiatedFrom() const
Retrieve the member declaration from which this member was instantiated.
Definition: DeclTemplate.h:627
OnStackType
Type used to indicate that the template argument list itself is a stack object.
Definition: DeclTemplate.h:231
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration, or explicit instantiation definition.
Definition: DeclTemplate.h:564
#define false
Definition: stdbool.h:33
Stores a list of template parameters and the associated requires-clause (if any) for a TemplateDecl a...
Definition: DeclTemplate.h:189
spec_iterator spec_begin() const
QualType InjectedClassNameType
The injected-class-name type for this class template.
static bool classofKind(Kind K)
const ASTTemplateArgumentListInfo * TemplateArgumentsAsWritten
The template arguments as written in the sources, if provided.
Definition: DeclTemplate.h:543
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Encodes a location in the source.
ClassTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this class template, or nullptr if no such declaration exists...
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getInstantiatedFrom() const
If this class template specialization is an instantiation of a template (rather than an explicit spec...
const FunctionTemplateDecl * getPreviousDecl() const
void setExternLoc(SourceLocation Loc)
Sets the location of the extern keyword.
bool wasDeclaredWithTypename() const
Whether this template type parameter was declared with the &#39;typename&#39; keyword.
const TemplateArgumentListInfo & templateArgs() const
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
void setPosition(unsigned P)
const Expr * getRequiresClause() const
The constraint-expression of the associated requires-clause.
Definition: DeclTemplate.h:168
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2043
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
Definition: DeclTemplate.h:163
bool isMemberSpecialization()
Determines whether this variable template partial specialization was a specialization of a member par...
Data that is common to all of the declarations of a given function template.
Definition: DeclTemplate.h:974
void Profile(llvm::FoldingSetNodeID &ID) const
BuiltinTemplateKind
Kinds of BuiltinTemplateDecl.
Definition: Builtins.h:243
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
unsigned getNumTemplates() const
Returns the number of function templates that this might be a specialization of.
Definition: DeclTemplate.h:705
static bool classof(const Decl *D)
Definition: DeclTemplate.h:946
Common * getCommonPtr() const
const TemplateArgumentListInfo & getTemplateArgsInfo() const
FunctionTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Definition: DeclTemplate.h:991
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
void init(NamedDecl *templatedDecl, TemplateParameterList *templateParams)
Initialize the underlying templated declaration and template parameters.
Definition: DeclTemplate.h:497
void setPointOfInstantiation(SourceLocation Loc)
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
ClassTemplateDecl * getMostRecentDecl()
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:149
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
const ParmDecl * getInheritedFrom() const
Get the parameter from which we inherit the default argument, if any.
Definition: DeclTemplate.h:333
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:174
size_t numTrailingObjects(OverloadToken< NamedDecl *>) const
Definition: DeclTemplate.h:93
void setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec)
static bool classofKind(Kind K)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
TemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Definition: DeclTemplate.h:418
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...
static bool classofKind(Kind K)
Definition: DeclTemplate.h:948
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getInstantiatedFrom() const
If this variable template specialization is an instantiation of a template (rather than an explicit s...
void setDeclaredWithTypename(bool withTypename)
Set whether this template type parameter was declared with the &#39;typename&#39; or &#39;class&#39; keyword...
Represents a pack expansion of types.
Definition: Type.h:5158
NamedDecl * TemplatedDecl
Definition: DeclTemplate.h:468
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
Definition: DeclTemplate.h:639
TemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params)
Definition: DeclTemplate.h:405
Defines various enumerations that describe declaration and type specifiers.
Represents a template argument.
Definition: TemplateBase.h:51
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
TagTypeKind
The kind of a tag type.
Definition: Type.h:4840
void setMemberSpecialization()
Note that this member template is a specialization.
const ClassTemplateDecl * getPreviousDecl() const
void removeDefaultArgument()
Removes the default argument of this template parameter.
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
bool containsUnexpandedParameterPack() const
Determine whether this template parameter list contains an unexpanded parameter pack.
Definition: DeclTemplate.h:158
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
llvm::PointerIntPair< RedeclarableTemplateDecl *, 1, bool > InstantiatedFromMember
The template from which this was most directly instantiated (or null).
Definition: DeclTemplate.h:813
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
static ArrayRef< TemplateArgument > getTemplateArgs(FunctionTemplateSpecializationInfo *I)
Definition: DeclTemplate.h:962
static BuiltinTemplateDecl * Create(const ASTContext &C, DeclContext *DC, DeclarationName Name, BuiltinTemplateKind BTK)
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:354
static bool classof(const Decl *D)
void setInheritedDefaultArgument(const ASTContext &C, TemplateTypeParmDecl *Prev)
Set that this default argument was inherited from another parameter.
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration, or explicit instantiation definition.
unsigned getNumTemplateParameters() const
DeclarationName - The name of a declaration.
Kind getKind() const
Definition: DeclBase.h:420
static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef< TemplateArgument > TemplateArgs, ASTContext &Context)
void setTemplateParameters(TemplateParameterList *TParams)
Definition: DeclTemplate.h:478
llvm::iterator_range< redecl_iterator > redecl_range
Definition: Redeclarable.h:291
Storage for a default argument.
Definition: DeclTemplate.h:287
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:146
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
bool isThisDeclarationADefinition() const
Returns whether this template declaration defines the primary variable pattern.
ClassTemplatePartialSpecializationDecl * getMostRecentDecl()
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
const DefArgStorage & getDefaultArgStorage() const
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
static bool classofKind(Kind K)
ClassTemplateDecl(ConstrainedTemplateDeclInfo *CTDI, ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
const_iterator end() const
Definition: DeclTemplate.h:122
void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD)
Definition: DeclTemplate.h:930
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:156
friend TrailingObjects
Definition: OpenMPClause.h:89
static DeclType * getDecl(FunctionTemplateSpecializationInfo *I)
Definition: DeclTemplate.h:957
VarTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this variable template, or nullptr if no such declaration exists...
RedeclarableTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Definition: DeclTemplate.h:854
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
TypeAliasTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
static bool classof(const Decl *D)
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
const ClassTemplateDecl * getMostRecentDecl() const
void setInstantiationOf(VarTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this variable template specialization is actually an instantiation of the given variable te...
SpecIterator(typename llvm::FoldingSetVector< EntryType >::iterator SetIter)
Definition: DeclTemplate.h:777
TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Definition: DeclTemplate.h:426
A template argument list.
Definition: DeclTemplate.h:210
redeclarable_base::redecl_iterator redecl_iterator
Definition: DeclTemplate.h:936
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
Defines the clang::SourceLocation class and associated facilities.
VarTemplateDecl * getMostRecentDecl()
static bool classof(const Decl *D)
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
TemplateParameterList(SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
TypeAliasTemplateDecl * getInstantiatedFromMemberTemplate() const
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:608
static bool classof(const Decl *D)
VarTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
SourceLocation getFriendLoc() const
Retrieves the location of the &#39;friend&#39; keyword.
Declaration of a class template.
VarTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
void removeDefaultArgument()
Removes the default argument of this template parameter.
static SpecIterator< EntryType > makeSpecIterator(llvm::FoldingSetVector< EntryType > &Specs, bool isEnd)
Definition: DeclTemplate.h:790
void setExternLoc(SourceLocation Loc)
Sets the location of the extern keyword.
const_iterator begin() const
Definition: DeclTemplate.h:120
VarTemplateDecl * getInstantiatedFromMemberTemplate() const
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:89
llvm::FoldingSetVector< VarTemplateSpecializationDecl > Specializations
The variable template specializations for this variable template, including explicit specializations ...
llvm::FoldingSetVector< ClassTemplateSpecializationDecl > Specializations
The class template specializations for this class template, including explicit specializations and in...
Common * getCommonPtr() const
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
bool isSet() const
Determine whether there is a default argument for this parameter.
Definition: DeclTemplate.h:314
void setMemberSpecialization()
Note that this member template is a specialization.
void setInheritedDefaultArgument(const ASTContext &C, TemplateTemplateParmDecl *Prev)
QualType getDefaultArgument() const
Retrieve the default argument, if any.
void Profile(llvm::FoldingSetNodeID &ID) const
void setTemplateParameters(TemplateParameterList *TParams)
Definition: DeclTemplate.h:383
const FunctionTemplateDecl * getCanonicalDecl() const
A trivial tuple used to represent a source range.
This represents a decl that may have a name.
Definition: Decl.h:248
NamedDecl * getAsNamedDecl(TemplateParameter P)
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate members of the class templa...
Declaration of a friend template.
VarTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member variable template partial specialization from which this particular variable temp...
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
Definition: DeclTemplate.h:648
NamedDecl * getFriendDecl() const
If this friend declaration names a templated function (or a member function of a templated type)...
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
Definition: DeclTemplate.h:653
SourceLocation getBegin() const
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:176
TrailingObjects::FixedSizeStorageOwner FixedSizeStorageOwner
Definition: DeclTemplate.h:182
Declaration of a template function.
Definition: DeclTemplate.h:968
bool isThisDeclarationADefinition() const
Returns whether this template declaration defines the primary pattern.
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
FunctionTemplateDecl * getMostRecentDecl()
TemplateArgumentList(OnStackType, ArrayRef< TemplateArgument > Args)
Construct a new, temporary template argument list on the stack.
Definition: DeclTemplate.h:242