clang  8.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  /// Merge \p Prev with our RedeclarableTemplateDecl::Common.
1097  void mergePrevDecl(FunctionTemplateDecl *Prev);
1098 
1099  /// Create a function template node.
1101  SourceLocation L,
1102  DeclarationName Name,
1103  TemplateParameterList *Params,
1104  NamedDecl *Decl);
1105 
1106  /// Create an empty function template node.
1107  static FunctionTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1108 
1109  // Implement isa/cast/dyncast support
1110  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1111  static bool classofKind(Kind K) { return K == FunctionTemplate; }
1112 };
1113 
1114 //===----------------------------------------------------------------------===//
1115 // Kinds of Template Parameters
1116 //===----------------------------------------------------------------------===//
1117 
1118 /// Defines the position of a template parameter within a template
1119 /// parameter list.
1120 ///
1121 /// Because template parameter can be listed
1122 /// sequentially for out-of-line template members, each template parameter is
1123 /// given a Depth - the nesting of template parameter scopes - and a Position -
1124 /// the occurrence within the parameter list.
1125 /// This class is inheritedly privately by different kinds of template
1126 /// parameters and is not part of the Decl hierarchy. Just a facility.
1128 protected:
1129  // FIXME: These probably don't need to be ints. int:5 for depth, int:8 for
1130  // position? Maybe?
1131  unsigned Depth;
1132  unsigned Position;
1133 
1134  TemplateParmPosition(unsigned D, unsigned P) : Depth(D), Position(P) {}
1135 
1136 public:
1137  TemplateParmPosition() = delete;
1138 
1139  /// Get the nesting depth of the template parameter.
1140  unsigned getDepth() const { return Depth; }
1141  void setDepth(unsigned D) { Depth = D; }
1142 
1143  /// Get the position of the template parameter within its parameter list.
1144  unsigned getPosition() const { return Position; }
1145  void setPosition(unsigned P) { Position = P; }
1146 
1147  /// Get the index of the template parameter within its parameter list.
1148  unsigned getIndex() const { return Position; }
1149 };
1150 
1151 /// Declaration of a template type parameter.
1152 ///
1153 /// For example, "T" in
1154 /// \code
1155 /// template<typename T> class vector;
1156 /// \endcode
1157 class TemplateTypeParmDecl : public TypeDecl {
1158  /// Sema creates these on the stack during auto type deduction.
1159  friend class Sema;
1160 
1161  /// Whether this template type parameter was declaration with
1162  /// the 'typename' keyword.
1163  ///
1164  /// If false, it was declared with the 'class' keyword.
1165  bool Typename : 1;
1166 
1167  /// The default template argument, if any.
1168  using DefArgStorage =
1170  DefArgStorage DefaultArgument;
1171 
1172  TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc,
1174  bool Typename)
1175  : TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename) {}
1176 
1177 public:
1178  static TemplateTypeParmDecl *Create(const ASTContext &C, DeclContext *DC,
1179  SourceLocation KeyLoc,
1180  SourceLocation NameLoc,
1181  unsigned D, unsigned P,
1182  IdentifierInfo *Id, bool Typename,
1183  bool ParameterPack);
1184  static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C,
1185  unsigned ID);
1186 
1187  /// Whether this template type parameter was declared with
1188  /// the 'typename' keyword.
1189  ///
1190  /// If not, it was declared with the 'class' keyword.
1191  bool wasDeclaredWithTypename() const { return Typename; }
1192 
1193  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1194 
1195  /// Determine whether this template parameter has a default
1196  /// argument.
1197  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1198 
1199  /// Retrieve the default argument, if any.
1201  return DefaultArgument.get()->getType();
1202  }
1203 
1204  /// Retrieves the default argument's source information, if any.
1206  return DefaultArgument.get();
1207  }
1208 
1209  /// Retrieves the location of the default argument declaration.
1210  SourceLocation getDefaultArgumentLoc() const;
1211 
1212  /// Determines whether the default argument was inherited
1213  /// from a previous declaration of this template.
1215  return DefaultArgument.isInherited();
1216  }
1217 
1218  /// Set the default argument for this template parameter.
1220  DefaultArgument.set(DefArg);
1221  }
1222 
1223  /// Set that this default argument was inherited from another
1224  /// parameter.
1226  TemplateTypeParmDecl *Prev) {
1227  DefaultArgument.setInherited(C, Prev);
1228  }
1229 
1230  /// Removes the default argument of this template parameter.
1232  DefaultArgument.clear();
1233  }
1234 
1235  /// Set whether this template type parameter was declared with
1236  /// the 'typename' or 'class' keyword.
1237  void setDeclaredWithTypename(bool withTypename) { Typename = withTypename; }
1238 
1239  /// Retrieve the depth of the template parameter.
1240  unsigned getDepth() const;
1241 
1242  /// Retrieve the index of the template parameter.
1243  unsigned getIndex() const;
1244 
1245  /// Returns whether this is a parameter pack.
1246  bool isParameterPack() const;
1247 
1248  SourceRange getSourceRange() const override LLVM_READONLY;
1249 
1250  // Implement isa/cast/dyncast/etc.
1251  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1252  static bool classofKind(Kind K) { return K == TemplateTypeParm; }
1253 };
1254 
1255 /// NonTypeTemplateParmDecl - Declares a non-type template parameter,
1256 /// e.g., "Size" in
1257 /// @code
1258 /// template<int Size> class array { };
1259 /// @endcode
1260 class NonTypeTemplateParmDecl final
1261  : public DeclaratorDecl,
1262  protected TemplateParmPosition,
1263  private llvm::TrailingObjects<NonTypeTemplateParmDecl,
1264  std::pair<QualType, TypeSourceInfo *>> {
1265  friend class ASTDeclReader;
1266  friend TrailingObjects;
1267 
1268  /// The default template argument, if any, and whether or not
1269  /// it was inherited.
1271  DefArgStorage DefaultArgument;
1272 
1273  // FIXME: Collapse this into TemplateParamPosition; or, just move depth/index
1274  // down here to save memory.
1275 
1276  /// Whether this non-type template parameter is a parameter pack.
1277  bool ParameterPack;
1278 
1279  /// Whether this non-type template parameter is an "expanded"
1280  /// parameter pack, meaning that its type is a pack expansion and we
1281  /// already know the set of types that expansion expands to.
1282  bool ExpandedParameterPack = false;
1283 
1284  /// The number of types in an expanded parameter pack.
1285  unsigned NumExpandedTypes = 0;
1286 
1287  size_t numTrailingObjects(
1288  OverloadToken<std::pair<QualType, TypeSourceInfo *>>) const {
1289  return NumExpandedTypes;
1290  }
1291 
1292  NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
1293  SourceLocation IdLoc, unsigned D, unsigned P,
1295  bool ParameterPack, TypeSourceInfo *TInfo)
1296  : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
1297  TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
1298 
1299  NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
1300  SourceLocation IdLoc, unsigned D, unsigned P,
1302  TypeSourceInfo *TInfo,
1303  ArrayRef<QualType> ExpandedTypes,
1304  ArrayRef<TypeSourceInfo *> ExpandedTInfos);
1305 
1306 public:
1307  static NonTypeTemplateParmDecl *
1308  Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1309  SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
1310  QualType T, bool ParameterPack, TypeSourceInfo *TInfo);
1311 
1312  static NonTypeTemplateParmDecl *
1313  Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1314  SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
1315  QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
1316  ArrayRef<TypeSourceInfo *> ExpandedTInfos);
1317 
1318  static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
1319  unsigned ID);
1320  static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
1321  unsigned ID,
1322  unsigned NumExpandedTypes);
1323 
1329 
1330  SourceRange getSourceRange() const override LLVM_READONLY;
1331 
1332  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1333 
1334  /// Determine whether this template parameter has a default
1335  /// argument.
1336  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1337 
1338  /// Retrieve the default argument, if any.
1339  Expr *getDefaultArgument() const { return DefaultArgument.get(); }
1340 
1341  /// Retrieve the location of the default argument, if any.
1342  SourceLocation getDefaultArgumentLoc() const;
1343 
1344  /// Determines whether the default argument was inherited
1345  /// from a previous declaration of this template.
1347  return DefaultArgument.isInherited();
1348  }
1349 
1350  /// Set the default argument for this template parameter, and
1351  /// whether that default argument was inherited from another
1352  /// declaration.
1353  void setDefaultArgument(Expr *DefArg) { DefaultArgument.set(DefArg); }
1355  NonTypeTemplateParmDecl *Parm) {
1356  DefaultArgument.setInherited(C, Parm);
1357  }
1358 
1359  /// Removes the default argument of this template parameter.
1360  void removeDefaultArgument() { DefaultArgument.clear(); }
1361 
1362  /// Whether this parameter is a non-type template parameter pack.
1363  ///
1364  /// If the parameter is a parameter pack, the type may be a
1365  /// \c PackExpansionType. In the following example, the \c Dims parameter
1366  /// is a parameter pack (whose type is 'unsigned').
1367  ///
1368  /// \code
1369  /// template<typename T, unsigned ...Dims> struct multi_array;
1370  /// \endcode
1371  bool isParameterPack() const { return ParameterPack; }
1372 
1373  /// Whether this parameter pack is a pack expansion.
1374  ///
1375  /// A non-type template parameter pack is a pack expansion if its type
1376  /// contains an unexpanded parameter pack. In this case, we will have
1377  /// built a PackExpansionType wrapping the type.
1378  bool isPackExpansion() const {
1379  return ParameterPack && getType()->getAs<PackExpansionType>();
1380  }
1381 
1382  /// Whether this parameter is a non-type template parameter pack
1383  /// that has a known list of different types at different positions.
1384  ///
1385  /// A parameter pack is an expanded parameter pack when the original
1386  /// parameter pack's type was itself a pack expansion, and that expansion
1387  /// has already been expanded. For example, given:
1388  ///
1389  /// \code
1390  /// template<typename ...Types>
1391  /// struct X {
1392  /// template<Types ...Values>
1393  /// struct Y { /* ... */ };
1394  /// };
1395  /// \endcode
1396  ///
1397  /// The parameter pack \c Values has a \c PackExpansionType as its type,
1398  /// which expands \c Types. When \c Types is supplied with template arguments
1399  /// by instantiating \c X, the instantiation of \c Values becomes an
1400  /// expanded parameter pack. For example, instantiating
1401  /// \c X<int, unsigned int> results in \c Values being an expanded parameter
1402  /// pack with expansion types \c int and \c unsigned int.
1403  ///
1404  /// The \c getExpansionType() and \c getExpansionTypeSourceInfo() functions
1405  /// return the expansion types.
1406  bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1407 
1408  /// Retrieves the number of expansion types in an expanded parameter
1409  /// pack.
1410  unsigned getNumExpansionTypes() const {
1411  assert(ExpandedParameterPack && "Not an expansion parameter pack");
1412  return NumExpandedTypes;
1413  }
1414 
1415  /// Retrieve a particular expansion type within an expanded parameter
1416  /// pack.
1417  QualType getExpansionType(unsigned I) const {
1418  assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1419  auto TypesAndInfos =
1420  getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1421  return TypesAndInfos[I].first;
1422  }
1423 
1424  /// Retrieve a particular expansion type source info within an
1425  /// expanded parameter pack.
1427  assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1428  auto TypesAndInfos =
1429  getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1430  return TypesAndInfos[I].second;
1431  }
1432 
1433  // Implement isa/cast/dyncast/etc.
1434  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1435  static bool classofKind(Kind K) { return K == NonTypeTemplateParm; }
1436 };
1437 
1438 /// TemplateTemplateParmDecl - Declares a template template parameter,
1439 /// e.g., "T" in
1440 /// @code
1441 /// template <template <typename> class T> class container { };
1442 /// @endcode
1443 /// A template template parameter is a TemplateDecl because it defines the
1444 /// name of a template and the template parameters allowable for substitution.
1446  : public TemplateDecl,
1447  protected TemplateParmPosition,
1448  private llvm::TrailingObjects<TemplateTemplateParmDecl,
1449  TemplateParameterList *> {
1450  /// The default template argument, if any.
1451  using DefArgStorage =
1453  DefArgStorage DefaultArgument;
1454 
1455  /// Whether this parameter is a parameter pack.
1456  bool ParameterPack;
1457 
1458  /// Whether this template template parameter is an "expanded"
1459  /// parameter pack, meaning that it is a pack expansion and we
1460  /// already know the set of template parameters that expansion expands to.
1461  bool ExpandedParameterPack = false;
1462 
1463  /// The number of parameters in an expanded parameter pack.
1464  unsigned NumExpandedParams = 0;
1465 
1467  unsigned D, unsigned P, bool ParameterPack,
1469  : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
1470  TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
1471 
1473  unsigned D, unsigned P,
1476 
1477  void anchor() override;
1478 
1479 public:
1480  friend class ASTDeclReader;
1481  friend class ASTDeclWriter;
1483 
1484  static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
1485  SourceLocation L, unsigned D,
1486  unsigned P, bool ParameterPack,
1487  IdentifierInfo *Id,
1488  TemplateParameterList *Params);
1489  static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
1490  SourceLocation L, unsigned D,
1491  unsigned P,
1492  IdentifierInfo *Id,
1493  TemplateParameterList *Params,
1495 
1496  static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
1497  unsigned ID);
1498  static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
1499  unsigned ID,
1500  unsigned NumExpansions);
1501 
1507 
1508  /// Whether this template template parameter is a template
1509  /// parameter pack.
1510  ///
1511  /// \code
1512  /// template<template <class T> ...MetaFunctions> struct Apply;
1513  /// \endcode
1514  bool isParameterPack() const { return ParameterPack; }
1515 
1516  /// Whether this parameter pack is a pack expansion.
1517  ///
1518  /// A template template parameter pack is a pack expansion if its template
1519  /// parameter list contains an unexpanded parameter pack.
1520  bool isPackExpansion() const {
1521  return ParameterPack &&
1522  getTemplateParameters()->containsUnexpandedParameterPack();
1523  }
1524 
1525  /// Whether this parameter is a template template parameter pack that
1526  /// has a known list of different template parameter lists at different
1527  /// positions.
1528  ///
1529  /// A parameter pack is an expanded parameter pack when the original parameter
1530  /// pack's template parameter list was itself a pack expansion, and that
1531  /// expansion has already been expanded. For exampe, given:
1532  ///
1533  /// \code
1534  /// template<typename...Types> struct Outer {
1535  /// template<template<Types> class...Templates> struct Inner;
1536  /// };
1537  /// \endcode
1538  ///
1539  /// The parameter pack \c Templates is a pack expansion, which expands the
1540  /// pack \c Types. When \c Types is supplied with template arguments by
1541  /// instantiating \c Outer, the instantiation of \c Templates is an expanded
1542  /// parameter pack.
1543  bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1544 
1545  /// Retrieves the number of expansion template parameters in
1546  /// an expanded parameter pack.
1548  assert(ExpandedParameterPack && "Not an expansion parameter pack");
1549  return NumExpandedParams;
1550  }
1551 
1552  /// Retrieve a particular expansion type within an expanded parameter
1553  /// pack.
1555  assert(I < NumExpandedParams && "Out-of-range expansion type index");
1556  return getTrailingObjects<TemplateParameterList *>()[I];
1557  }
1558 
1559  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1560 
1561  /// Determine whether this template parameter has a default
1562  /// argument.
1563  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1564 
1565  /// Retrieve the default argument, if any.
1567  static const TemplateArgumentLoc None;
1568  return DefaultArgument.isSet() ? *DefaultArgument.get() : None;
1569  }
1570 
1571  /// Retrieve the location of the default argument, if any.
1572  SourceLocation getDefaultArgumentLoc() const;
1573 
1574  /// Determines whether the default argument was inherited
1575  /// from a previous declaration of this template.
1577  return DefaultArgument.isInherited();
1578  }
1579 
1580  /// Set the default argument for this template parameter, and
1581  /// whether that default argument was inherited from another
1582  /// declaration.
1583  void setDefaultArgument(const ASTContext &C,
1584  const TemplateArgumentLoc &DefArg);
1586  TemplateTemplateParmDecl *Prev) {
1587  DefaultArgument.setInherited(C, Prev);
1588  }
1589 
1590  /// Removes the default argument of this template parameter.
1591  void removeDefaultArgument() { DefaultArgument.clear(); }
1592 
1593  SourceRange getSourceRange() const override LLVM_READONLY {
1594  SourceLocation End = getLocation();
1595  if (hasDefaultArgument() && !defaultArgumentWasInherited())
1596  End = getDefaultArgument().getSourceRange().getEnd();
1597  return SourceRange(getTemplateParameters()->getTemplateLoc(), End);
1598  }
1599 
1600  // Implement isa/cast/dyncast/etc.
1601  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1602  static bool classofKind(Kind K) { return K == TemplateTemplateParm; }
1603 };
1604 
1605 /// Represents the builtin template declaration which is used to
1606 /// implement __make_integer_seq and other builtin templates. It serves
1607 /// no real purpose beyond existing as a place to hold template parameters.
1609  BuiltinTemplateKind BTK;
1610 
1613 
1614  void anchor() override;
1615 
1616 public:
1617  // Implement isa/cast/dyncast support
1618  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1619  static bool classofKind(Kind K) { return K == BuiltinTemplate; }
1620 
1622  DeclarationName Name,
1623  BuiltinTemplateKind BTK) {
1624  return new (C, DC) BuiltinTemplateDecl(C, DC, Name, BTK);
1625  }
1626 
1627  SourceRange getSourceRange() const override LLVM_READONLY {
1628  return {};
1629  }
1630 
1632 };
1633 
1634 /// Represents a class template specialization, which refers to
1635 /// a class template with a given set of template arguments.
1636 ///
1637 /// Class template specializations represent both explicit
1638 /// specialization of class templates, as in the example below, and
1639 /// implicit instantiations of class templates.
1640 ///
1641 /// \code
1642 /// template<typename T> class array;
1643 ///
1644 /// template<>
1645 /// class array<bool> { }; // class template specialization array<bool>
1646 /// \endcode
1648  : public CXXRecordDecl, public llvm::FoldingSetNode {
1649  /// Structure that stores information about a class template
1650  /// specialization that was instantiated from a class template partial
1651  /// specialization.
1652  struct SpecializedPartialSpecialization {
1653  /// The class template partial specialization from which this
1654  /// class template specialization was instantiated.
1655  ClassTemplatePartialSpecializationDecl *PartialSpecialization;
1656 
1657  /// The template argument list deduced for the class template
1658  /// partial specialization itself.
1659  const TemplateArgumentList *TemplateArgs;
1660  };
1661 
1662  /// The template that this specialization specializes
1663  llvm::PointerUnion<ClassTemplateDecl *, SpecializedPartialSpecialization *>
1664  SpecializedTemplate;
1665 
1666  /// Further info for explicit template specialization/instantiation.
1667  struct ExplicitSpecializationInfo {
1668  /// The type-as-written.
1669  TypeSourceInfo *TypeAsWritten = nullptr;
1670 
1671  /// The location of the extern keyword.
1672  SourceLocation ExternLoc;
1673 
1674  /// The location of the template keyword.
1675  SourceLocation TemplateKeywordLoc;
1676 
1677  ExplicitSpecializationInfo() = default;
1678  };
1679 
1680  /// Further info for explicit template specialization/instantiation.
1681  /// Does not apply to implicit specializations.
1682  ExplicitSpecializationInfo *ExplicitInfo = nullptr;
1683 
1684  /// The template arguments used to describe this specialization.
1685  const TemplateArgumentList *TemplateArgs;
1686 
1687  /// The point where this template was instantiated (if any)
1688  SourceLocation PointOfInstantiation;
1689 
1690  /// The kind of specialization this declaration refers to.
1691  /// Really a value of type TemplateSpecializationKind.
1692  unsigned SpecializationKind : 3;
1693 
1694 protected:
1696  DeclContext *DC, SourceLocation StartLoc,
1697  SourceLocation IdLoc,
1698  ClassTemplateDecl *SpecializedTemplate,
1701 
1703 
1704 public:
1705  friend class ASTDeclReader;
1706  friend class ASTDeclWriter;
1707 
1709  Create(ASTContext &Context, TagKind TK, DeclContext *DC,
1710  SourceLocation StartLoc, SourceLocation IdLoc,
1711  ClassTemplateDecl *SpecializedTemplate,
1715  CreateDeserialized(ASTContext &C, unsigned ID);
1716 
1717  void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
1718  bool Qualified) const override;
1719 
1720  // FIXME: This is broken. CXXRecordDecl::getMostRecentDecl() returns a
1721  // different "most recent" declaration from this function for the same
1722  // declaration, because we don't override getMostRecentDeclImpl(). But
1723  // it's not clear that we should override that, because the most recent
1724  // declaration as a CXXRecordDecl sometimes is the injected-class-name.
1726  return cast<ClassTemplateSpecializationDecl>(
1727  getMostRecentNonInjectedDecl());
1728  }
1729 
1730  /// Retrieve the template that this specialization specializes.
1731  ClassTemplateDecl *getSpecializedTemplate() const;
1732 
1733  /// Retrieve the template arguments of the class template
1734  /// specialization.
1736  return *TemplateArgs;
1737  }
1738 
1739  /// Determine the kind of specialization that this
1740  /// declaration represents.
1742  return static_cast<TemplateSpecializationKind>(SpecializationKind);
1743  }
1744 
1746  return getSpecializationKind() == TSK_ExplicitSpecialization;
1747  }
1748 
1749  /// True if this declaration is an explicit specialization,
1750  /// explicit instantiation declaration, or explicit instantiation
1751  /// definition.
1755  }
1756 
1758  SpecializationKind = TSK;
1759  }
1760 
1761  /// Get the point of instantiation (if any), or null if none.
1763  return PointOfInstantiation;
1764  }
1765 
1767  assert(Loc.isValid() && "point of instantiation must be valid!");
1768  PointOfInstantiation = Loc;
1769  }
1770 
1771  /// If this class template specialization is an instantiation of
1772  /// a template (rather than an explicit specialization), return the
1773  /// class template or class template partial specialization from which it
1774  /// was instantiated.
1775  llvm::PointerUnion<ClassTemplateDecl *,
1778  if (!isTemplateInstantiation(getSpecializationKind()))
1779  return llvm::PointerUnion<ClassTemplateDecl *,
1781 
1782  return getSpecializedTemplateOrPartial();
1783  }
1784 
1785  /// Retrieve the class template or class template partial
1786  /// specialization which was specialized by this.
1787  llvm::PointerUnion<ClassTemplateDecl *,
1790  if (const auto *PartialSpec =
1791  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1792  return PartialSpec->PartialSpecialization;
1793 
1794  return SpecializedTemplate.get<ClassTemplateDecl*>();
1795  }
1796 
1797  /// Retrieve the set of template arguments that should be used
1798  /// to instantiate members of the class template or class template partial
1799  /// specialization from which this class template specialization was
1800  /// instantiated.
1801  ///
1802  /// \returns For a class template specialization instantiated from the primary
1803  /// template, this function will return the same template arguments as
1804  /// getTemplateArgs(). For a class template specialization instantiated from
1805  /// a class template partial specialization, this function will return the
1806  /// deduced template arguments for the class template partial specialization
1807  /// itself.
1809  if (const auto *PartialSpec =
1810  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1811  return *PartialSpec->TemplateArgs;
1812 
1813  return getTemplateArgs();
1814  }
1815 
1816  /// Note that this class template specialization is actually an
1817  /// instantiation of the given class template partial specialization whose
1818  /// template arguments have been deduced.
1820  const TemplateArgumentList *TemplateArgs) {
1821  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
1822  "Already set to a class template partial specialization!");
1823  auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
1824  PS->PartialSpecialization = PartialSpec;
1825  PS->TemplateArgs = TemplateArgs;
1826  SpecializedTemplate = PS;
1827  }
1828 
1829  /// Note that this class template specialization is an instantiation
1830  /// of the given class template.
1831  void setInstantiationOf(ClassTemplateDecl *TemplDecl) {
1832  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
1833  "Previously set to a class template partial specialization!");
1834  SpecializedTemplate = TemplDecl;
1835  }
1836 
1837  /// Sets the type of this specialization as it was written by
1838  /// the user. This will be a class template specialization type.
1840  if (!ExplicitInfo)
1841  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1842  ExplicitInfo->TypeAsWritten = T;
1843  }
1844 
1845  /// Gets the type of this specialization as it was written by
1846  /// the user, if it was so written.
1848  return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
1849  }
1850 
1851  /// Gets the location of the extern keyword, if present.
1853  return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
1854  }
1855 
1856  /// Sets the location of the extern keyword.
1858  if (!ExplicitInfo)
1859  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1860  ExplicitInfo->ExternLoc = Loc;
1861  }
1862 
1863  /// Sets the location of the template keyword.
1865  if (!ExplicitInfo)
1866  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1867  ExplicitInfo->TemplateKeywordLoc = Loc;
1868  }
1869 
1870  /// Gets the location of the template keyword, if present.
1872  return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
1873  }
1874 
1875  SourceRange getSourceRange() const override LLVM_READONLY;
1876 
1877  void Profile(llvm::FoldingSetNodeID &ID) const {
1878  Profile(ID, TemplateArgs->asArray(), getASTContext());
1879  }
1880 
1881  static void
1882  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
1883  ASTContext &Context) {
1884  ID.AddInteger(TemplateArgs.size());
1885  for (const TemplateArgument &TemplateArg : TemplateArgs)
1886  TemplateArg.Profile(ID, Context);
1887  }
1888 
1889  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1890 
1891  static bool classofKind(Kind K) {
1892  return K >= firstClassTemplateSpecialization &&
1893  K <= lastClassTemplateSpecialization;
1894  }
1895 };
1896 
1899  /// The list of template parameters
1900  TemplateParameterList* TemplateParams = nullptr;
1901 
1902  /// The source info for the template arguments as written.
1903  /// FIXME: redundant with TypeAsWritten?
1904  const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
1905 
1906  /// The class template partial specialization from which this
1907  /// class template partial specialization was instantiated.
1908  ///
1909  /// The boolean value will be true to indicate that this class template
1910  /// partial specialization was specialized at this level.
1911  llvm::PointerIntPair<ClassTemplatePartialSpecializationDecl *, 1, bool>
1912  InstantiatedFromMember;
1913 
1915  DeclContext *DC,
1916  SourceLocation StartLoc,
1917  SourceLocation IdLoc,
1918  TemplateParameterList *Params,
1919  ClassTemplateDecl *SpecializedTemplate,
1921  const ASTTemplateArgumentListInfo *ArgsAsWritten,
1923 
1925  : ClassTemplateSpecializationDecl(C, ClassTemplatePartialSpecialization),
1926  InstantiatedFromMember(nullptr, false) {}
1927 
1928  void anchor() override;
1929 
1930 public:
1931  friend class ASTDeclReader;
1932  friend class ASTDeclWriter;
1933 
1935  Create(ASTContext &Context, TagKind TK, DeclContext *DC,
1936  SourceLocation StartLoc, SourceLocation IdLoc,
1937  TemplateParameterList *Params,
1938  ClassTemplateDecl *SpecializedTemplate,
1940  const TemplateArgumentListInfo &ArgInfos,
1941  QualType CanonInjectedType,
1943 
1945  CreateDeserialized(ASTContext &C, unsigned ID);
1946 
1948  return cast<ClassTemplatePartialSpecializationDecl>(
1949  static_cast<ClassTemplateSpecializationDecl *>(
1950  this)->getMostRecentDecl());
1951  }
1952 
1953  /// Get the list of template parameters
1955  return TemplateParams;
1956  }
1957 
1958  /// Get the template arguments as written.
1960  return ArgsAsWritten;
1961  }
1962 
1963  /// Retrieve the member class template partial specialization from
1964  /// which this particular class template partial specialization was
1965  /// instantiated.
1966  ///
1967  /// \code
1968  /// template<typename T>
1969  /// struct Outer {
1970  /// template<typename U> struct Inner;
1971  /// template<typename U> struct Inner<U*> { }; // #1
1972  /// };
1973  ///
1974  /// Outer<float>::Inner<int*> ii;
1975  /// \endcode
1976  ///
1977  /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
1978  /// end up instantiating the partial specialization
1979  /// \c Outer<float>::Inner<U*>, which itself was instantiated from the class
1980  /// template partial specialization \c Outer<T>::Inner<U*>. Given
1981  /// \c Outer<float>::Inner<U*>, this function would return
1982  /// \c Outer<T>::Inner<U*>.
1984  const auto *First =
1985  cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
1986  return First->InstantiatedFromMember.getPointer();
1987  }
1990  return getInstantiatedFromMember();
1991  }
1992 
1995  auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
1996  First->InstantiatedFromMember.setPointer(PartialSpec);
1997  }
1998 
1999  /// Determines whether this class template partial specialization
2000  /// template was a specialization of a member partial specialization.
2001  ///
2002  /// In the following example, the member template partial specialization
2003  /// \c X<int>::Inner<T*> is a member specialization.
2004  ///
2005  /// \code
2006  /// template<typename T>
2007  /// struct X {
2008  /// template<typename U> struct Inner;
2009  /// template<typename U> struct Inner<U*>;
2010  /// };
2011  ///
2012  /// template<> template<typename T>
2013  /// struct X<int>::Inner<T*> { /* ... */ };
2014  /// \endcode
2016  const auto *First =
2017  cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2018  return First->InstantiatedFromMember.getInt();
2019  }
2020 
2021  /// Note that this member template is a specialization.
2023  auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2024  assert(First->InstantiatedFromMember.getPointer() &&
2025  "Only member templates can be member template specializations");
2026  return First->InstantiatedFromMember.setInt(true);
2027  }
2028 
2029  /// Retrieves the injected specialization type for this partial
2030  /// specialization. This is not the same as the type-decl-type for
2031  /// this partial specialization, which is an InjectedClassNameType.
2033  assert(getTypeForDecl() && "partial specialization has no type set!");
2034  return cast<InjectedClassNameType>(getTypeForDecl())
2035  ->getInjectedSpecializationType();
2036  }
2037 
2038  // FIXME: Add Profile support!
2039 
2040  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2041 
2042  static bool classofKind(Kind K) {
2043  return K == ClassTemplatePartialSpecialization;
2044  }
2045 };
2046 
2047 /// Declaration of a class template.
2049 protected:
2050  /// Data that is common to all of the declarations of a given
2051  /// class template.
2052  struct Common : CommonBase {
2053  /// The class template specializations for this class
2054  /// template, including explicit specializations and instantiations.
2055  llvm::FoldingSetVector<ClassTemplateSpecializationDecl> Specializations;
2056 
2057  /// The class template partial specializations for this class
2058  /// template.
2059  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
2061 
2062  /// The injected-class-name type for this class template.
2064 
2065  Common() = default;
2066  };
2067 
2068  /// Retrieve the set of specializations of this class template.
2069  llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
2070  getSpecializations() const;
2071 
2072  /// Retrieve the set of partial specializations of this class
2073  /// template.
2074  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
2075  getPartialSpecializations();
2076 
2080  : RedeclarableTemplateDecl(CTDI, ClassTemplate, C, DC, L, Name, Params,
2081  Decl) {}
2082 
2084  DeclarationName Name, TemplateParameterList *Params,
2085  NamedDecl *Decl)
2086  : ClassTemplateDecl(nullptr, C, DC, L, Name, Params, Decl) {}
2087 
2088  CommonBase *newCommon(ASTContext &C) const override;
2089 
2091  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2092  }
2093 
2094 public:
2095  friend class ASTDeclReader;
2096  friend class ASTDeclWriter;
2097 
2098  /// Load any lazily-loaded specializations from the external source.
2099  void LoadLazySpecializations() const;
2100 
2101  /// Get the underlying class declarations of the template.
2103  return static_cast<CXXRecordDecl *>(TemplatedDecl);
2104  }
2105 
2106  /// Returns whether this template declaration defines the primary
2107  /// class pattern.
2109  return getTemplatedDecl()->isThisDeclarationADefinition();
2110  }
2111 
2112  // FIXME: remove default argument for AssociatedConstraints
2113  /// Create a class template node.
2115  SourceLocation L,
2116  DeclarationName Name,
2117  TemplateParameterList *Params,
2118  NamedDecl *Decl,
2119  Expr *AssociatedConstraints = nullptr);
2120 
2121  /// Create an empty class template node.
2122  static ClassTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2123 
2124  /// Return the specialization with the provided arguments if it exists,
2125  /// otherwise return the insertion point.
2127  findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2128 
2129  /// Insert the specified specialization knowing that it is not already
2130  /// in. InsertPos must be obtained from findSpecialization.
2131  void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos);
2132 
2134  return cast<ClassTemplateDecl>(
2136  }
2138  return cast<ClassTemplateDecl>(
2140  }
2141 
2142  /// Retrieve the previous declaration of this class template, or
2143  /// nullptr if no such declaration exists.
2145  return cast_or_null<ClassTemplateDecl>(
2146  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2147  }
2149  return cast_or_null<ClassTemplateDecl>(
2150  static_cast<const RedeclarableTemplateDecl *>(
2151  this)->getPreviousDecl());
2152  }
2153 
2155  return cast<ClassTemplateDecl>(
2156  static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
2157  }
2159  return const_cast<ClassTemplateDecl*>(this)->getMostRecentDecl();
2160  }
2161 
2163  return cast_or_null<ClassTemplateDecl>(
2165  }
2166 
2167  /// Return the partial specialization with the provided arguments if it
2168  /// exists, otherwise return the insertion point.
2170  findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2171 
2172  /// Insert the specified partial specialization knowing that it is not
2173  /// already in. InsertPos must be obtained from findPartialSpecialization.
2174  void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D,
2175  void *InsertPos);
2176 
2177  /// Retrieve the partial specializations as an ordered list.
2178  void getPartialSpecializations(
2180 
2181  /// Find a class template partial specialization with the given
2182  /// type T.
2183  ///
2184  /// \param T a dependent type that names a specialization of this class
2185  /// template.
2186  ///
2187  /// \returns the class template partial specialization that exactly matches
2188  /// the type \p T, or nullptr if no such partial specialization exists.
2189  ClassTemplatePartialSpecializationDecl *findPartialSpecialization(QualType T);
2190 
2191  /// Find a class template partial specialization which was instantiated
2192  /// from the given member partial specialization.
2193  ///
2194  /// \param D a member class template partial specialization.
2195  ///
2196  /// \returns the class template partial specialization which was instantiated
2197  /// from the given member partial specialization, or nullptr if no such
2198  /// partial specialization exists.
2200  findPartialSpecInstantiatedFromMember(
2202 
2203  /// Retrieve the template specialization type of the
2204  /// injected-class-name for this class template.
2205  ///
2206  /// The injected-class-name for a class template \c X is \c
2207  /// X<template-args>, where \c template-args is formed from the
2208  /// template arguments that correspond to the template parameters of
2209  /// \c X. For example:
2210  ///
2211  /// \code
2212  /// template<typename T, int N>
2213  /// struct array {
2214  /// typedef array this_type; // "array" is equivalent to "array<T, N>"
2215  /// };
2216  /// \endcode
2217  QualType getInjectedClassNameSpecialization();
2218 
2220  using spec_range = llvm::iterator_range<spec_iterator>;
2221 
2223  return spec_range(spec_begin(), spec_end());
2224  }
2225 
2227  return makeSpecIterator(getSpecializations(), false);
2228  }
2229 
2231  return makeSpecIterator(getSpecializations(), true);
2232  }
2233 
2234  // Implement isa/cast/dyncast support
2235  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2236  static bool classofKind(Kind K) { return K == ClassTemplate; }
2237 };
2238 
2239 /// Declaration of a friend template.
2240 ///
2241 /// For example:
2242 /// \code
2243 /// template <typename T> class A {
2244 /// friend class MyVector<T>; // not a friend template
2245 /// template <typename U> friend class B; // not a friend template
2246 /// template <typename U> friend class Foo<T>::Nested; // friend template
2247 /// };
2248 /// \endcode
2249 ///
2250 /// \note This class is not currently in use. All of the above
2251 /// will yield a FriendDecl, not a FriendTemplateDecl.
2252 class FriendTemplateDecl : public Decl {
2253  virtual void anchor();
2254 
2255 public:
2256  using FriendUnion = llvm::PointerUnion<NamedDecl *,TypeSourceInfo *>;
2257 
2258 private:
2259  // The number of template parameters; always non-zero.
2260  unsigned NumParams = 0;
2261 
2262  // The parameter list.
2263  TemplateParameterList **Params = nullptr;
2264 
2265  // The declaration that's a friend of this class.
2266  FriendUnion Friend;
2267 
2268  // Location of the 'friend' specifier.
2269  SourceLocation FriendLoc;
2270 
2273  FriendUnion Friend, SourceLocation FriendLoc)
2274  : Decl(Decl::FriendTemplate, DC, Loc), NumParams(Params.size()),
2275  Params(Params.data()), Friend(Friend), FriendLoc(FriendLoc) {}
2276 
2277  FriendTemplateDecl(EmptyShell Empty) : Decl(Decl::FriendTemplate, Empty) {}
2278 
2279 public:
2280  friend class ASTDeclReader;
2281 
2282  static FriendTemplateDecl *
2283  Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc,
2285  SourceLocation FriendLoc);
2286 
2287  static FriendTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2288 
2289  /// If this friend declaration names a templated type (or
2290  /// a dependent member type of a templated type), return that
2291  /// type; otherwise return null.
2293  return Friend.dyn_cast<TypeSourceInfo*>();
2294  }
2295 
2296  /// If this friend declaration names a templated function (or
2297  /// a member function of a templated type), return that type;
2298  /// otherwise return null.
2300  return Friend.dyn_cast<NamedDecl*>();
2301  }
2302 
2303  /// Retrieves the location of the 'friend' keyword.
2305  return FriendLoc;
2306  }
2307 
2309  assert(i <= NumParams);
2310  return Params[i];
2311  }
2312 
2313  unsigned getNumTemplateParameters() const {
2314  return NumParams;
2315  }
2316 
2317  // Implement isa/cast/dyncast/etc.
2318  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2319  static bool classofKind(Kind K) { return K == Decl::FriendTemplate; }
2320 };
2321 
2322 /// Declaration of an alias template.
2323 ///
2324 /// For example:
2325 /// \code
2326 /// template <typename T> using V = std::map<T*, int, MyCompare<T>>;
2327 /// \endcode
2329 protected:
2331 
2333  DeclarationName Name, TemplateParameterList *Params,
2334  NamedDecl *Decl)
2335  : RedeclarableTemplateDecl(TypeAliasTemplate, C, DC, L, Name, Params,
2336  Decl) {}
2337 
2338  CommonBase *newCommon(ASTContext &C) const override;
2339 
2341  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2342  }
2343 
2344 public:
2345  friend class ASTDeclReader;
2346  friend class ASTDeclWriter;
2347 
2348  /// Get the underlying function declaration of the template.
2350  return static_cast<TypeAliasDecl *>(TemplatedDecl);
2351  }
2352 
2353 
2355  return cast<TypeAliasTemplateDecl>(
2357  }
2359  return cast<TypeAliasTemplateDecl>(
2361  }
2362 
2363  /// Retrieve the previous declaration of this function template, or
2364  /// nullptr if no such declaration exists.
2366  return cast_or_null<TypeAliasTemplateDecl>(
2367  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2368  }
2370  return cast_or_null<TypeAliasTemplateDecl>(
2371  static_cast<const RedeclarableTemplateDecl *>(
2372  this)->getPreviousDecl());
2373  }
2374 
2376  return cast_or_null<TypeAliasTemplateDecl>(
2378  }
2379 
2380  /// Create a function template node.
2382  SourceLocation L,
2383  DeclarationName Name,
2384  TemplateParameterList *Params,
2385  NamedDecl *Decl);
2386 
2387  /// Create an empty alias template node.
2388  static TypeAliasTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2389 
2390  // Implement isa/cast/dyncast support
2391  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2392  static bool classofKind(Kind K) { return K == TypeAliasTemplate; }
2393 };
2394 
2395 /// Declaration of a function specialization at template class scope.
2396 ///
2397 /// This is a non-standard extension needed to support MSVC.
2398 ///
2399 /// For example:
2400 /// \code
2401 /// template <class T>
2402 /// class A {
2403 /// template <class U> void foo(U a) { }
2404 /// template<> void foo(int a) { }
2405 /// }
2406 /// \endcode
2407 ///
2408 /// "template<> foo(int a)" will be saved in Specialization as a normal
2409 /// CXXMethodDecl. Then during an instantiation of class A, it will be
2410 /// transformed into an actual function specialization.
2412  CXXMethodDecl *Specialization;
2413  bool HasExplicitTemplateArgs;
2414  TemplateArgumentListInfo TemplateArgs;
2415 
2417  CXXMethodDecl *FD, bool Args,
2418  TemplateArgumentListInfo TemplArgs)
2419  : Decl(Decl::ClassScopeFunctionSpecialization, DC, Loc),
2420  Specialization(FD), HasExplicitTemplateArgs(Args),
2421  TemplateArgs(std::move(TemplArgs)) {}
2422 
2424  : Decl(Decl::ClassScopeFunctionSpecialization, Empty) {}
2425 
2426  virtual void anchor();
2427 
2428 public:
2429  friend class ASTDeclReader;
2430  friend class ASTDeclWriter;
2431 
2432  CXXMethodDecl *getSpecialization() const { return Specialization; }
2433  bool hasExplicitTemplateArgs() const { return HasExplicitTemplateArgs; }
2434  const TemplateArgumentListInfo& templateArgs() const { return TemplateArgs; }
2435 
2437  DeclContext *DC,
2438  SourceLocation Loc,
2439  CXXMethodDecl *FD,
2440  bool HasExplicitTemplateArgs,
2441  TemplateArgumentListInfo TemplateArgs) {
2442  return new (C, DC) ClassScopeFunctionSpecializationDecl(
2443  DC, Loc, FD, HasExplicitTemplateArgs, std::move(TemplateArgs));
2444  }
2445 
2447  CreateDeserialized(ASTContext &Context, unsigned ID);
2448 
2449  // Implement isa/cast/dyncast/etc.
2450  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2451 
2452  static bool classofKind(Kind K) {
2453  return K == Decl::ClassScopeFunctionSpecialization;
2454  }
2455 };
2456 
2457 /// Implementation of inline functions that require the template declarations
2458 inline AnyFunctionDecl::AnyFunctionDecl(FunctionTemplateDecl *FTD)
2459  : Function(FTD) {}
2460 
2461 /// Represents a variable template specialization, which refers to
2462 /// a variable template with a given set of template arguments.
2463 ///
2464 /// Variable template specializations represent both explicit
2465 /// specializations of variable templates, as in the example below, and
2466 /// implicit instantiations of variable templates.
2467 ///
2468 /// \code
2469 /// template<typename T> constexpr T pi = T(3.1415926535897932385);
2470 ///
2471 /// template<>
2472 /// constexpr float pi<float>; // variable template specialization pi<float>
2473 /// \endcode
2475  public llvm::FoldingSetNode {
2476 
2477  /// Structure that stores information about a variable template
2478  /// specialization that was instantiated from a variable template partial
2479  /// specialization.
2480  struct SpecializedPartialSpecialization {
2481  /// The variable template partial specialization from which this
2482  /// variable template specialization was instantiated.
2483  VarTemplatePartialSpecializationDecl *PartialSpecialization;
2484 
2485  /// The template argument list deduced for the variable template
2486  /// partial specialization itself.
2487  const TemplateArgumentList *TemplateArgs;
2488  };
2489 
2490  /// The template that this specialization specializes.
2491  llvm::PointerUnion<VarTemplateDecl *, SpecializedPartialSpecialization *>
2492  SpecializedTemplate;
2493 
2494  /// Further info for explicit template specialization/instantiation.
2495  struct ExplicitSpecializationInfo {
2496  /// The type-as-written.
2497  TypeSourceInfo *TypeAsWritten = nullptr;
2498 
2499  /// The location of the extern keyword.
2500  SourceLocation ExternLoc;
2501 
2502  /// The location of the template keyword.
2503  SourceLocation TemplateKeywordLoc;
2504 
2505  ExplicitSpecializationInfo() = default;
2506  };
2507 
2508  /// Further info for explicit template specialization/instantiation.
2509  /// Does not apply to implicit specializations.
2510  ExplicitSpecializationInfo *ExplicitInfo = nullptr;
2511 
2512  /// The template arguments used to describe this specialization.
2513  const TemplateArgumentList *TemplateArgs;
2514  TemplateArgumentListInfo TemplateArgsInfo;
2515 
2516  /// The point where this template was instantiated (if any).
2517  SourceLocation PointOfInstantiation;
2518 
2519  /// The kind of specialization this declaration refers to.
2520  /// Really a value of type TemplateSpecializationKind.
2521  unsigned SpecializationKind : 3;
2522 
2523  /// Whether this declaration is a complete definition of the
2524  /// variable template specialization. We can't otherwise tell apart
2525  /// an instantiated declaration from an instantiated definition with
2526  /// no initializer.
2527  unsigned IsCompleteDefinition : 1;
2528 
2529 protected:
2531  SourceLocation StartLoc, SourceLocation IdLoc,
2532  VarTemplateDecl *SpecializedTemplate,
2533  QualType T, TypeSourceInfo *TInfo,
2534  StorageClass S,
2536 
2537  explicit VarTemplateSpecializationDecl(Kind DK, ASTContext &Context);
2538 
2539 public:
2540  friend class ASTDeclReader;
2541  friend class ASTDeclWriter;
2542  friend class VarDecl;
2543 
2545  Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2546  SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
2547  TypeSourceInfo *TInfo, StorageClass S,
2549  static VarTemplateSpecializationDecl *CreateDeserialized(ASTContext &C,
2550  unsigned ID);
2551 
2552  void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
2553  bool Qualified) const override;
2554 
2556  VarDecl *Recent = static_cast<VarDecl *>(this)->getMostRecentDecl();
2557  return cast<VarTemplateSpecializationDecl>(Recent);
2558  }
2559 
2560  /// Retrieve the template that this specialization specializes.
2561  VarTemplateDecl *getSpecializedTemplate() const;
2562 
2563  /// Retrieve the template arguments of the variable template
2564  /// specialization.
2565  const TemplateArgumentList &getTemplateArgs() const { return *TemplateArgs; }
2566 
2567  // TODO: Always set this when creating the new specialization?
2568  void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo);
2569 
2571  return TemplateArgsInfo;
2572  }
2573 
2574  /// Determine the kind of specialization that this
2575  /// declaration represents.
2577  return static_cast<TemplateSpecializationKind>(SpecializationKind);
2578  }
2579 
2581  return getSpecializationKind() == TSK_ExplicitSpecialization;
2582  }
2583 
2584  /// True if this declaration is an explicit specialization,
2585  /// explicit instantiation declaration, or explicit instantiation
2586  /// definition.
2590  }
2591 
2593  SpecializationKind = TSK;
2594  }
2595 
2596  /// Get the point of instantiation (if any), or null if none.
2598  return PointOfInstantiation;
2599  }
2600 
2602  assert(Loc.isValid() && "point of instantiation must be valid!");
2603  PointOfInstantiation = Loc;
2604  }
2605 
2606  void setCompleteDefinition() { IsCompleteDefinition = true; }
2607 
2608  /// If this variable template specialization is an instantiation of
2609  /// a template (rather than an explicit specialization), return the
2610  /// variable template or variable template partial specialization from which
2611  /// it was instantiated.
2612  llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2614  if (!isTemplateInstantiation(getSpecializationKind()))
2615  return llvm::PointerUnion<VarTemplateDecl *,
2617 
2618  return getSpecializedTemplateOrPartial();
2619  }
2620 
2621  /// Retrieve the variable template or variable template partial
2622  /// specialization which was specialized by this.
2623  llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2625  if (const auto *PartialSpec =
2626  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2627  return PartialSpec->PartialSpecialization;
2628 
2629  return SpecializedTemplate.get<VarTemplateDecl *>();
2630  }
2631 
2632  /// Retrieve the set of template arguments that should be used
2633  /// to instantiate the initializer of the variable template or variable
2634  /// template partial specialization from which this variable template
2635  /// specialization was instantiated.
2636  ///
2637  /// \returns For a variable template specialization instantiated from the
2638  /// primary template, this function will return the same template arguments
2639  /// as getTemplateArgs(). For a variable template specialization instantiated
2640  /// from a variable template partial specialization, this function will the
2641  /// return deduced template arguments for the variable template partial
2642  /// specialization itself.
2644  if (const auto *PartialSpec =
2645  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2646  return *PartialSpec->TemplateArgs;
2647 
2648  return getTemplateArgs();
2649  }
2650 
2651  /// Note that this variable template specialization is actually an
2652  /// instantiation of the given variable template partial specialization whose
2653  /// template arguments have been deduced.
2655  const TemplateArgumentList *TemplateArgs) {
2656  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
2657  "Already set to a variable template partial specialization!");
2658  auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
2659  PS->PartialSpecialization = PartialSpec;
2660  PS->TemplateArgs = TemplateArgs;
2661  SpecializedTemplate = PS;
2662  }
2663 
2664  /// Note that this variable template specialization is an instantiation
2665  /// of the given variable template.
2667  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
2668  "Previously set to a variable template partial specialization!");
2669  SpecializedTemplate = TemplDecl;
2670  }
2671 
2672  /// Sets the type of this specialization as it was written by
2673  /// the user.
2675  if (!ExplicitInfo)
2676  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2677  ExplicitInfo->TypeAsWritten = T;
2678  }
2679 
2680  /// Gets the type of this specialization as it was written by
2681  /// the user, if it was so written.
2683  return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
2684  }
2685 
2686  /// Gets the location of the extern keyword, if present.
2688  return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
2689  }
2690 
2691  /// Sets the location of the extern keyword.
2693  if (!ExplicitInfo)
2694  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2695  ExplicitInfo->ExternLoc = Loc;
2696  }
2697 
2698  /// Sets the location of the template keyword.
2700  if (!ExplicitInfo)
2701  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2702  ExplicitInfo->TemplateKeywordLoc = Loc;
2703  }
2704 
2705  /// Gets the location of the template keyword, if present.
2707  return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
2708  }
2709 
2710  void Profile(llvm::FoldingSetNodeID &ID) const {
2711  Profile(ID, TemplateArgs->asArray(), getASTContext());
2712  }
2713 
2714  static void Profile(llvm::FoldingSetNodeID &ID,
2715  ArrayRef<TemplateArgument> TemplateArgs,
2716  ASTContext &Context) {
2717  ID.AddInteger(TemplateArgs.size());
2718  for (const TemplateArgument &TemplateArg : TemplateArgs)
2719  TemplateArg.Profile(ID, Context);
2720  }
2721 
2722  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2723 
2724  static bool classofKind(Kind K) {
2725  return K >= firstVarTemplateSpecialization &&
2726  K <= lastVarTemplateSpecialization;
2727  }
2728 };
2729 
2732  /// The list of template parameters
2733  TemplateParameterList *TemplateParams = nullptr;
2734 
2735  /// The source info for the template arguments as written.
2736  /// FIXME: redundant with TypeAsWritten?
2737  const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
2738 
2739  /// The variable template partial specialization from which this
2740  /// variable template partial specialization was instantiated.
2741  ///
2742  /// The boolean value will be true to indicate that this variable template
2743  /// partial specialization was specialized at this level.
2744  llvm::PointerIntPair<VarTemplatePartialSpecializationDecl *, 1, bool>
2745  InstantiatedFromMember;
2746 
2748  ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2749  SourceLocation IdLoc, TemplateParameterList *Params,
2750  VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
2752  const ASTTemplateArgumentListInfo *ArgInfos);
2753 
2755  : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization,
2756  Context),
2757  InstantiatedFromMember(nullptr, false) {}
2758 
2759  void anchor() override;
2760 
2761 public:
2762  friend class ASTDeclReader;
2763  friend class ASTDeclWriter;
2764 
2766  Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2767  SourceLocation IdLoc, TemplateParameterList *Params,
2768  VarTemplateDecl *SpecializedTemplate, QualType T,
2770  const TemplateArgumentListInfo &ArgInfos);
2771 
2772  static VarTemplatePartialSpecializationDecl *CreateDeserialized(ASTContext &C,
2773  unsigned ID);
2774 
2776  return cast<VarTemplatePartialSpecializationDecl>(
2777  static_cast<VarTemplateSpecializationDecl *>(
2778  this)->getMostRecentDecl());
2779  }
2780 
2781  /// Get the list of template parameters
2783  return TemplateParams;
2784  }
2785 
2786  /// Get the template arguments as written.
2788  return ArgsAsWritten;
2789  }
2790 
2791  /// Retrieve the member variable template partial specialization from
2792  /// which this particular variable template partial specialization was
2793  /// instantiated.
2794  ///
2795  /// \code
2796  /// template<typename T>
2797  /// struct Outer {
2798  /// template<typename U> U Inner;
2799  /// template<typename U> U* Inner<U*> = (U*)(0); // #1
2800  /// };
2801  ///
2802  /// template int* Outer<float>::Inner<int*>;
2803  /// \endcode
2804  ///
2805  /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
2806  /// end up instantiating the partial specialization
2807  /// \c Outer<float>::Inner<U*>, which itself was instantiated from the
2808  /// variable template partial specialization \c Outer<T>::Inner<U*>. Given
2809  /// \c Outer<float>::Inner<U*>, this function would return
2810  /// \c Outer<T>::Inner<U*>.
2812  const auto *First =
2813  cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2814  return First->InstantiatedFromMember.getPointer();
2815  }
2816 
2817  void
2819  auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2820  First->InstantiatedFromMember.setPointer(PartialSpec);
2821  }
2822 
2823  /// Determines whether this variable template partial specialization
2824  /// was a specialization of a member partial specialization.
2825  ///
2826  /// In the following example, the member template partial specialization
2827  /// \c X<int>::Inner<T*> is a member specialization.
2828  ///
2829  /// \code
2830  /// template<typename T>
2831  /// struct X {
2832  /// template<typename U> U Inner;
2833  /// template<typename U> U* Inner<U*> = (U*)(0);
2834  /// };
2835  ///
2836  /// template<> template<typename T>
2837  /// U* X<int>::Inner<T*> = (T*)(0) + 1;
2838  /// \endcode
2840  const auto *First =
2841  cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2842  return First->InstantiatedFromMember.getInt();
2843  }
2844 
2845  /// Note that this member template is a specialization.
2847  auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
2848  assert(First->InstantiatedFromMember.getPointer() &&
2849  "Only member templates can be member template specializations");
2850  return First->InstantiatedFromMember.setInt(true);
2851  }
2852 
2853  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2854 
2855  static bool classofKind(Kind K) {
2856  return K == VarTemplatePartialSpecialization;
2857  }
2858 };
2859 
2860 /// Declaration of a variable template.
2862 protected:
2863  /// Data that is common to all of the declarations of a given
2864  /// variable template.
2865  struct Common : CommonBase {
2866  /// The variable template specializations for this variable
2867  /// template, including explicit specializations and instantiations.
2868  llvm::FoldingSetVector<VarTemplateSpecializationDecl> Specializations;
2869 
2870  /// The variable template partial specializations for this variable
2871  /// template.
2872  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>
2874 
2875  Common() = default;
2876  };
2877 
2878  /// Retrieve the set of specializations of this variable template.
2879  llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
2880  getSpecializations() const;
2881 
2882  /// Retrieve the set of partial specializations of this class
2883  /// template.
2884  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
2885  getPartialSpecializations();
2886 
2888  DeclarationName Name, TemplateParameterList *Params,
2889  NamedDecl *Decl)
2890  : RedeclarableTemplateDecl(VarTemplate, C, DC, L, Name, Params, Decl) {}
2891 
2892  CommonBase *newCommon(ASTContext &C) const override;
2893 
2895  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2896  }
2897 
2898 public:
2899  friend class ASTDeclReader;
2900  friend class ASTDeclWriter;
2901 
2902  /// Load any lazily-loaded specializations from the external source.
2903  void LoadLazySpecializations() const;
2904 
2905  /// Get the underlying variable declarations of the template.
2907  return static_cast<VarDecl *>(TemplatedDecl);
2908  }
2909 
2910  /// Returns whether this template declaration defines the primary
2911  /// variable pattern.
2913  return getTemplatedDecl()->isThisDeclarationADefinition();
2914  }
2915 
2917 
2918  /// Create a variable template node.
2919  static VarTemplateDecl *Create(ASTContext &C, DeclContext *DC,
2921  TemplateParameterList *Params,
2922  VarDecl *Decl);
2923 
2924  /// Create an empty variable template node.
2925  static VarTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2926 
2927  /// Return the specialization with the provided arguments if it exists,
2928  /// otherwise return the insertion point.
2930  findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2931 
2932  /// Insert the specified specialization knowing that it is not already
2933  /// in. InsertPos must be obtained from findSpecialization.
2934  void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos);
2935 
2937  return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
2938  }
2940  return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
2941  }
2942 
2943  /// Retrieve the previous declaration of this variable template, or
2944  /// nullptr if no such declaration exists.
2946  return cast_or_null<VarTemplateDecl>(
2947  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2948  }
2950  return cast_or_null<VarTemplateDecl>(
2951  static_cast<const RedeclarableTemplateDecl *>(
2952  this)->getPreviousDecl());
2953  }
2954 
2956  return cast<VarTemplateDecl>(
2957  static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
2958  }
2960  return const_cast<VarTemplateDecl *>(this)->getMostRecentDecl();
2961  }
2962 
2964  return cast_or_null<VarTemplateDecl>(
2966  }
2967 
2968  /// Return the partial specialization with the provided arguments if it
2969  /// exists, otherwise return the insertion point.
2971  findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2972 
2973  /// Insert the specified partial specialization knowing that it is not
2974  /// already in. InsertPos must be obtained from findPartialSpecialization.
2975  void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D,
2976  void *InsertPos);
2977 
2978  /// Retrieve the partial specializations as an ordered list.
2979  void getPartialSpecializations(
2981 
2982  /// Find a variable template partial specialization which was
2983  /// instantiated
2984  /// from the given member partial specialization.
2985  ///
2986  /// \param D a member variable template partial specialization.
2987  ///
2988  /// \returns the variable template partial specialization which was
2989  /// instantiated
2990  /// from the given member partial specialization, or nullptr if no such
2991  /// partial specialization exists.
2992  VarTemplatePartialSpecializationDecl *findPartialSpecInstantiatedFromMember(
2994 
2996  using spec_range = llvm::iterator_range<spec_iterator>;
2997 
2999  return spec_range(spec_begin(), spec_end());
3000  }
3001 
3003  return makeSpecIterator(getSpecializations(), false);
3004  }
3005 
3007  return makeSpecIterator(getSpecializations(), true);
3008  }
3009 
3010  // Implement isa/cast/dyncast support
3011  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3012  static bool classofKind(Kind K) { return K == VarTemplate; }
3013 };
3014 
3016  if (auto *PD = P.dyn_cast<TemplateTypeParmDecl *>())
3017  return PD;
3018  if (auto *PD = P.dyn_cast<NonTypeTemplateParmDecl *>())
3019  return PD;
3020  return P.get<TemplateTemplateParmDecl *>();
3021 }
3022 
3024  auto *TD = dyn_cast<TemplateDecl>(D);
3025  return TD && (isa<ClassTemplateDecl>(TD) ||
3026  isa<ClassTemplatePartialSpecializationDecl>(TD) ||
3027  isa<TypeAliasTemplateDecl>(TD) ||
3028  isa<TemplateTemplateParmDecl>(TD))
3029  ? TD
3030  : nullptr;
3031 }
3032 
3033 } // namespace clang
3034 
3035 #endif // LLVM_CLANG_AST_DECLTEMPLATE_H
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:1739
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:937
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:642
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:87
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:601
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:154
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:2072
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:552
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:2883
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:278
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
Definition: DeclBase.h:103
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3047
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
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:2041
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:5341
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:5017
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:355
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
The name of a declaration.
Kind getKind() const
Definition: DeclBase.h:421
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:99
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:90
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