clang  10.0.0git
DeclTemplate.h
Go to the documentation of this file.
1 //===- DeclTemplate.h - Classes for representing C++ templates --*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 /// \file
10 /// Defines the C++ template declaration subclasses.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_DECLTEMPLATE_H
15 #define LLVM_CLANG_AST_DECLTEMPLATE_H
16 
17 #include "clang/AST/ASTConcept.h"
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 ConceptDecl;
56 class UnresolvedSetImpl;
57 class VarTemplateDecl;
58 class VarTemplatePartialSpecializationDecl;
59 
60 /// Stores a template parameter of any kind.
61 using TemplateParameter =
62  llvm::PointerUnion<TemplateTypeParmDecl *, NonTypeTemplateParmDecl *,
64 
66 
67 /// Stores a list of template parameters for a TemplateDecl and its
68 /// derived classes.
70  : private llvm::TrailingObjects<TemplateParameterList, NamedDecl *,
71  Expr *> {
72  /// The location of the 'template' keyword.
73  SourceLocation TemplateLoc;
74 
75  /// The locations of the '<' and '>' angle brackets.
76  SourceLocation LAngleLoc, RAngleLoc;
77 
78  /// The number of template parameters in this template
79  /// parameter list.
80  unsigned NumParams : 30;
81 
82  /// Whether this template parameter list contains an unexpanded parameter
83  /// pack.
84  unsigned ContainsUnexpandedParameterPack : 1;
85 
86  /// Whether this template parameter list has a requires clause.
87  unsigned HasRequiresClause : 1;
88 
89  /// Whether any of the template parameters has constrained-parameter
90  /// constraint-expression.
91  unsigned HasConstrainedParameters : 1;
92 
93 protected:
95  SourceLocation LAngleLoc, ArrayRef<NamedDecl *> Params,
96  SourceLocation RAngleLoc, Expr *RequiresClause);
97 
98  size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
99  return NumParams;
100  }
101 
102  size_t numTrailingObjects(OverloadToken<Expr *>) const {
103  return HasRequiresClause ? 1 : 0;
104  }
105 
106 public:
107  template <size_t N, bool HasRequiresClause>
110 
111  static TemplateParameterList *Create(const ASTContext &C,
112  SourceLocation TemplateLoc,
113  SourceLocation LAngleLoc,
114  ArrayRef<NamedDecl *> Params,
115  SourceLocation RAngleLoc,
116  Expr *RequiresClause);
117 
118  /// Iterates through the template parameters in this list.
119  using iterator = NamedDecl **;
120 
121  /// Iterates through the template parameters in this list.
122  using const_iterator = NamedDecl * const *;
123 
124  iterator begin() { return getTrailingObjects<NamedDecl *>(); }
125  const_iterator begin() const { return getTrailingObjects<NamedDecl *>(); }
126  iterator end() { return begin() + NumParams; }
127  const_iterator end() const { return begin() + NumParams; }
128 
129  unsigned size() const { return NumParams; }
130 
132  return llvm::makeArrayRef(begin(), end());
133  }
135  return llvm::makeArrayRef(begin(), size());
136  }
137 
138  NamedDecl* getParam(unsigned Idx) {
139  assert(Idx < size() && "Template parameter index out-of-range");
140  return begin()[Idx];
141  }
142  const NamedDecl* getParam(unsigned Idx) const {
143  assert(Idx < size() && "Template parameter index out-of-range");
144  return begin()[Idx];
145  }
146 
147  /// Returns the minimum number of arguments needed to form a
148  /// template specialization.
149  ///
150  /// This may be fewer than the number of template parameters, if some of
151  /// the parameters have default arguments or if there is a parameter pack.
152  unsigned getMinRequiredArguments() const;
153 
154  /// Get the depth of this template parameter list in the set of
155  /// template parameter lists.
156  ///
157  /// The first template parameter list in a declaration will have depth 0,
158  /// the second template parameter list will have depth 1, etc.
159  unsigned getDepth() const;
160 
161  /// Determine whether this template parameter list contains an
162  /// unexpanded parameter pack.
164  return ContainsUnexpandedParameterPack;
165  }
166 
167  /// Determine whether this template parameter list contains a parameter pack.
168  bool hasParameterPack() const {
169  for (const NamedDecl *P : asArray())
170  if (P->isParameterPack())
171  return true;
172  return false;
173  }
174 
175  /// The constraint-expression of the associated requires-clause.
177  return HasRequiresClause ? getTrailingObjects<Expr *>()[0] : nullptr;
178  }
179 
180  /// The constraint-expression of the associated requires-clause.
181  const Expr *getRequiresClause() const {
182  return HasRequiresClause ? getTrailingObjects<Expr *>()[0] : nullptr;
183  }
184 
185  /// \brief All associated constraints derived from this template parameter
186  /// list, including the requires clause and any constraints derived from
187  /// constrained-parameters.
188  ///
189  /// The constraints in the resulting list are to be treated as if in a
190  /// conjunction ("and").
192 
193  bool hasAssociatedConstraints() const;
194 
195  SourceLocation getTemplateLoc() const { return TemplateLoc; }
196  SourceLocation getLAngleLoc() const { return LAngleLoc; }
197  SourceLocation getRAngleLoc() const { return RAngleLoc; }
198 
199  SourceRange getSourceRange() const LLVM_READONLY {
200  return SourceRange(TemplateLoc, RAngleLoc);
201  }
202 
203  void print(raw_ostream &Out, const ASTContext &Context,
204  bool OmitTemplateKW = false) const;
205  void print(raw_ostream &Out, const ASTContext &Context,
206  const PrintingPolicy &Policy, bool OmitTemplateKW = false) const;
207 
208 public:
209  // FIXME: workaround for MSVC 2013; remove when no longer needed
210  using FixedSizeStorageOwner = TrailingObjects::FixedSizeStorageOwner;
211 };
212 
213 /// Stores a list of template parameters and the associated
214 /// requires-clause (if any) for a TemplateDecl and its derived classes.
215 /// Suitable for creating on the stack.
216 template <size_t N, bool HasRequiresClause>
219  typename TemplateParameterList::FixedSizeStorage<
220  NamedDecl *, Expr *>::with_counts<
221  N, HasRequiresClause ? 1u : 0u
222  >::type storage;
223 
224 public:
226  SourceLocation TemplateLoc,
227  SourceLocation LAngleLoc,
228  ArrayRef<NamedDecl *> Params,
229  SourceLocation RAngleLoc,
230  Expr *RequiresClause)
232  (assert(N == Params.size()),
233  assert(HasRequiresClause == (RequiresClause != nullptr)),
234  new (static_cast<void *>(&storage)) TemplateParameterList(C,
235  TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause))) {}
236 };
237 
238 /// A template argument list.
240  : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {
241  /// The template argument list.
242  const TemplateArgument *Arguments;
243 
244  /// The number of template arguments in this template
245  /// argument list.
246  unsigned NumArguments;
247 
248  // Constructs an instance with an internal Argument list, containing
249  // a copy of the Args array. (Called by CreateCopy)
251 
252 public:
254 
255  TemplateArgumentList(const TemplateArgumentList &) = delete;
256  TemplateArgumentList &operator=(const TemplateArgumentList &) = delete;
257 
258  /// Type used to indicate that the template argument list itself is a
259  /// stack object. It does not own its template arguments.
260  enum OnStackType { OnStack };
261 
262  /// Create a new template argument list that copies the given set of
263  /// template arguments.
264  static TemplateArgumentList *CreateCopy(ASTContext &Context,
266 
267  /// Construct a new, temporary template argument list on the stack.
268  ///
269  /// The template argument list does not own the template arguments
270  /// provided.
272  : Arguments(Args.data()), NumArguments(Args.size()) {}
273 
274  /// Produces a shallow copy of the given template argument list.
275  ///
276  /// This operation assumes that the input argument list outlives it.
277  /// This takes the list as a pointer to avoid looking like a copy
278  /// constructor, since this really really isn't safe to use that
279  /// way.
281  : Arguments(Other->data()), NumArguments(Other->size()) {}
282 
283  /// Retrieve the template argument at a given index.
284  const TemplateArgument &get(unsigned Idx) const {
285  assert(Idx < NumArguments && "Invalid template argument index");
286  return data()[Idx];
287  }
288 
289  /// Retrieve the template argument at a given index.
290  const TemplateArgument &operator[](unsigned Idx) const { return get(Idx); }
291 
292  /// Produce this as an array ref.
294  return llvm::makeArrayRef(data(), size());
295  }
296 
297  /// Retrieve the number of template arguments in this
298  /// template argument list.
299  unsigned size() const { return NumArguments; }
300 
301  /// Retrieve a pointer to the template argument list.
302  const TemplateArgument *data() const { return Arguments; }
303 };
304 
306 
307 /// Storage for a default argument. This is conceptually either empty, or an
308 /// argument value, or a pointer to a previous declaration that had a default
309 /// argument.
310 ///
311 /// However, this is complicated by modules: while we require all the default
312 /// arguments for a template to be equivalent, there may be more than one, and
313 /// we need to track all the originating parameters to determine if the default
314 /// argument is visible.
315 template<typename ParmDecl, typename ArgType>
317  /// Storage for both the value *and* another parameter from which we inherit
318  /// the default argument. This is used when multiple default arguments for a
319  /// parameter are merged together from different modules.
320  struct Chain {
321  ParmDecl *PrevDeclWithDefaultArg;
322  ArgType Value;
323  };
324  static_assert(sizeof(Chain) == sizeof(void *) * 2,
325  "non-pointer argument type?");
326 
327  llvm::PointerUnion<ArgType, ParmDecl*, Chain*> ValueOrInherited;
328 
329  static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {
330  const DefaultArgStorage &Storage = Parm->getDefaultArgStorage();
331  if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl *>())
332  Parm = Prev;
333  assert(!Parm->getDefaultArgStorage()
334  .ValueOrInherited.template is<ParmDecl *>() &&
335  "should only be one level of indirection");
336  return Parm;
337  }
338 
339 public:
340  DefaultArgStorage() : ValueOrInherited(ArgType()) {}
341 
342  /// Determine whether there is a default argument for this parameter.
343  bool isSet() const { return !ValueOrInherited.isNull(); }
344 
345  /// Determine whether the default argument for this parameter was inherited
346  /// from a previous declaration of the same entity.
347  bool isInherited() const { return ValueOrInherited.template is<ParmDecl*>(); }
348 
349  /// Get the default argument's value. This does not consider whether the
350  /// default argument is visible.
351  ArgType get() const {
352  const DefaultArgStorage *Storage = this;
353  if (const auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl *>())
354  Storage = &Prev->getDefaultArgStorage();
355  if (const auto *C = Storage->ValueOrInherited.template dyn_cast<Chain *>())
356  return C->Value;
357  return Storage->ValueOrInherited.template get<ArgType>();
358  }
359 
360  /// Get the parameter from which we inherit the default argument, if any.
361  /// This is the parameter on which the default argument was actually written.
362  const ParmDecl *getInheritedFrom() const {
363  if (const auto *D = ValueOrInherited.template dyn_cast<ParmDecl *>())
364  return D;
365  if (const auto *C = ValueOrInherited.template dyn_cast<Chain *>())
366  return C->PrevDeclWithDefaultArg;
367  return nullptr;
368  }
369 
370  /// Set the default argument.
371  void set(ArgType Arg) {
372  assert(!isSet() && "default argument already set");
373  ValueOrInherited = Arg;
374  }
375 
376  /// Set that the default argument was inherited from another parameter.
377  void setInherited(const ASTContext &C, ParmDecl *InheritedFrom) {
378  assert(!isInherited() && "default argument already inherited");
379  InheritedFrom = getParmOwningDefaultArg(InheritedFrom);
380  if (!isSet())
381  ValueOrInherited = InheritedFrom;
382  else
383  ValueOrInherited = new (allocateDefaultArgStorageChain(C))
384  Chain{InheritedFrom, ValueOrInherited.template get<ArgType>()};
385  }
386 
387  /// Remove the default argument, even if it was inherited.
388  void clear() {
389  ValueOrInherited = ArgType();
390  }
391 };
392 
393 //===----------------------------------------------------------------------===//
394 // Kinds of Templates
395 //===----------------------------------------------------------------------===//
396 
397 /// \brief The base class of all kinds of template declarations (e.g.,
398 /// class, function, etc.).
399 ///
400 /// The TemplateDecl class stores the list of template parameters and a
401 /// reference to the templated scoped declaration: the underlying AST node.
402 class TemplateDecl : public NamedDecl {
403  void anchor() override;
404 
405 protected:
406  // Construct a template decl with name, parameters, and templated element.
409 
410  // Construct a template decl with the given name and parameters.
411  // Used when there is no templated element (e.g., for tt-params).
413  TemplateParameterList *Params)
414  : TemplateDecl(DK, DC, L, Name, Params, nullptr) {}
415 
416 public:
417  friend class ASTDeclReader;
418  friend class ASTDeclWriter;
419 
420  /// Get the list of template parameters
422  return TemplateParams;
423  }
424 
425  /// \brief Get the total constraint-expression associated with this template,
426  /// including constraint-expressions derived from the requires-clause,
427  /// trailing requires-clause (for functions and methods) and constrained
428  /// template parameters.
430 
431  bool hasAssociatedConstraints() const;
432 
433  /// Get the underlying, templated declaration.
434  NamedDecl *getTemplatedDecl() const { return TemplatedDecl; }
435 
436  // Implement isa/cast/dyncast/etc.
437  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
438 
439  static bool classofKind(Kind K) {
440  return K >= firstTemplate && K <= lastTemplate;
441  }
442 
443  SourceRange getSourceRange() const override LLVM_READONLY {
444  return SourceRange(getTemplateParameters()->getTemplateLoc(),
445  TemplatedDecl->getSourceRange().getEnd());
446  }
447 
448 protected:
451 
453  TemplateParams = TParams;
454  }
455 
456 public:
457  /// Initialize the underlying templated declaration and
458  /// template parameters.
459  void init(NamedDecl *templatedDecl, TemplateParameterList* templateParams) {
460  assert(!TemplatedDecl && "TemplatedDecl already set!");
461  assert(!TemplateParams && "TemplateParams already set!");
462  TemplatedDecl = templatedDecl;
463  TemplateParams = templateParams;
464  }
465 };
466 
467 /// Provides information about a function template specialization,
468 /// which is a FunctionDecl that has been explicitly specialization or
469 /// instantiated from a function template.
471  : public llvm::FoldingSetNode,
472  private llvm::TrailingObjects<FunctionTemplateSpecializationInfo,
473  MemberSpecializationInfo *> {
474  /// The function template specialization that this structure describes and a
475  /// flag indicating if the function is a member specialization.
476  llvm::PointerIntPair<FunctionDecl *, 1, bool> Function;
477 
478  /// The function template from which this function template
479  /// specialization was generated.
480  ///
481  /// The two bits contain the top 4 values of TemplateSpecializationKind.
482  llvm::PointerIntPair<FunctionTemplateDecl *, 2> Template;
483 
484 public:
485  /// The template arguments used to produce the function template
486  /// specialization from the function template.
488 
489  /// The template arguments as written in the sources, if provided.
490  /// FIXME: Normally null; tail-allocate this.
492 
493  /// The point at which this function template specialization was
494  /// first instantiated.
496 
497 private:
499  FunctionDecl *FD, FunctionTemplateDecl *Template,
500  TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs,
501  const ASTTemplateArgumentListInfo *TemplateArgsAsWritten,
503  : Function(FD, MSInfo ? 1 : 0), Template(Template, TSK - 1),
504  TemplateArguments(TemplateArgs),
505  TemplateArgumentsAsWritten(TemplateArgsAsWritten),
506  PointOfInstantiation(POI) {
507  if (MSInfo)
508  getTrailingObjects<MemberSpecializationInfo *>()[0] = MSInfo;
509  }
510 
511  size_t numTrailingObjects(OverloadToken<MemberSpecializationInfo*>) const {
512  return Function.getInt();
513  }
514 
515 public:
517 
521  const TemplateArgumentList *TemplateArgs,
522  const TemplateArgumentListInfo *TemplateArgsAsWritten,
524 
525  /// Retrieve the declaration of the function template specialization.
526  FunctionDecl *getFunction() const { return Function.getPointer(); }
527 
528  /// Retrieve the template from which this function was specialized.
529  FunctionTemplateDecl *getTemplate() const { return Template.getPointer(); }
530 
531  /// Determine what kind of template specialization this is.
533  return (TemplateSpecializationKind)(Template.getInt() + 1);
534  }
535 
538  }
539 
540  /// True if this declaration is an explicit specialization,
541  /// explicit instantiation declaration, or explicit instantiation
542  /// definition.
546  }
547 
548  /// Set the template specialization kind.
550  assert(TSK != TSK_Undeclared &&
551  "Cannot encode TSK_Undeclared for a function template specialization");
552  Template.setInt(TSK - 1);
553  }
554 
555  /// Retrieve the first point of instantiation of this function
556  /// template specialization.
557  ///
558  /// The point of instantiation may be an invalid source location if this
559  /// function has yet to be instantiated.
561  return PointOfInstantiation;
562  }
563 
564  /// Set the (first) point of instantiation of this function template
565  /// specialization.
567  PointOfInstantiation = POI;
568  }
569 
570  /// Get the specialization info if this function template specialization is
571  /// also a member specialization:
572  ///
573  /// \code
574  /// template<typename> struct A {
575  /// template<typename> void f();
576  /// template<> void f<int>(); // ClassScopeFunctionSpecializationDecl
577  /// };
578  /// \endcode
579  ///
580  /// Here, A<int>::f<int> is a function template specialization that is
581  /// an explicit specialization of A<int>::f, but it's also a member
582  /// specialization (an implicit instantiation in this case) of A::f<int>.
583  /// Further:
584  ///
585  /// \code
586  /// template<> template<> void A<int>::f<int>() {}
587  /// \endcode
588  ///
589  /// ... declares a function template specialization that is an explicit
590  /// specialization of A<int>::f, and is also an explicit member
591  /// specialization of A::f<int>.
592  ///
593  /// Note that the TemplateSpecializationKind of the MemberSpecializationInfo
594  /// need not be the same as that returned by getTemplateSpecializationKind(),
595  /// and represents the relationship between the function and the class-scope
596  /// explicit specialization in the original templated class -- whereas our
597  /// TemplateSpecializationKind represents the relationship between the
598  /// function and the function template, and should always be
599  /// TSK_ExplicitSpecialization whenever we have MemberSpecializationInfo.
601  return numTrailingObjects(OverloadToken<MemberSpecializationInfo *>())
602  ? getTrailingObjects<MemberSpecializationInfo *>()[0]
603  : nullptr;
604  }
605 
606  void Profile(llvm::FoldingSetNodeID &ID) {
607  Profile(ID, TemplateArguments->asArray(), getFunction()->getASTContext());
608  }
609 
610  static void
611  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
612  ASTContext &Context) {
613  ID.AddInteger(TemplateArgs.size());
614  for (const TemplateArgument &TemplateArg : TemplateArgs)
615  TemplateArg.Profile(ID, Context);
616  }
617 };
618 
619 /// Provides information a specialization of a member of a class
620 /// template, which may be a member function, static data member,
621 /// member class or member enumeration.
623  // The member declaration from which this member was instantiated, and the
624  // manner in which the instantiation occurred (in the lower two bits).
625  llvm::PointerIntPair<NamedDecl *, 2> MemberAndTSK;
626 
627  // The point at which this member was first instantiated.
628  SourceLocation PointOfInstantiation;
629 
630 public:
631  explicit
634  : MemberAndTSK(IF, TSK - 1), PointOfInstantiation(POI) {
635  assert(TSK != TSK_Undeclared &&
636  "Cannot encode undeclared template specializations for members");
637  }
638 
639  /// Retrieve the member declaration from which this member was
640  /// instantiated.
641  NamedDecl *getInstantiatedFrom() const { return MemberAndTSK.getPointer(); }
642 
643  /// Determine what kind of template specialization this is.
645  return (TemplateSpecializationKind)(MemberAndTSK.getInt() + 1);
646  }
647 
650  }
651 
652  /// Set the template specialization kind.
654  assert(TSK != TSK_Undeclared &&
655  "Cannot encode undeclared template specializations for members");
656  MemberAndTSK.setInt(TSK - 1);
657  }
658 
659  /// Retrieve the first point of instantiation of this member.
660  /// If the point of instantiation is an invalid location, then this member
661  /// has not yet been instantiated.
663  return PointOfInstantiation;
664  }
665 
666  /// Set the first point of instantiation.
668  PointOfInstantiation = POI;
669  }
670 };
671 
672 /// Provides information about a dependent function-template
673 /// specialization declaration.
674 ///
675 /// Since explicit function template specialization and instantiation
676 /// declarations can only appear in namespace scope, and you can only
677 /// specialize a member of a fully-specialized class, the only way to
678 /// get one of these is in a friend declaration like the following:
679 ///
680 /// \code
681 /// template <class T> void foo(T);
682 /// template <class T> class A {
683 /// friend void foo<>(T);
684 /// };
685 /// \endcode
687  : private llvm::TrailingObjects<DependentFunctionTemplateSpecializationInfo,
688  TemplateArgumentLoc,
689  FunctionTemplateDecl *> {
690  /// The number of potential template candidates.
691  unsigned NumTemplates;
692 
693  /// The number of template arguments.
694  unsigned NumArgs;
695 
696  /// The locations of the left and right angle brackets.
697  SourceRange AngleLocs;
698 
699  size_t numTrailingObjects(OverloadToken<TemplateArgumentLoc>) const {
700  return NumArgs;
701  }
702  size_t numTrailingObjects(OverloadToken<FunctionTemplateDecl *>) const {
703  return NumTemplates;
704  }
705 
707  const UnresolvedSetImpl &Templates,
708  const TemplateArgumentListInfo &TemplateArgs);
709 
710 public:
712 
714  Create(ASTContext &Context, const UnresolvedSetImpl &Templates,
715  const TemplateArgumentListInfo &TemplateArgs);
716 
717  /// Returns the number of function templates that this might
718  /// be a specialization of.
719  unsigned getNumTemplates() const { return NumTemplates; }
720 
721  /// Returns the i'th template candidate.
722  FunctionTemplateDecl *getTemplate(unsigned I) const {
723  assert(I < getNumTemplates() && "template index out of range");
724  return getTrailingObjects<FunctionTemplateDecl *>()[I];
725  }
726 
727  /// Returns the explicit template arguments that were given.
729  return getTrailingObjects<TemplateArgumentLoc>();
730  }
731 
732  /// Returns the number of explicit template arguments that were given.
733  unsigned getNumTemplateArgs() const { return NumArgs; }
734 
735  /// Returns the nth template argument.
736  const TemplateArgumentLoc &getTemplateArg(unsigned I) const {
737  assert(I < getNumTemplateArgs() && "template arg index out of range");
738  return getTemplateArgs()[I];
739  }
740 
742  return AngleLocs.getBegin();
743  }
744 
746  return AngleLocs.getEnd();
747  }
748 };
749 
750 /// Declaration of a redeclarable template.
752  public Redeclarable<RedeclarableTemplateDecl>
753 {
755 
756  RedeclarableTemplateDecl *getNextRedeclarationImpl() override {
757  return getNextRedeclaration();
758  }
759 
760  RedeclarableTemplateDecl *getPreviousDeclImpl() override {
761  return getPreviousDecl();
762  }
763 
764  RedeclarableTemplateDecl *getMostRecentDeclImpl() override {
765  return getMostRecentDecl();
766  }
767 
768  void anchor() override;
769 protected:
770  template <typename EntryType> struct SpecEntryTraits {
771  using DeclType = EntryType;
772 
773  static DeclType *getDecl(EntryType *D) {
774  return D;
775  }
776 
778  return D->getTemplateArgs().asArray();
779  }
780  };
781 
782  template <typename EntryType, typename SETraits = SpecEntryTraits<EntryType>,
783  typename DeclType = typename SETraits::DeclType>
785  : llvm::iterator_adaptor_base<
786  SpecIterator<EntryType, SETraits, DeclType>,
787  typename llvm::FoldingSetVector<EntryType>::iterator,
788  typename std::iterator_traits<typename llvm::FoldingSetVector<
789  EntryType>::iterator>::iterator_category,
790  DeclType *, ptrdiff_t, DeclType *, DeclType *> {
791  SpecIterator() = default;
792  explicit SpecIterator(
793  typename llvm::FoldingSetVector<EntryType>::iterator SetIter)
794  : SpecIterator::iterator_adaptor_base(std::move(SetIter)) {}
795 
796  DeclType *operator*() const {
797  return SETraits::getDecl(&*this->I)->getMostRecentDecl();
798  }
799 
800  DeclType *operator->() const { return **this; }
801  };
802 
803  template <typename EntryType>
805  makeSpecIterator(llvm::FoldingSetVector<EntryType> &Specs, bool isEnd) {
806  return SpecIterator<EntryType>(isEnd ? Specs.end() : Specs.begin());
807  }
808 
809  void loadLazySpecializationsImpl() const;
810 
811  template <class EntryType, typename ...ProfileArguments>
813  findSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs,
814  void *&InsertPos, ProfileArguments &&...ProfileArgs);
815 
816  template <class Derived, class EntryType>
817  void addSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs,
818  EntryType *Entry, void *InsertPos);
819 
820  struct CommonBase {
821  CommonBase() : InstantiatedFromMember(nullptr, false) {}
822 
823  /// The template from which this was most
824  /// directly instantiated (or null).
825  ///
826  /// The boolean value indicates whether this template
827  /// was explicitly specialized.
828  llvm::PointerIntPair<RedeclarableTemplateDecl*, 1, bool>
830 
831  /// If non-null, points to an array of specializations (including
832  /// partial specializations) known only by their external declaration IDs.
833  ///
834  /// The first value in the array is the number of specializations/partial
835  /// specializations that follow.
836  uint32_t *LazySpecializations = nullptr;
837  };
838 
839  /// Pointer to the common data shared by all declarations of this
840  /// template.
841  mutable CommonBase *Common = nullptr;
842 
843  /// Retrieves the "common" pointer shared by all (re-)declarations of
844  /// the same template. Calling this routine may implicitly allocate memory
845  /// for the common pointer.
846  CommonBase *getCommonPtr() const;
847 
848  virtual CommonBase *newCommon(ASTContext &C) const = 0;
849 
850  // Construct a template decl with name, parameters, and templated element.
854  : TemplateDecl(DK, DC, L, Name, Params, Decl), redeclarable_base(C) {}
855 
856 public:
857  friend class ASTDeclReader;
858  friend class ASTDeclWriter;
859  friend class ASTReader;
860  template <class decl_type> friend class RedeclarableTemplate;
861 
862  /// Retrieves the canonical declaration of this template.
864  return getFirstDecl();
865  }
867  return getFirstDecl();
868  }
869 
870  /// Determines whether this template was a specialization of a
871  /// member template.
872  ///
873  /// In the following example, the function template \c X<int>::f and the
874  /// member template \c X<int>::Inner are member specializations.
875  ///
876  /// \code
877  /// template<typename T>
878  /// struct X {
879  /// template<typename U> void f(T, U);
880  /// template<typename U> struct Inner;
881  /// };
882  ///
883  /// template<> template<typename T>
884  /// void X<int>::f(int, T);
885  /// template<> template<typename T>
886  /// struct X<int>::Inner { /* ... */ };
887  /// \endcode
888  bool isMemberSpecialization() const {
889  return getCommonPtr()->InstantiatedFromMember.getInt();
890  }
891 
892  /// Note that this member template is a specialization.
894  assert(getCommonPtr()->InstantiatedFromMember.getPointer() &&
895  "Only member templates can be member template specializations");
896  getCommonPtr()->InstantiatedFromMember.setInt(true);
897  }
898 
899  /// Retrieve the member template from which this template was
900  /// instantiated, or nullptr if this template was not instantiated from a
901  /// member template.
902  ///
903  /// A template is instantiated from a member template when the member
904  /// template itself is part of a class template (or member thereof). For
905  /// example, given
906  ///
907  /// \code
908  /// template<typename T>
909  /// struct X {
910  /// template<typename U> void f(T, U);
911  /// };
912  ///
913  /// void test(X<int> x) {
914  /// x.f(1, 'a');
915  /// };
916  /// \endcode
917  ///
918  /// \c X<int>::f is a FunctionTemplateDecl that describes the function
919  /// template
920  ///
921  /// \code
922  /// template<typename U> void X<int>::f(int, U);
923  /// \endcode
924  ///
925  /// which was itself created during the instantiation of \c X<int>. Calling
926  /// getInstantiatedFromMemberTemplate() on this FunctionTemplateDecl will
927  /// retrieve the FunctionTemplateDecl for the original template \c f within
928  /// the class template \c X<T>, i.e.,
929  ///
930  /// \code
931  /// template<typename T>
932  /// template<typename U>
933  /// void X<T>::f(T, U);
934  /// \endcode
936  return getCommonPtr()->InstantiatedFromMember.getPointer();
937  }
938 
940  assert(!getCommonPtr()->InstantiatedFromMember.getPointer());
941  getCommonPtr()->InstantiatedFromMember.setPointer(TD);
942  }
943 
945  using redecl_iterator = redeclarable_base::redecl_iterator;
946 
947  using redeclarable_base::redecls_begin;
948  using redeclarable_base::redecls_end;
949  using redeclarable_base::redecls;
950  using redeclarable_base::getPreviousDecl;
951  using redeclarable_base::getMostRecentDecl;
952  using redeclarable_base::isFirstDecl;
953 
954  // Implement isa/cast/dyncast/etc.
955  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
956 
957  static bool classofKind(Kind K) {
958  return K >= firstRedeclarableTemplate && K <= lastRedeclarableTemplate;
959  }
960 };
961 
962 template <> struct RedeclarableTemplateDecl::
963 SpecEntryTraits<FunctionTemplateSpecializationInfo> {
965 
967  return I->getFunction();
968  }
969 
972  return I->TemplateArguments->asArray();
973  }
974 };
975 
976 /// Declaration of a template function.
978 protected:
979  friend class FunctionDecl;
980 
981  /// Data that is common to all of the declarations of a given
982  /// function template.
983  struct Common : CommonBase {
984  /// The function template specializations for this function
985  /// template, including explicit specializations and instantiations.
986  llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> Specializations;
987 
988  /// The set of "injected" template arguments used within this
989  /// function template.
990  ///
991  /// This pointer refers to the template arguments (there are as
992  /// many template arguments as template parameaters) for the function
993  /// template, and is allocated lazily, since most function templates do not
994  /// require the use of this information.
995  TemplateArgument *InjectedArgs = nullptr;
996 
997  Common() = default;
998  };
999 
1001  DeclarationName Name, TemplateParameterList *Params,
1002  NamedDecl *Decl)
1003  : RedeclarableTemplateDecl(FunctionTemplate, C, DC, L, Name, Params,
1004  Decl) {}
1005 
1006  CommonBase *newCommon(ASTContext &C) const override;
1007 
1009  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
1010  }
1011 
1012  /// Retrieve the set of function template specializations of this
1013  /// function template.
1014  llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
1015  getSpecializations() const;
1016 
1017  /// Add a specialization of this function template.
1018  ///
1019  /// \param InsertPos Insert position in the FoldingSetVector, must have been
1020  /// retrieved by an earlier call to findSpecialization().
1021  void addSpecialization(FunctionTemplateSpecializationInfo* Info,
1022  void *InsertPos);
1023 
1024 public:
1025  friend class ASTDeclReader;
1026  friend class ASTDeclWriter;
1027 
1028  /// Load any lazily-loaded specializations from the external source.
1029  void LoadLazySpecializations() const;
1030 
1031  /// Get the underlying function declaration of the template.
1033  return static_cast<FunctionDecl *>(TemplatedDecl);
1034  }
1035 
1036  /// Returns whether this template declaration defines the primary
1037  /// pattern.
1039  return getTemplatedDecl()->isThisDeclarationADefinition();
1040  }
1041 
1042  /// Return the specialization with the provided arguments if it exists,
1043  /// otherwise return the insertion point.
1044  FunctionDecl *findSpecialization(ArrayRef<TemplateArgument> Args,
1045  void *&InsertPos);
1046 
1048  return cast<FunctionTemplateDecl>(
1050  }
1052  return cast<FunctionTemplateDecl>(
1054  }
1055 
1056  /// Retrieve the previous declaration of this function template, or
1057  /// nullptr if no such declaration exists.
1059  return cast_or_null<FunctionTemplateDecl>(
1060  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
1061  }
1063  return cast_or_null<FunctionTemplateDecl>(
1064  static_cast<const RedeclarableTemplateDecl *>(this)->getPreviousDecl());
1065  }
1066 
1068  return cast<FunctionTemplateDecl>(
1069  static_cast<RedeclarableTemplateDecl *>(this)
1070  ->getMostRecentDecl());
1071  }
1073  return const_cast<FunctionTemplateDecl*>(this)->getMostRecentDecl();
1074  }
1075 
1077  return cast_or_null<FunctionTemplateDecl>(
1079  }
1080 
1082  using spec_range = llvm::iterator_range<spec_iterator>;
1083 
1085  return spec_range(spec_begin(), spec_end());
1086  }
1087 
1089  return makeSpecIterator(getSpecializations(), false);
1090  }
1091 
1093  return makeSpecIterator(getSpecializations(), true);
1094  }
1095 
1096  /// Retrieve the "injected" template arguments that correspond to the
1097  /// template parameters of this function template.
1098  ///
1099  /// Although the C++ standard has no notion of the "injected" template
1100  /// arguments for a function template, the notion is convenient when
1101  /// we need to perform substitutions inside the definition of a function
1102  /// template.
1103  ArrayRef<TemplateArgument> getInjectedTemplateArgs();
1104 
1105  /// Return whether this function template is an abbreviated function template,
1106  /// e.g. `void foo(auto x)` or `template<typename T> void foo(auto x)`
1107  bool isAbbreviated() const {
1108  // Since the invented template parameters generated from 'auto' parameters
1109  // are either appended to the end of the explicit template parameter list or
1110  // form a new template paramter list, we can simply observe the last
1111  // parameter to determine if such a thing happened.
1112  const TemplateParameterList *TPL = getTemplateParameters();
1113  return TPL->getParam(TPL->size() - 1)->isImplicit();
1114  }
1115 
1116  /// Merge \p Prev with our RedeclarableTemplateDecl::Common.
1117  void mergePrevDecl(FunctionTemplateDecl *Prev);
1118 
1119  /// Create a function template node.
1121  SourceLocation L,
1122  DeclarationName Name,
1123  TemplateParameterList *Params,
1124  NamedDecl *Decl);
1125 
1126  /// Create an empty function template node.
1127  static FunctionTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1128 
1129  // Implement isa/cast/dyncast support
1130  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1131  static bool classofKind(Kind K) { return K == FunctionTemplate; }
1132 };
1133 
1134 //===----------------------------------------------------------------------===//
1135 // Kinds of Template Parameters
1136 //===----------------------------------------------------------------------===//
1137 
1138 /// Defines the position of a template parameter within a template
1139 /// parameter list.
1140 ///
1141 /// Because template parameter can be listed
1142 /// sequentially for out-of-line template members, each template parameter is
1143 /// given a Depth - the nesting of template parameter scopes - and a Position -
1144 /// the occurrence within the parameter list.
1145 /// This class is inheritedly privately by different kinds of template
1146 /// parameters and is not part of the Decl hierarchy. Just a facility.
1148 protected:
1149  // FIXME: These probably don't need to be ints. int:5 for depth, int:8 for
1150  // position? Maybe?
1151  unsigned Depth;
1152  unsigned Position;
1153 
1154  TemplateParmPosition(unsigned D, unsigned P) : Depth(D), Position(P) {}
1155 
1156 public:
1157  TemplateParmPosition() = delete;
1158 
1159  /// Get the nesting depth of the template parameter.
1160  unsigned getDepth() const { return Depth; }
1161  void setDepth(unsigned D) { Depth = D; }
1162 
1163  /// Get the position of the template parameter within its parameter list.
1164  unsigned getPosition() const { return Position; }
1165  void setPosition(unsigned P) { Position = P; }
1166 
1167  /// Get the index of the template parameter within its parameter list.
1168  unsigned getIndex() const { return Position; }
1169 };
1170 
1171 /// Declaration of a template type parameter.
1172 ///
1173 /// For example, "T" in
1174 /// \code
1175 /// template<typename T> class vector;
1176 /// \endcode
1177 class TemplateTypeParmDecl final : public TypeDecl,
1178  private llvm::TrailingObjects<TemplateTypeParmDecl, TypeConstraint> {
1179  /// Sema creates these on the stack during auto type deduction.
1180  friend class Sema;
1181  friend TrailingObjects;
1182  friend class ASTDeclReader;
1183 
1184  /// Whether this template type parameter was declaration with
1185  /// the 'typename' keyword.
1186  ///
1187  /// If false, it was declared with the 'class' keyword.
1188  bool Typename : 1;
1189 
1190  /// Whether this template type parameter has a type-constraint construct.
1191  bool HasTypeConstraint : 1;
1192 
1193  /// Whether the type constraint has been initialized. This can be false if the
1194  /// constraint was not initialized yet or if there was an error forming the
1195  /// type constriant.
1196  bool TypeConstraintInitialized : 1;
1197 
1198  /// Whether this non-type template parameter is an "expanded"
1199  /// parameter pack, meaning that its type is a pack expansion and we
1200  /// already know the set of types that expansion expands to.
1201  bool ExpandedParameterPack : 1;
1202 
1203  /// The number of type parameters in an expanded parameter pack.
1204  unsigned NumExpanded = 0;
1205 
1206  /// The default template argument, if any.
1207  using DefArgStorage =
1209  DefArgStorage DefaultArgument;
1210 
1211  TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc,
1213  bool Typename, bool HasTypeConstraint,
1214  Optional<unsigned> NumExpanded)
1215  : TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename),
1216  HasTypeConstraint(HasTypeConstraint), TypeConstraintInitialized(false),
1217  ExpandedParameterPack(NumExpanded),
1218  NumExpanded(NumExpanded ? *NumExpanded : 0) {}
1219 
1220 public:
1221  static TemplateTypeParmDecl *Create(const ASTContext &C, DeclContext *DC,
1222  SourceLocation KeyLoc,
1223  SourceLocation NameLoc,
1224  unsigned D, unsigned P,
1225  IdentifierInfo *Id, bool Typename,
1226  bool ParameterPack,
1227  bool HasTypeConstraint = false,
1228  Optional<unsigned> NumExpanded = None);
1229  static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C,
1230  unsigned ID);
1231  static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C,
1232  unsigned ID,
1233  bool HasTypeConstraint);
1234 
1235  /// Whether this template type parameter was declared with
1236  /// the 'typename' keyword.
1237  ///
1238  /// If not, it was either declared with the 'class' keyword or with a
1239  /// type-constraint (see hasTypeConstraint()).
1241  return Typename && !HasTypeConstraint;
1242  }
1243 
1244  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1245 
1246  /// Determine whether this template parameter has a default
1247  /// argument.
1248  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1249 
1250  /// Retrieve the default argument, if any.
1252  return DefaultArgument.get()->getType();
1253  }
1254 
1255  /// Retrieves the default argument's source information, if any.
1257  return DefaultArgument.get();
1258  }
1259 
1260  /// Retrieves the location of the default argument declaration.
1261  SourceLocation getDefaultArgumentLoc() const;
1262 
1263  /// Determines whether the default argument was inherited
1264  /// from a previous declaration of this template.
1266  return DefaultArgument.isInherited();
1267  }
1268 
1269  /// Set the default argument for this template parameter.
1271  DefaultArgument.set(DefArg);
1272  }
1273 
1274  /// Set that this default argument was inherited from another
1275  /// parameter.
1277  TemplateTypeParmDecl *Prev) {
1278  DefaultArgument.setInherited(C, Prev);
1279  }
1280 
1281  /// Removes the default argument of this template parameter.
1283  DefaultArgument.clear();
1284  }
1285 
1286  /// Set whether this template type parameter was declared with
1287  /// the 'typename' or 'class' keyword.
1288  void setDeclaredWithTypename(bool withTypename) { Typename = withTypename; }
1289 
1290  /// Retrieve the depth of the template parameter.
1291  unsigned getDepth() const;
1292 
1293  /// Retrieve the index of the template parameter.
1294  unsigned getIndex() const;
1295 
1296  /// Returns whether this is a parameter pack.
1297  bool isParameterPack() const;
1298 
1299  /// Whether this parameter pack is a pack expansion.
1300  ///
1301  /// A template type template parameter pack can be a pack expansion if its
1302  /// type-constraint contains an unexpanded parameter pack.
1303  bool isPackExpansion() const {
1304  if (!isParameterPack())
1305  return false;
1306  if (const TypeConstraint *TC = getTypeConstraint())
1307  if (TC->hasExplicitTemplateArgs())
1308  for (const auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
1309  if (ArgLoc.getArgument().containsUnexpandedParameterPack())
1310  return true;
1311  return false;
1312  }
1313 
1314  /// Whether this parameter is a template type parameter pack that has a known
1315  /// list of different type-constraints at different positions.
1316  ///
1317  /// A parameter pack is an expanded parameter pack when the original
1318  /// parameter pack's type-constraint was itself a pack expansion, and that
1319  /// expansion has already been expanded. For example, given:
1320  ///
1321  /// \code
1322  /// template<typename ...Types>
1323  /// struct X {
1324  /// template<convertible_to<Types> ...Convertibles>
1325  /// struct Y { /* ... */ };
1326  /// };
1327  /// \endcode
1328  ///
1329  /// The parameter pack \c Convertibles has (convertible_to<Types> && ...) as
1330  /// its type-constraint. When \c Types is supplied with template arguments by
1331  /// instantiating \c X, the instantiation of \c Convertibles becomes an
1332  /// expanded parameter pack. For example, instantiating
1333  /// \c X<int, unsigned int> results in \c Convertibles being an expanded
1334  /// parameter pack of size 2 (use getNumExpansionTypes() to get this number).
1335  bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1336 
1337  /// Retrieves the number of parameters in an expanded parameter pack.
1338  unsigned getNumExpansionParameters() const {
1339  assert(ExpandedParameterPack && "Not an expansion parameter pack");
1340  return NumExpanded;
1341  }
1342 
1343  /// Returns the type constraint associated with this template parameter (if
1344  /// any).
1346  return TypeConstraintInitialized ? getTrailingObjects<TypeConstraint>() :
1347  nullptr;
1348  }
1349 
1350  void setTypeConstraint(NestedNameSpecifierLoc NNS,
1351  DeclarationNameInfo NameInfo, NamedDecl *FoundDecl,
1352  ConceptDecl *CD,
1353  const ASTTemplateArgumentListInfo *ArgsAsWritten,
1354  Expr *ImmediatelyDeclaredConstraint);
1355 
1356  /// Determine whether this template parameter has a type-constraint.
1357  bool hasTypeConstraint() const {
1358  return HasTypeConstraint;
1359  }
1360 
1361  /// \brief Get the associated-constraints of this template parameter.
1362  /// This will either be the immediately-introduced constraint or empty.
1363  ///
1364  /// Use this instead of getConstraintExpression for concepts APIs that
1365  /// accept an ArrayRef of constraint expressions.
1367  if (HasTypeConstraint)
1368  AC.push_back(getTypeConstraint()->getImmediatelyDeclaredConstraint());
1369  }
1370 
1371  SourceRange getSourceRange() const override LLVM_READONLY;
1372 
1373  // Implement isa/cast/dyncast/etc.
1374  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1375  static bool classofKind(Kind K) { return K == TemplateTypeParm; }
1376 };
1377 
1378 /// NonTypeTemplateParmDecl - Declares a non-type template parameter,
1379 /// e.g., "Size" in
1380 /// @code
1381 /// template<int Size> class array { };
1382 /// @endcode
1383 class NonTypeTemplateParmDecl final
1384  : public DeclaratorDecl,
1385  protected TemplateParmPosition,
1386  private llvm::TrailingObjects<NonTypeTemplateParmDecl,
1387  std::pair<QualType, TypeSourceInfo *>,
1388  Expr *> {
1389  friend class ASTDeclReader;
1390  friend TrailingObjects;
1391 
1392  /// The default template argument, if any, and whether or not
1393  /// it was inherited.
1395  DefArgStorage DefaultArgument;
1396 
1397  // FIXME: Collapse this into TemplateParamPosition; or, just move depth/index
1398  // down here to save memory.
1399 
1400  /// Whether this non-type template parameter is a parameter pack.
1401  bool ParameterPack;
1402 
1403  /// Whether this non-type template parameter is an "expanded"
1404  /// parameter pack, meaning that its type is a pack expansion and we
1405  /// already know the set of types that expansion expands to.
1406  bool ExpandedParameterPack = false;
1407 
1408  /// The number of types in an expanded parameter pack.
1409  unsigned NumExpandedTypes = 0;
1410 
1411  size_t numTrailingObjects(
1412  OverloadToken<std::pair<QualType, TypeSourceInfo *>>) const {
1413  return NumExpandedTypes;
1414  }
1415 
1416  NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
1417  SourceLocation IdLoc, unsigned D, unsigned P,
1419  bool ParameterPack, TypeSourceInfo *TInfo)
1420  : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
1421  TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
1422 
1423  NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
1424  SourceLocation IdLoc, unsigned D, unsigned P,
1426  TypeSourceInfo *TInfo,
1427  ArrayRef<QualType> ExpandedTypes,
1428  ArrayRef<TypeSourceInfo *> ExpandedTInfos);
1429 
1430 public:
1431  static NonTypeTemplateParmDecl *
1432  Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1433  SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
1434  QualType T, bool ParameterPack, TypeSourceInfo *TInfo);
1435 
1436  static NonTypeTemplateParmDecl *
1437  Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1438  SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
1439  QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
1440  ArrayRef<TypeSourceInfo *> ExpandedTInfos);
1441 
1442  static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
1443  unsigned ID,
1444  bool HasTypeConstraint);
1445  static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
1446  unsigned ID,
1447  unsigned NumExpandedTypes,
1448  bool HasTypeConstraint);
1449 
1455 
1456  SourceRange getSourceRange() const override LLVM_READONLY;
1457 
1458  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1459 
1460  /// Determine whether this template parameter has a default
1461  /// argument.
1462  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1463 
1464  /// Retrieve the default argument, if any.
1465  Expr *getDefaultArgument() const { return DefaultArgument.get(); }
1466 
1467  /// Retrieve the location of the default argument, if any.
1468  SourceLocation getDefaultArgumentLoc() const;
1469 
1470  /// Determines whether the default argument was inherited
1471  /// from a previous declaration of this template.
1473  return DefaultArgument.isInherited();
1474  }
1475 
1476  /// Set the default argument for this template parameter, and
1477  /// whether that default argument was inherited from another
1478  /// declaration.
1479  void setDefaultArgument(Expr *DefArg) { DefaultArgument.set(DefArg); }
1481  NonTypeTemplateParmDecl *Parm) {
1482  DefaultArgument.setInherited(C, Parm);
1483  }
1484 
1485  /// Removes the default argument of this template parameter.
1486  void removeDefaultArgument() { DefaultArgument.clear(); }
1487 
1488  /// Whether this parameter is a non-type template parameter pack.
1489  ///
1490  /// If the parameter is a parameter pack, the type may be a
1491  /// \c PackExpansionType. In the following example, the \c Dims parameter
1492  /// is a parameter pack (whose type is 'unsigned').
1493  ///
1494  /// \code
1495  /// template<typename T, unsigned ...Dims> struct multi_array;
1496  /// \endcode
1497  bool isParameterPack() const { return ParameterPack; }
1498 
1499  /// Whether this parameter pack is a pack expansion.
1500  ///
1501  /// A non-type template parameter pack is a pack expansion if its type
1502  /// contains an unexpanded parameter pack. In this case, we will have
1503  /// built a PackExpansionType wrapping the type.
1504  bool isPackExpansion() const {
1505  return ParameterPack && getType()->getAs<PackExpansionType>();
1506  }
1507 
1508  /// Whether this parameter is a non-type template parameter pack
1509  /// that has a known list of different types at different positions.
1510  ///
1511  /// A parameter pack is an expanded parameter pack when the original
1512  /// parameter pack's type was itself a pack expansion, and that expansion
1513  /// has already been expanded. For example, given:
1514  ///
1515  /// \code
1516  /// template<typename ...Types>
1517  /// struct X {
1518  /// template<Types ...Values>
1519  /// struct Y { /* ... */ };
1520  /// };
1521  /// \endcode
1522  ///
1523  /// The parameter pack \c Values has a \c PackExpansionType as its type,
1524  /// which expands \c Types. When \c Types is supplied with template arguments
1525  /// by instantiating \c X, the instantiation of \c Values becomes an
1526  /// expanded parameter pack. For example, instantiating
1527  /// \c X<int, unsigned int> results in \c Values being an expanded parameter
1528  /// pack with expansion types \c int and \c unsigned int.
1529  ///
1530  /// The \c getExpansionType() and \c getExpansionTypeSourceInfo() functions
1531  /// return the expansion types.
1532  bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1533 
1534  /// Retrieves the number of expansion types in an expanded parameter
1535  /// pack.
1536  unsigned getNumExpansionTypes() const {
1537  assert(ExpandedParameterPack && "Not an expansion parameter pack");
1538  return NumExpandedTypes;
1539  }
1540 
1541  /// Retrieve a particular expansion type within an expanded parameter
1542  /// pack.
1543  QualType getExpansionType(unsigned I) const {
1544  assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1545  auto TypesAndInfos =
1546  getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1547  return TypesAndInfos[I].first;
1548  }
1549 
1550  /// Retrieve a particular expansion type source info within an
1551  /// expanded parameter pack.
1553  assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1554  auto TypesAndInfos =
1555  getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1556  return TypesAndInfos[I].second;
1557  }
1558 
1559  /// Return the constraint introduced by the placeholder type of this non-type
1560  /// template parameter (if any).
1562  return hasPlaceholderTypeConstraint() ? *getTrailingObjects<Expr *>() :
1563  nullptr;
1564  }
1565 
1567  *getTrailingObjects<Expr *>() = E;
1568  }
1569 
1570  /// Determine whether this non-type template parameter's type has a
1571  /// placeholder with a type-constraint.
1573  auto *AT = getType()->getContainedAutoType();
1574  return AT && AT->isConstrained();
1575  }
1576 
1577  /// \brief Get the associated-constraints of this template parameter.
1578  /// This will either be a vector of size 1 containing the immediately-declared
1579  /// constraint introduced by the placeholder type, or an empty vector.
1580  ///
1581  /// Use this instead of getPlaceholderImmediatelyDeclaredConstraint for
1582  /// concepts APIs that accept an ArrayRef of constraint expressions.
1584  if (Expr *E = getPlaceholderTypeConstraint())
1585  AC.push_back(E);
1586  }
1587 
1588  // Implement isa/cast/dyncast/etc.
1589  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1590  static bool classofKind(Kind K) { return K == NonTypeTemplateParm; }
1591 };
1592 
1593 /// TemplateTemplateParmDecl - Declares a template template parameter,
1594 /// e.g., "T" in
1595 /// @code
1596 /// template <template <typename> class T> class container { };
1597 /// @endcode
1598 /// A template template parameter is a TemplateDecl because it defines the
1599 /// name of a template and the template parameters allowable for substitution.
1601  : public TemplateDecl,
1602  protected TemplateParmPosition,
1603  private llvm::TrailingObjects<TemplateTemplateParmDecl,
1604  TemplateParameterList *> {
1605  /// The default template argument, if any.
1606  using DefArgStorage =
1608  DefArgStorage DefaultArgument;
1609 
1610  /// Whether this parameter is a parameter pack.
1611  bool ParameterPack;
1612 
1613  /// Whether this template template parameter is an "expanded"
1614  /// parameter pack, meaning that it is a pack expansion and we
1615  /// already know the set of template parameters that expansion expands to.
1616  bool ExpandedParameterPack = false;
1617 
1618  /// The number of parameters in an expanded parameter pack.
1619  unsigned NumExpandedParams = 0;
1620 
1622  unsigned D, unsigned P, bool ParameterPack,
1624  : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
1625  TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
1626 
1628  unsigned D, unsigned P,
1631 
1632  void anchor() override;
1633 
1634 public:
1635  friend class ASTDeclReader;
1636  friend class ASTDeclWriter;
1638 
1639  static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
1640  SourceLocation L, unsigned D,
1641  unsigned P, bool ParameterPack,
1642  IdentifierInfo *Id,
1643  TemplateParameterList *Params);
1644  static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
1645  SourceLocation L, unsigned D,
1646  unsigned P,
1647  IdentifierInfo *Id,
1648  TemplateParameterList *Params,
1650 
1651  static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
1652  unsigned ID);
1653  static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
1654  unsigned ID,
1655  unsigned NumExpansions);
1656 
1662 
1663  /// Whether this template template parameter is a template
1664  /// parameter pack.
1665  ///
1666  /// \code
1667  /// template<template <class T> ...MetaFunctions> struct Apply;
1668  /// \endcode
1669  bool isParameterPack() const { return ParameterPack; }
1670 
1671  /// Whether this parameter pack is a pack expansion.
1672  ///
1673  /// A template template parameter pack is a pack expansion if its template
1674  /// parameter list contains an unexpanded parameter pack.
1675  bool isPackExpansion() const {
1676  return ParameterPack &&
1677  getTemplateParameters()->containsUnexpandedParameterPack();
1678  }
1679 
1680  /// Whether this parameter is a template template parameter pack that
1681  /// has a known list of different template parameter lists at different
1682  /// positions.
1683  ///
1684  /// A parameter pack is an expanded parameter pack when the original parameter
1685  /// pack's template parameter list was itself a pack expansion, and that
1686  /// expansion has already been expanded. For exampe, given:
1687  ///
1688  /// \code
1689  /// template<typename...Types> struct Outer {
1690  /// template<template<Types> class...Templates> struct Inner;
1691  /// };
1692  /// \endcode
1693  ///
1694  /// The parameter pack \c Templates is a pack expansion, which expands the
1695  /// pack \c Types. When \c Types is supplied with template arguments by
1696  /// instantiating \c Outer, the instantiation of \c Templates is an expanded
1697  /// parameter pack.
1698  bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1699 
1700  /// Retrieves the number of expansion template parameters in
1701  /// an expanded parameter pack.
1703  assert(ExpandedParameterPack && "Not an expansion parameter pack");
1704  return NumExpandedParams;
1705  }
1706 
1707  /// Retrieve a particular expansion type within an expanded parameter
1708  /// pack.
1710  assert(I < NumExpandedParams && "Out-of-range expansion type index");
1711  return getTrailingObjects<TemplateParameterList *>()[I];
1712  }
1713 
1714  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1715 
1716  /// Determine whether this template parameter has a default
1717  /// argument.
1718  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1719 
1720  /// Retrieve the default argument, if any.
1722  static const TemplateArgumentLoc NoneLoc;
1723  return DefaultArgument.isSet() ? *DefaultArgument.get() : NoneLoc;
1724  }
1725 
1726  /// Retrieve the location of the default argument, if any.
1727  SourceLocation getDefaultArgumentLoc() const;
1728 
1729  /// Determines whether the default argument was inherited
1730  /// from a previous declaration of this template.
1732  return DefaultArgument.isInherited();
1733  }
1734 
1735  /// Set the default argument for this template parameter, and
1736  /// whether that default argument was inherited from another
1737  /// declaration.
1738  void setDefaultArgument(const ASTContext &C,
1739  const TemplateArgumentLoc &DefArg);
1741  TemplateTemplateParmDecl *Prev) {
1742  DefaultArgument.setInherited(C, Prev);
1743  }
1744 
1745  /// Removes the default argument of this template parameter.
1746  void removeDefaultArgument() { DefaultArgument.clear(); }
1747 
1748  SourceRange getSourceRange() const override LLVM_READONLY {
1749  SourceLocation End = getLocation();
1750  if (hasDefaultArgument() && !defaultArgumentWasInherited())
1751  End = getDefaultArgument().getSourceRange().getEnd();
1752  return SourceRange(getTemplateParameters()->getTemplateLoc(), End);
1753  }
1754 
1755  // Implement isa/cast/dyncast/etc.
1756  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1757  static bool classofKind(Kind K) { return K == TemplateTemplateParm; }
1758 };
1759 
1760 /// Represents the builtin template declaration which is used to
1761 /// implement __make_integer_seq and other builtin templates. It serves
1762 /// no real purpose beyond existing as a place to hold template parameters.
1764  BuiltinTemplateKind BTK;
1765 
1768 
1769  void anchor() override;
1770 
1771 public:
1772  // Implement isa/cast/dyncast support
1773  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1774  static bool classofKind(Kind K) { return K == BuiltinTemplate; }
1775 
1777  DeclarationName Name,
1778  BuiltinTemplateKind BTK) {
1779  return new (C, DC) BuiltinTemplateDecl(C, DC, Name, BTK);
1780  }
1781 
1782  SourceRange getSourceRange() const override LLVM_READONLY {
1783  return {};
1784  }
1785 
1787 };
1788 
1789 /// Represents a class template specialization, which refers to
1790 /// a class template with a given set of template arguments.
1791 ///
1792 /// Class template specializations represent both explicit
1793 /// specialization of class templates, as in the example below, and
1794 /// implicit instantiations of class templates.
1795 ///
1796 /// \code
1797 /// template<typename T> class array;
1798 ///
1799 /// template<>
1800 /// class array<bool> { }; // class template specialization array<bool>
1801 /// \endcode
1803  : public CXXRecordDecl, public llvm::FoldingSetNode {
1804  /// Structure that stores information about a class template
1805  /// specialization that was instantiated from a class template partial
1806  /// specialization.
1807  struct SpecializedPartialSpecialization {
1808  /// The class template partial specialization from which this
1809  /// class template specialization was instantiated.
1810  ClassTemplatePartialSpecializationDecl *PartialSpecialization;
1811 
1812  /// The template argument list deduced for the class template
1813  /// partial specialization itself.
1814  const TemplateArgumentList *TemplateArgs;
1815  };
1816 
1817  /// The template that this specialization specializes
1818  llvm::PointerUnion<ClassTemplateDecl *, SpecializedPartialSpecialization *>
1819  SpecializedTemplate;
1820 
1821  /// Further info for explicit template specialization/instantiation.
1822  struct ExplicitSpecializationInfo {
1823  /// The type-as-written.
1824  TypeSourceInfo *TypeAsWritten = nullptr;
1825 
1826  /// The location of the extern keyword.
1827  SourceLocation ExternLoc;
1828 
1829  /// The location of the template keyword.
1830  SourceLocation TemplateKeywordLoc;
1831 
1832  ExplicitSpecializationInfo() = default;
1833  };
1834 
1835  /// Further info for explicit template specialization/instantiation.
1836  /// Does not apply to implicit specializations.
1837  ExplicitSpecializationInfo *ExplicitInfo = nullptr;
1838 
1839  /// The template arguments used to describe this specialization.
1840  const TemplateArgumentList *TemplateArgs;
1841 
1842  /// The point where this template was instantiated (if any)
1843  SourceLocation PointOfInstantiation;
1844 
1845  /// The kind of specialization this declaration refers to.
1846  /// Really a value of type TemplateSpecializationKind.
1847  unsigned SpecializationKind : 3;
1848 
1849 protected:
1851  DeclContext *DC, SourceLocation StartLoc,
1852  SourceLocation IdLoc,
1853  ClassTemplateDecl *SpecializedTemplate,
1856 
1858 
1859 public:
1860  friend class ASTDeclReader;
1861  friend class ASTDeclWriter;
1862 
1864  Create(ASTContext &Context, TagKind TK, DeclContext *DC,
1865  SourceLocation StartLoc, SourceLocation IdLoc,
1866  ClassTemplateDecl *SpecializedTemplate,
1870  CreateDeserialized(ASTContext &C, unsigned ID);
1871 
1872  void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
1873  bool Qualified) const override;
1874 
1875  // FIXME: This is broken. CXXRecordDecl::getMostRecentDecl() returns a
1876  // different "most recent" declaration from this function for the same
1877  // declaration, because we don't override getMostRecentDeclImpl(). But
1878  // it's not clear that we should override that, because the most recent
1879  // declaration as a CXXRecordDecl sometimes is the injected-class-name.
1881  return cast<ClassTemplateSpecializationDecl>(
1882  getMostRecentNonInjectedDecl());
1883  }
1884 
1885  /// Retrieve the template that this specialization specializes.
1886  ClassTemplateDecl *getSpecializedTemplate() const;
1887 
1888  /// Retrieve the template arguments of the class template
1889  /// specialization.
1891  return *TemplateArgs;
1892  }
1893 
1894  /// Determine the kind of specialization that this
1895  /// declaration represents.
1897  return static_cast<TemplateSpecializationKind>(SpecializationKind);
1898  }
1899 
1901  return getSpecializationKind() == TSK_ExplicitSpecialization;
1902  }
1903 
1904  /// Is this an explicit specialization at class scope (within the class that
1905  /// owns the primary template)? For example:
1906  ///
1907  /// \code
1908  /// template<typename T> struct Outer {
1909  /// template<typename U> struct Inner;
1910  /// template<> struct Inner; // class-scope explicit specialization
1911  /// };
1912  /// \endcode
1914  return isExplicitSpecialization() &&
1915  isa<CXXRecordDecl>(getLexicalDeclContext());
1916  }
1917 
1918  /// True if this declaration is an explicit specialization,
1919  /// explicit instantiation declaration, or explicit instantiation
1920  /// definition.
1924  }
1925 
1927  SpecializationKind = TSK;
1928  }
1929 
1930  /// Get the point of instantiation (if any), or null if none.
1932  return PointOfInstantiation;
1933  }
1934 
1936  assert(Loc.isValid() && "point of instantiation must be valid!");
1937  PointOfInstantiation = Loc;
1938  }
1939 
1940  /// If this class template specialization is an instantiation of
1941  /// a template (rather than an explicit specialization), return the
1942  /// class template or class template partial specialization from which it
1943  /// was instantiated.
1944  llvm::PointerUnion<ClassTemplateDecl *,
1947  if (!isTemplateInstantiation(getSpecializationKind()))
1948  return llvm::PointerUnion<ClassTemplateDecl *,
1950 
1951  return getSpecializedTemplateOrPartial();
1952  }
1953 
1954  /// Retrieve the class template or class template partial
1955  /// specialization which was specialized by this.
1956  llvm::PointerUnion<ClassTemplateDecl *,
1959  if (const auto *PartialSpec =
1960  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1961  return PartialSpec->PartialSpecialization;
1962 
1963  return SpecializedTemplate.get<ClassTemplateDecl*>();
1964  }
1965 
1966  /// Retrieve the set of template arguments that should be used
1967  /// to instantiate members of the class template or class template partial
1968  /// specialization from which this class template specialization was
1969  /// instantiated.
1970  ///
1971  /// \returns For a class template specialization instantiated from the primary
1972  /// template, this function will return the same template arguments as
1973  /// getTemplateArgs(). For a class template specialization instantiated from
1974  /// a class template partial specialization, this function will return the
1975  /// deduced template arguments for the class template partial specialization
1976  /// itself.
1978  if (const auto *PartialSpec =
1979  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1980  return *PartialSpec->TemplateArgs;
1981 
1982  return getTemplateArgs();
1983  }
1984 
1985  /// Note that this class template specialization is actually an
1986  /// instantiation of the given class template partial specialization whose
1987  /// template arguments have been deduced.
1989  const TemplateArgumentList *TemplateArgs) {
1990  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
1991  "Already set to a class template partial specialization!");
1992  auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
1993  PS->PartialSpecialization = PartialSpec;
1994  PS->TemplateArgs = TemplateArgs;
1995  SpecializedTemplate = PS;
1996  }
1997 
1998  /// Note that this class template specialization is an instantiation
1999  /// of the given class template.
2000  void setInstantiationOf(ClassTemplateDecl *TemplDecl) {
2001  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
2002  "Previously set to a class template partial specialization!");
2003  SpecializedTemplate = TemplDecl;
2004  }
2005 
2006  /// Sets the type of this specialization as it was written by
2007  /// the user. This will be a class template specialization type.
2009  if (!ExplicitInfo)
2010  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2011  ExplicitInfo->TypeAsWritten = T;
2012  }
2013 
2014  /// Gets the type of this specialization as it was written by
2015  /// the user, if it was so written.
2017  return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
2018  }
2019 
2020  /// Gets the location of the extern keyword, if present.
2022  return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
2023  }
2024 
2025  /// Sets the location of the extern keyword.
2027  if (!ExplicitInfo)
2028  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2029  ExplicitInfo->ExternLoc = Loc;
2030  }
2031 
2032  /// Sets the location of the template keyword.
2034  if (!ExplicitInfo)
2035  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2036  ExplicitInfo->TemplateKeywordLoc = Loc;
2037  }
2038 
2039  /// Gets the location of the template keyword, if present.
2041  return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
2042  }
2043 
2044  SourceRange getSourceRange() const override LLVM_READONLY;
2045 
2046  void Profile(llvm::FoldingSetNodeID &ID) const {
2047  Profile(ID, TemplateArgs->asArray(), getASTContext());
2048  }
2049 
2050  static void
2051  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
2052  ASTContext &Context) {
2053  ID.AddInteger(TemplateArgs.size());
2054  for (const TemplateArgument &TemplateArg : TemplateArgs)
2055  TemplateArg.Profile(ID, Context);
2056  }
2057 
2058  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2059 
2060  static bool classofKind(Kind K) {
2061  return K >= firstClassTemplateSpecialization &&
2062  K <= lastClassTemplateSpecialization;
2063  }
2064 };
2065 
2068  /// The list of template parameters
2069  TemplateParameterList* TemplateParams = nullptr;
2070 
2071  /// The source info for the template arguments as written.
2072  /// FIXME: redundant with TypeAsWritten?
2073  const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
2074 
2075  /// The class template partial specialization from which this
2076  /// class template partial specialization was instantiated.
2077  ///
2078  /// The boolean value will be true to indicate that this class template
2079  /// partial specialization was specialized at this level.
2080  llvm::PointerIntPair<ClassTemplatePartialSpecializationDecl *, 1, bool>
2081  InstantiatedFromMember;
2082 
2084  DeclContext *DC,
2085  SourceLocation StartLoc,
2086  SourceLocation IdLoc,
2087  TemplateParameterList *Params,
2088  ClassTemplateDecl *SpecializedTemplate,
2090  const ASTTemplateArgumentListInfo *ArgsAsWritten,
2092 
2094  : ClassTemplateSpecializationDecl(C, ClassTemplatePartialSpecialization),
2095  InstantiatedFromMember(nullptr, false) {}
2096 
2097  void anchor() override;
2098 
2099 public:
2100  friend class ASTDeclReader;
2101  friend class ASTDeclWriter;
2102 
2104  Create(ASTContext &Context, TagKind TK, DeclContext *DC,
2105  SourceLocation StartLoc, SourceLocation IdLoc,
2106  TemplateParameterList *Params,
2107  ClassTemplateDecl *SpecializedTemplate,
2109  const TemplateArgumentListInfo &ArgInfos,
2110  QualType CanonInjectedType,
2112 
2114  CreateDeserialized(ASTContext &C, unsigned ID);
2115 
2117  return cast<ClassTemplatePartialSpecializationDecl>(
2118  static_cast<ClassTemplateSpecializationDecl *>(
2119  this)->getMostRecentDecl());
2120  }
2121 
2122  /// Get the list of template parameters
2124  return TemplateParams;
2125  }
2126 
2127  /// \brief All associated constraints of this partial specialization,
2128  /// including the requires clause and any constraints derived from
2129  /// constrained-parameters.
2130  ///
2131  /// The constraints in the resulting list are to be treated as if in a
2132  /// conjunction ("and").
2134  TemplateParams->getAssociatedConstraints(AC);
2135  }
2136 
2138  return TemplateParams->hasAssociatedConstraints();
2139  }
2140 
2141  /// Get the template arguments as written.
2143  return ArgsAsWritten;
2144  }
2145 
2146  /// Retrieve the member class template partial specialization from
2147  /// which this particular class template partial specialization was
2148  /// instantiated.
2149  ///
2150  /// \code
2151  /// template<typename T>
2152  /// struct Outer {
2153  /// template<typename U> struct Inner;
2154  /// template<typename U> struct Inner<U*> { }; // #1
2155  /// };
2156  ///
2157  /// Outer<float>::Inner<int*> ii;
2158  /// \endcode
2159  ///
2160  /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
2161  /// end up instantiating the partial specialization
2162  /// \c Outer<float>::Inner<U*>, which itself was instantiated from the class
2163  /// template partial specialization \c Outer<T>::Inner<U*>. Given
2164  /// \c Outer<float>::Inner<U*>, this function would return
2165  /// \c Outer<T>::Inner<U*>.
2167  const auto *First =
2168  cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2169  return First->InstantiatedFromMember.getPointer();
2170  }
2173  return getInstantiatedFromMember();
2174  }
2175 
2178  auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2179  First->InstantiatedFromMember.setPointer(PartialSpec);
2180  }
2181 
2182  /// Determines whether this class template partial specialization
2183  /// template was a specialization of a member partial specialization.
2184  ///
2185  /// In the following example, the member template partial specialization
2186  /// \c X<int>::Inner<T*> is a member specialization.
2187  ///
2188  /// \code
2189  /// template<typename T>
2190  /// struct X {
2191  /// template<typename U> struct Inner;
2192  /// template<typename U> struct Inner<U*>;
2193  /// };
2194  ///
2195  /// template<> template<typename T>
2196  /// struct X<int>::Inner<T*> { /* ... */ };
2197  /// \endcode
2199  const auto *First =
2200  cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2201  return First->InstantiatedFromMember.getInt();
2202  }
2203 
2204  /// Note that this member template is a specialization.
2206  auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2207  assert(First->InstantiatedFromMember.getPointer() &&
2208  "Only member templates can be member template specializations");
2209  return First->InstantiatedFromMember.setInt(true);
2210  }
2211 
2212  /// Retrieves the injected specialization type for this partial
2213  /// specialization. This is not the same as the type-decl-type for
2214  /// this partial specialization, which is an InjectedClassNameType.
2216  assert(getTypeForDecl() && "partial specialization has no type set!");
2217  return cast<InjectedClassNameType>(getTypeForDecl())
2218  ->getInjectedSpecializationType();
2219  }
2220 
2221  void Profile(llvm::FoldingSetNodeID &ID) const {
2222  Profile(ID, getTemplateArgs().asArray(), getTemplateParameters(),
2223  getASTContext());
2224  }
2225 
2226  static void
2227  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
2228  TemplateParameterList *TPL, ASTContext &Context);
2229 
2230  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2231 
2232  static bool classofKind(Kind K) {
2233  return K == ClassTemplatePartialSpecialization;
2234  }
2235 };
2236 
2237 /// Declaration of a class template.
2239 protected:
2240  /// Data that is common to all of the declarations of a given
2241  /// class template.
2242  struct Common : CommonBase {
2243  /// The class template specializations for this class
2244  /// template, including explicit specializations and instantiations.
2245  llvm::FoldingSetVector<ClassTemplateSpecializationDecl> Specializations;
2246 
2247  /// The class template partial specializations for this class
2248  /// template.
2249  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
2251 
2252  /// The injected-class-name type for this class template.
2254 
2255  Common() = default;
2256  };
2257 
2258  /// Retrieve the set of specializations of this class template.
2259  llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
2260  getSpecializations() const;
2261 
2262  /// Retrieve the set of partial specializations of this class
2263  /// template.
2264  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
2265  getPartialSpecializations();
2266 
2268  DeclarationName Name, TemplateParameterList *Params,
2269  NamedDecl *Decl)
2270  : RedeclarableTemplateDecl(ClassTemplate, C, DC, L, Name, Params, Decl) {}
2271 
2272  CommonBase *newCommon(ASTContext &C) const override;
2273 
2275  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2276  }
2277 
2278 public:
2279  friend class ASTDeclReader;
2280  friend class ASTDeclWriter;
2281 
2282  /// Load any lazily-loaded specializations from the external source.
2283  void LoadLazySpecializations() const;
2284 
2285  /// Get the underlying class declarations of the template.
2287  return static_cast<CXXRecordDecl *>(TemplatedDecl);
2288  }
2289 
2290  /// Returns whether this template declaration defines the primary
2291  /// class pattern.
2293  return getTemplatedDecl()->isThisDeclarationADefinition();
2294  }
2295 
2296  /// \brief Create a class template node.
2298  SourceLocation L,
2299  DeclarationName Name,
2300  TemplateParameterList *Params,
2301  NamedDecl *Decl);
2302 
2303  /// Create an empty class template node.
2304  static ClassTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2305 
2306  /// Return the specialization with the provided arguments if it exists,
2307  /// otherwise return the insertion point.
2309  findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2310 
2311  /// Insert the specified specialization knowing that it is not already
2312  /// in. InsertPos must be obtained from findSpecialization.
2313  void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos);
2314 
2316  return cast<ClassTemplateDecl>(
2318  }
2320  return cast<ClassTemplateDecl>(
2322  }
2323 
2324  /// Retrieve the previous declaration of this class template, or
2325  /// nullptr if no such declaration exists.
2327  return cast_or_null<ClassTemplateDecl>(
2328  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2329  }
2331  return cast_or_null<ClassTemplateDecl>(
2332  static_cast<const RedeclarableTemplateDecl *>(
2333  this)->getPreviousDecl());
2334  }
2335 
2337  return cast<ClassTemplateDecl>(
2338  static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
2339  }
2341  return const_cast<ClassTemplateDecl*>(this)->getMostRecentDecl();
2342  }
2343 
2345  return cast_or_null<ClassTemplateDecl>(
2347  }
2348 
2349  /// Return the partial specialization with the provided arguments if it
2350  /// exists, otherwise return the insertion point.
2352  findPartialSpecialization(ArrayRef<TemplateArgument> Args,
2353  TemplateParameterList *TPL, void *&InsertPos);
2354 
2355  /// Insert the specified partial specialization knowing that it is not
2356  /// already in. InsertPos must be obtained from findPartialSpecialization.
2357  void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D,
2358  void *InsertPos);
2359 
2360  /// Retrieve the partial specializations as an ordered list.
2361  void getPartialSpecializations(
2363 
2364  /// Find a class template partial specialization with the given
2365  /// type T.
2366  ///
2367  /// \param T a dependent type that names a specialization of this class
2368  /// template.
2369  ///
2370  /// \returns the class template partial specialization that exactly matches
2371  /// the type \p T, or nullptr if no such partial specialization exists.
2372  ClassTemplatePartialSpecializationDecl *findPartialSpecialization(QualType T);
2373 
2374  /// Find a class template partial specialization which was instantiated
2375  /// from the given member partial specialization.
2376  ///
2377  /// \param D a member class template partial specialization.
2378  ///
2379  /// \returns the class template partial specialization which was instantiated
2380  /// from the given member partial specialization, or nullptr if no such
2381  /// partial specialization exists.
2383  findPartialSpecInstantiatedFromMember(
2385 
2386  /// Retrieve the template specialization type of the
2387  /// injected-class-name for this class template.
2388  ///
2389  /// The injected-class-name for a class template \c X is \c
2390  /// X<template-args>, where \c template-args is formed from the
2391  /// template arguments that correspond to the template parameters of
2392  /// \c X. For example:
2393  ///
2394  /// \code
2395  /// template<typename T, int N>
2396  /// struct array {
2397  /// typedef array this_type; // "array" is equivalent to "array<T, N>"
2398  /// };
2399  /// \endcode
2400  QualType getInjectedClassNameSpecialization();
2401 
2403  using spec_range = llvm::iterator_range<spec_iterator>;
2404 
2406  return spec_range(spec_begin(), spec_end());
2407  }
2408 
2410  return makeSpecIterator(getSpecializations(), false);
2411  }
2412 
2414  return makeSpecIterator(getSpecializations(), true);
2415  }
2416 
2417  // Implement isa/cast/dyncast support
2418  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2419  static bool classofKind(Kind K) { return K == ClassTemplate; }
2420 };
2421 
2422 /// Declaration of a friend template.
2423 ///
2424 /// For example:
2425 /// \code
2426 /// template <typename T> class A {
2427 /// friend class MyVector<T>; // not a friend template
2428 /// template <typename U> friend class B; // not a friend template
2429 /// template <typename U> friend class Foo<T>::Nested; // friend template
2430 /// };
2431 /// \endcode
2432 ///
2433 /// \note This class is not currently in use. All of the above
2434 /// will yield a FriendDecl, not a FriendTemplateDecl.
2435 class FriendTemplateDecl : public Decl {
2436  virtual void anchor();
2437 
2438 public:
2439  using FriendUnion = llvm::PointerUnion<NamedDecl *,TypeSourceInfo *>;
2440 
2441 private:
2442  // The number of template parameters; always non-zero.
2443  unsigned NumParams = 0;
2444 
2445  // The parameter list.
2446  TemplateParameterList **Params = nullptr;
2447 
2448  // The declaration that's a friend of this class.
2449  FriendUnion Friend;
2450 
2451  // Location of the 'friend' specifier.
2452  SourceLocation FriendLoc;
2453 
2456  FriendUnion Friend, SourceLocation FriendLoc)
2457  : Decl(Decl::FriendTemplate, DC, Loc), NumParams(Params.size()),
2458  Params(Params.data()), Friend(Friend), FriendLoc(FriendLoc) {}
2459 
2460  FriendTemplateDecl(EmptyShell Empty) : Decl(Decl::FriendTemplate, Empty) {}
2461 
2462 public:
2463  friend class ASTDeclReader;
2464 
2465  static FriendTemplateDecl *
2466  Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc,
2468  SourceLocation FriendLoc);
2469 
2470  static FriendTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2471 
2472  /// If this friend declaration names a templated type (or
2473  /// a dependent member type of a templated type), return that
2474  /// type; otherwise return null.
2476  return Friend.dyn_cast<TypeSourceInfo*>();
2477  }
2478 
2479  /// If this friend declaration names a templated function (or
2480  /// a member function of a templated type), return that type;
2481  /// otherwise return null.
2483  return Friend.dyn_cast<NamedDecl*>();
2484  }
2485 
2486  /// Retrieves the location of the 'friend' keyword.
2488  return FriendLoc;
2489  }
2490 
2492  assert(i <= NumParams);
2493  return Params[i];
2494  }
2495 
2496  unsigned getNumTemplateParameters() const {
2497  return NumParams;
2498  }
2499 
2500  // Implement isa/cast/dyncast/etc.
2501  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2502  static bool classofKind(Kind K) { return K == Decl::FriendTemplate; }
2503 };
2504 
2505 /// Declaration of an alias template.
2506 ///
2507 /// For example:
2508 /// \code
2509 /// template <typename T> using V = std::map<T*, int, MyCompare<T>>;
2510 /// \endcode
2512 protected:
2514 
2516  DeclarationName Name, TemplateParameterList *Params,
2517  NamedDecl *Decl)
2518  : RedeclarableTemplateDecl(TypeAliasTemplate, C, DC, L, Name, Params,
2519  Decl) {}
2520 
2521  CommonBase *newCommon(ASTContext &C) const override;
2522 
2524  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2525  }
2526 
2527 public:
2528  friend class ASTDeclReader;
2529  friend class ASTDeclWriter;
2530 
2531  /// Get the underlying function declaration of the template.
2533  return static_cast<TypeAliasDecl *>(TemplatedDecl);
2534  }
2535 
2536 
2538  return cast<TypeAliasTemplateDecl>(
2540  }
2542  return cast<TypeAliasTemplateDecl>(
2544  }
2545 
2546  /// Retrieve the previous declaration of this function template, or
2547  /// nullptr if no such declaration exists.
2549  return cast_or_null<TypeAliasTemplateDecl>(
2550  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
2551  }
2553  return cast_or_null<TypeAliasTemplateDecl>(
2554  static_cast<const RedeclarableTemplateDecl *>(
2555  this)->getPreviousDecl());
2556  }
2557 
2559  return cast_or_null<TypeAliasTemplateDecl>(
2561  }
2562 
2563  /// Create a function template node.
2565  SourceLocation L,
2566  DeclarationName Name,
2567  TemplateParameterList *Params,
2568  NamedDecl *Decl);
2569 
2570  /// Create an empty alias template node.
2571  static TypeAliasTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2572 
2573  // Implement isa/cast/dyncast support
2574  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2575  static bool classofKind(Kind K) { return K == TypeAliasTemplate; }
2576 };
2577 
2578 /// Declaration of a function specialization at template class scope.
2579 ///
2580 /// For example:
2581 /// \code
2582 /// template <class T>
2583 /// class A {
2584 /// template <class U> void foo(U a) { }
2585 /// template<> void foo(int a) { }
2586 /// }
2587 /// \endcode
2588 ///
2589 /// "template<> foo(int a)" will be saved in Specialization as a normal
2590 /// CXXMethodDecl. Then during an instantiation of class A, it will be
2591 /// transformed into an actual function specialization.
2592 ///
2593 /// FIXME: This is redundant; we could store the same information directly on
2594 /// the CXXMethodDecl as a DependentFunctionTemplateSpecializationInfo.
2596  CXXMethodDecl *Specialization;
2597  const ASTTemplateArgumentListInfo *TemplateArgs;
2598 
2601  const ASTTemplateArgumentListInfo *TemplArgs)
2602  : Decl(Decl::ClassScopeFunctionSpecialization, DC, Loc),
2603  Specialization(FD), TemplateArgs(TemplArgs) {}
2604 
2606  : Decl(Decl::ClassScopeFunctionSpecialization, Empty) {}
2607 
2608  virtual void anchor();
2609 
2610 public:
2611  friend class ASTDeclReader;
2612  friend class ASTDeclWriter;
2613 
2614  CXXMethodDecl *getSpecialization() const { return Specialization; }
2615  bool hasExplicitTemplateArgs() const { return TemplateArgs; }
2617  return TemplateArgs;
2618  }
2619 
2622  bool HasExplicitTemplateArgs,
2623  const TemplateArgumentListInfo &TemplateArgs) {
2624  return new (C, DC) ClassScopeFunctionSpecializationDecl(
2625  DC, Loc, FD,
2626  HasExplicitTemplateArgs
2627  ? ASTTemplateArgumentListInfo::Create(C, TemplateArgs)
2628  : nullptr);
2629  }
2630 
2632  CreateDeserialized(ASTContext &Context, unsigned ID);
2633 
2634  // Implement isa/cast/dyncast/etc.
2635  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2636 
2637  static bool classofKind(Kind K) {
2638  return K == Decl::ClassScopeFunctionSpecialization;
2639  }
2640 };
2641 
2642 /// Represents a variable template specialization, which refers to
2643 /// a variable template with a given set of template arguments.
2644 ///
2645 /// Variable template specializations represent both explicit
2646 /// specializations of variable templates, as in the example below, and
2647 /// implicit instantiations of variable templates.
2648 ///
2649 /// \code
2650 /// template<typename T> constexpr T pi = T(3.1415926535897932385);
2651 ///
2652 /// template<>
2653 /// constexpr float pi<float>; // variable template specialization pi<float>
2654 /// \endcode
2656  public llvm::FoldingSetNode {
2657 
2658  /// Structure that stores information about a variable template
2659  /// specialization that was instantiated from a variable template partial
2660  /// specialization.
2661  struct SpecializedPartialSpecialization {
2662  /// The variable template partial specialization from which this
2663  /// variable template specialization was instantiated.
2664  VarTemplatePartialSpecializationDecl *PartialSpecialization;
2665 
2666  /// The template argument list deduced for the variable template
2667  /// partial specialization itself.
2668  const TemplateArgumentList *TemplateArgs;
2669  };
2670 
2671  /// The template that this specialization specializes.
2672  llvm::PointerUnion<VarTemplateDecl *, SpecializedPartialSpecialization *>
2673  SpecializedTemplate;
2674 
2675  /// Further info for explicit template specialization/instantiation.
2676  struct ExplicitSpecializationInfo {
2677  /// The type-as-written.
2678  TypeSourceInfo *TypeAsWritten = nullptr;
2679 
2680  /// The location of the extern keyword.
2681  SourceLocation ExternLoc;
2682 
2683  /// The location of the template keyword.
2684  SourceLocation TemplateKeywordLoc;
2685 
2686  ExplicitSpecializationInfo() = default;
2687  };
2688 
2689  /// Further info for explicit template specialization/instantiation.
2690  /// Does not apply to implicit specializations.
2691  ExplicitSpecializationInfo *ExplicitInfo = nullptr;
2692 
2693  /// The template arguments used to describe this specialization.
2694  const TemplateArgumentList *TemplateArgs;
2695  TemplateArgumentListInfo TemplateArgsInfo;
2696 
2697  /// The point where this template was instantiated (if any).
2698  SourceLocation PointOfInstantiation;
2699 
2700  /// The kind of specialization this declaration refers to.
2701  /// Really a value of type TemplateSpecializationKind.
2702  unsigned SpecializationKind : 3;
2703 
2704  /// Whether this declaration is a complete definition of the
2705  /// variable template specialization. We can't otherwise tell apart
2706  /// an instantiated declaration from an instantiated definition with
2707  /// no initializer.
2708  unsigned IsCompleteDefinition : 1;
2709 
2710 protected:
2712  SourceLocation StartLoc, SourceLocation IdLoc,
2713  VarTemplateDecl *SpecializedTemplate,
2714  QualType T, TypeSourceInfo *TInfo,
2715  StorageClass S,
2717 
2718  explicit VarTemplateSpecializationDecl(Kind DK, ASTContext &Context);
2719 
2720 public:
2721  friend class ASTDeclReader;
2722  friend class ASTDeclWriter;
2723  friend class VarDecl;
2724 
2726  Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2727  SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
2728  TypeSourceInfo *TInfo, StorageClass S,
2730  static VarTemplateSpecializationDecl *CreateDeserialized(ASTContext &C,
2731  unsigned ID);
2732 
2733  void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
2734  bool Qualified) const override;
2735 
2737  VarDecl *Recent = static_cast<VarDecl *>(this)->getMostRecentDecl();
2738  return cast<VarTemplateSpecializationDecl>(Recent);
2739  }
2740 
2741  /// Retrieve the template that this specialization specializes.
2742  VarTemplateDecl *getSpecializedTemplate() const;
2743 
2744  /// Retrieve the template arguments of the variable template
2745  /// specialization.
2746  const TemplateArgumentList &getTemplateArgs() const { return *TemplateArgs; }
2747 
2748  // TODO: Always set this when creating the new specialization?
2749  void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo);
2750 
2752  return TemplateArgsInfo;
2753  }
2754 
2755  /// Determine the kind of specialization that this
2756  /// declaration represents.
2758  return static_cast<TemplateSpecializationKind>(SpecializationKind);
2759  }
2760 
2762  return getSpecializationKind() == TSK_ExplicitSpecialization;
2763  }
2764 
2766  return isExplicitSpecialization() &&
2767  isa<CXXRecordDecl>(getLexicalDeclContext());
2768  }
2769 
2770  /// True if this declaration is an explicit specialization,
2771  /// explicit instantiation declaration, or explicit instantiation
2772  /// definition.
2776  }
2777 
2779  SpecializationKind = TSK;
2780  }
2781 
2782  /// Get the point of instantiation (if any), or null if none.
2784  return PointOfInstantiation;
2785  }
2786 
2788  assert(Loc.isValid() && "point of instantiation must be valid!");
2789  PointOfInstantiation = Loc;
2790  }
2791 
2792  void setCompleteDefinition() { IsCompleteDefinition = true; }
2793 
2794  /// If this variable template specialization is an instantiation of
2795  /// a template (rather than an explicit specialization), return the
2796  /// variable template or variable template partial specialization from which
2797  /// it was instantiated.
2798  llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2800  if (!isTemplateInstantiation(getSpecializationKind()))
2801  return llvm::PointerUnion<VarTemplateDecl *,
2803 
2804  return getSpecializedTemplateOrPartial();
2805  }
2806 
2807  /// Retrieve the variable template or variable template partial
2808  /// specialization which was specialized by this.
2809  llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2811  if (const auto *PartialSpec =
2812  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2813  return PartialSpec->PartialSpecialization;
2814 
2815  return SpecializedTemplate.get<VarTemplateDecl *>();
2816  }
2817 
2818  /// Retrieve the set of template arguments that should be used
2819  /// to instantiate the initializer of the variable template or variable
2820  /// template partial specialization from which this variable template
2821  /// specialization was instantiated.
2822  ///
2823  /// \returns For a variable template specialization instantiated from the
2824  /// primary template, this function will return the same template arguments
2825  /// as getTemplateArgs(). For a variable template specialization instantiated
2826  /// from a variable template partial specialization, this function will the
2827  /// return deduced template arguments for the variable template partial
2828  /// specialization itself.
2830  if (const auto *PartialSpec =
2831  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2832  return *PartialSpec->TemplateArgs;
2833 
2834  return getTemplateArgs();
2835  }
2836 
2837  /// Note that this variable template specialization is actually an
2838  /// instantiation of the given variable template partial specialization whose
2839  /// template arguments have been deduced.
2841  const TemplateArgumentList *TemplateArgs) {
2842  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
2843  "Already set to a variable template partial specialization!");
2844  auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
2845  PS->PartialSpecialization = PartialSpec;
2846  PS->TemplateArgs = TemplateArgs;
2847  SpecializedTemplate = PS;
2848  }
2849 
2850  /// Note that this variable template specialization is an instantiation
2851  /// of the given variable template.
2853  assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
2854  "Previously set to a variable template partial specialization!");
2855  SpecializedTemplate = TemplDecl;
2856  }
2857 
2858  /// Sets the type of this specialization as it was written by
2859  /// the user.
2861  if (!ExplicitInfo)
2862  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2863  ExplicitInfo->TypeAsWritten = T;
2864  }
2865 
2866  /// Gets the type of this specialization as it was written by
2867  /// the user, if it was so written.
2869  return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
2870  }
2871 
2872  /// Gets the location of the extern keyword, if present.
2874  return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
2875  }
2876 
2877  /// Sets the location of the extern keyword.
2879  if (!ExplicitInfo)
2880  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2881  ExplicitInfo->ExternLoc = Loc;
2882  }
2883 
2884  /// Sets the location of the template keyword.
2886  if (!ExplicitInfo)
2887  ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
2888  ExplicitInfo->TemplateKeywordLoc = Loc;
2889  }
2890 
2891  /// Gets the location of the template keyword, if present.
2893  return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
2894  }
2895 
2896  void Profile(llvm::FoldingSetNodeID &ID) const {
2897  Profile(ID, TemplateArgs->asArray(), getASTContext());
2898  }
2899 
2900  static void Profile(llvm::FoldingSetNodeID &ID,
2901  ArrayRef<TemplateArgument> TemplateArgs,
2902  ASTContext &Context) {
2903  ID.AddInteger(TemplateArgs.size());
2904  for (const TemplateArgument &TemplateArg : TemplateArgs)
2905  TemplateArg.Profile(ID, Context);
2906  }
2907 
2908  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2909 
2910  static bool classofKind(Kind K) {
2911  return K >= firstVarTemplateSpecialization &&
2912  K <= lastVarTemplateSpecialization;
2913  }
2914 };
2915 
2918  /// The list of template parameters
2919  TemplateParameterList *TemplateParams = nullptr;
2920 
2921  /// The source info for the template arguments as written.
2922  /// FIXME: redundant with TypeAsWritten?
2923  const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
2924 
2925  /// The variable template partial specialization from which this
2926  /// variable template partial specialization was instantiated.
2927  ///
2928  /// The boolean value will be true to indicate that this variable template
2929  /// partial specialization was specialized at this level.
2930  llvm::PointerIntPair<VarTemplatePartialSpecializationDecl *, 1, bool>
2931  InstantiatedFromMember;
2932 
2934  ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2935  SourceLocation IdLoc, TemplateParameterList *Params,
2936  VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
2938  const ASTTemplateArgumentListInfo *ArgInfos);
2939 
2941  : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization,
2942  Context),
2943  InstantiatedFromMember(nullptr, false) {}
2944 
2945  void anchor() override;
2946 
2947 public:
2948  friend class ASTDeclReader;
2949  friend class ASTDeclWriter;
2950 
2952  Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
2953  SourceLocation IdLoc, TemplateParameterList *Params,
2954  VarTemplateDecl *SpecializedTemplate, QualType T,
2956  const TemplateArgumentListInfo &ArgInfos);
2957 
2958  static VarTemplatePartialSpecializationDecl *CreateDeserialized(ASTContext &C,
2959  unsigned ID);
2960 
2962  return cast<VarTemplatePartialSpecializationDecl>(
2963  static_cast<VarTemplateSpecializationDecl *>(
2964  this)->getMostRecentDecl());
2965  }
2966 
2967  /// Get the list of template parameters
2969  return TemplateParams;
2970  }
2971 
2972  /// Get the template arguments as written.
2974  return ArgsAsWritten;
2975  }
2976 
2977  /// \brief All associated constraints of this partial specialization,
2978  /// including the requires clause and any constraints derived from
2979  /// constrained-parameters.
2980  ///
2981  /// The constraints in the resulting list are to be treated as if in a
2982  /// conjunction ("and").
2984  TemplateParams->getAssociatedConstraints(AC);
2985  }
2986 
2988  return TemplateParams->hasAssociatedConstraints();
2989  }
2990 
2991  /// \brief Retrieve the member variable template partial specialization from
2992  /// which this particular variable template partial specialization was
2993  /// instantiated.
2994  ///
2995  /// \code
2996  /// template<typename T>
2997  /// struct Outer {
2998  /// template<typename U> U Inner;
2999  /// template<typename U> U* Inner<U*> = (U*)(0); // #1
3000  /// };
3001  ///
3002  /// template int* Outer<float>::Inner<int*>;
3003  /// \endcode
3004  ///
3005  /// In this example, the instantiation of \c Outer<float>::Inner<int*> will
3006  /// end up instantiating the partial specialization
3007  /// \c Outer<float>::Inner<U*>, which itself was instantiated from the
3008  /// variable template partial specialization \c Outer<T>::Inner<U*>. Given
3009  /// \c Outer<float>::Inner<U*>, this function would return
3010  /// \c Outer<T>::Inner<U*>.
3012  const auto *First =
3013  cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
3014  return First->InstantiatedFromMember.getPointer();
3015  }
3016 
3017  void
3019  auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
3020  First->InstantiatedFromMember.setPointer(PartialSpec);
3021  }
3022 
3023  /// Determines whether this variable template partial specialization
3024  /// was a specialization of a member partial specialization.
3025  ///
3026  /// In the following example, the member template partial specialization
3027  /// \c X<int>::Inner<T*> is a member specialization.
3028  ///
3029  /// \code
3030  /// template<typename T>
3031  /// struct X {
3032  /// template<typename U> U Inner;
3033  /// template<typename U> U* Inner<U*> = (U*)(0);
3034  /// };
3035  ///
3036  /// template<> template<typename T>
3037  /// U* X<int>::Inner<T*> = (T*)(0) + 1;
3038  /// \endcode
3040  const auto *First =
3041  cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
3042  return First->InstantiatedFromMember.getInt();
3043  }
3044 
3045  /// Note that this member template is a specialization.
3047  auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
3048  assert(First->InstantiatedFromMember.getPointer() &&
3049  "Only member templates can be member template specializations");
3050  return First->InstantiatedFromMember.setInt(true);
3051  }
3052 
3053  void Profile(llvm::FoldingSetNodeID &ID) const {
3054  Profile(ID, getTemplateArgs().asArray(), getTemplateParameters(),
3055  getASTContext());
3056  }
3057 
3058  static void
3059  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
3060  TemplateParameterList *TPL, ASTContext &Context);
3061 
3062  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3063 
3064  static bool classofKind(Kind K) {
3065  return K == VarTemplatePartialSpecialization;
3066  }
3067 };
3068 
3069 /// Declaration of a variable template.
3071 protected:
3072  /// Data that is common to all of the declarations of a given
3073  /// variable template.
3074  struct Common : CommonBase {
3075  /// The variable template specializations for this variable
3076  /// template, including explicit specializations and instantiations.
3077  llvm::FoldingSetVector<VarTemplateSpecializationDecl> Specializations;
3078 
3079  /// The variable template partial specializations for this variable
3080  /// template.
3081  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>
3083 
3084  Common() = default;
3085  };
3086 
3087  /// Retrieve the set of specializations of this variable template.
3088  llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
3089  getSpecializations() const;
3090 
3091  /// Retrieve the set of partial specializations of this class
3092  /// template.
3093  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
3094  getPartialSpecializations();
3095 
3097  DeclarationName Name, TemplateParameterList *Params,
3098  NamedDecl *Decl)
3099  : RedeclarableTemplateDecl(VarTemplate, C, DC, L, Name, Params, Decl) {}
3100 
3101  CommonBase *newCommon(ASTContext &C) const override;
3102 
3104  return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
3105  }
3106 
3107 public:
3108  friend class ASTDeclReader;
3109  friend class ASTDeclWriter;
3110 
3111  /// Load any lazily-loaded specializations from the external source.
3112  void LoadLazySpecializations() const;
3113 
3114  /// Get the underlying variable declarations of the template.
3116  return static_cast<VarDecl *>(TemplatedDecl);
3117  }
3118 
3119  /// Returns whether this template declaration defines the primary
3120  /// variable pattern.
3122  return getTemplatedDecl()->isThisDeclarationADefinition();
3123  }
3124 
3126 
3127  /// Create a variable template node.
3128  static VarTemplateDecl *Create(ASTContext &C, DeclContext *DC,
3130  TemplateParameterList *Params,
3131  VarDecl *Decl);
3132 
3133  /// Create an empty variable template node.
3134  static VarTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3135 
3136  /// Return the specialization with the provided arguments if it exists,
3137  /// otherwise return the insertion point.
3139  findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
3140 
3141  /// Insert the specified specialization knowing that it is not already
3142  /// in. InsertPos must be obtained from findSpecialization.
3143  void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos);
3144 
3146  return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
3147  }
3149  return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
3150  }
3151 
3152  /// Retrieve the previous declaration of this variable template, or
3153  /// nullptr if no such declaration exists.
3155  return cast_or_null<VarTemplateDecl>(
3156  static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
3157  }
3159  return cast_or_null<VarTemplateDecl>(
3160  static_cast<const RedeclarableTemplateDecl *>(
3161  this)->getPreviousDecl());
3162  }
3163 
3165  return cast<VarTemplateDecl>(
3166  static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
3167  }
3169  return const_cast<VarTemplateDecl *>(this)->getMostRecentDecl();
3170  }
3171 
3173  return cast_or_null<VarTemplateDecl>(
3175  }
3176 
3177  /// Return the partial specialization with the provided arguments if it
3178  /// exists, otherwise return the insertion point.
3180  findPartialSpecialization(ArrayRef<TemplateArgument> Args,
3181  TemplateParameterList *TPL, void *&InsertPos);
3182 
3183  /// Insert the specified partial specialization knowing that it is not
3184  /// already in. InsertPos must be obtained from findPartialSpecialization.
3185  void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D,
3186  void *InsertPos);
3187 
3188  /// Retrieve the partial specializations as an ordered list.
3189  void getPartialSpecializations(
3191 
3192  /// Find a variable template partial specialization which was
3193  /// instantiated
3194  /// from the given member partial specialization.
3195  ///
3196  /// \param D a member variable template partial specialization.
3197  ///
3198  /// \returns the variable template partial specialization which was
3199  /// instantiated
3200  /// from the given member partial specialization, or nullptr if no such
3201  /// partial specialization exists.
3202  VarTemplatePartialSpecializationDecl *findPartialSpecInstantiatedFromMember(
3204 
3206  using spec_range = llvm::iterator_range<spec_iterator>;
3207 
3209  return spec_range(spec_begin(), spec_end());
3210  }
3211 
3213  return makeSpecIterator(getSpecializations(), false);
3214  }
3215 
3217  return makeSpecIterator(getSpecializations(), true);
3218  }
3219 
3220  // Implement isa/cast/dyncast support
3221  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3222  static bool classofKind(Kind K) { return K == VarTemplate; }
3223 };
3224 
3225 // \brief Declaration of a C++2a concept.
3226 class ConceptDecl : public TemplateDecl, public Mergeable<ConceptDecl> {
3227 protected:
3229 
3231  TemplateParameterList *Params, Expr *ConstraintExpr)
3232  : TemplateDecl(Concept, DC, L, Name, Params),
3233  ConstraintExpr(ConstraintExpr) {};
3234 public:
3235  static ConceptDecl *Create(ASTContext &C, DeclContext *DC,
3237  TemplateParameterList *Params,
3238  Expr *ConstraintExpr);
3239  static ConceptDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3240 
3242  return ConstraintExpr;
3243  }
3244 
3245  SourceRange getSourceRange() const override LLVM_READONLY {
3246  return SourceRange(getTemplateParameters()->getTemplateLoc(),
3247  ConstraintExpr->getEndLoc());
3248  }
3249 
3250  bool isTypeConcept() const {
3251  return isa<TemplateTypeParmDecl>(getTemplateParameters()->getParam(0));
3252  }
3253 
3254  // Implement isa/cast/dyncast/etc.
3255  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3256  static bool classofKind(Kind K) { return K == Concept; }
3257 
3258  friend class ASTReader;
3259  friend class ASTDeclReader;
3260  friend class ASTDeclWriter;
3261 };
3262 
3264  if (auto *PD = P.dyn_cast<TemplateTypeParmDecl *>())
3265  return PD;
3266  if (auto *PD = P.dyn_cast<NonTypeTemplateParmDecl *>())
3267  return PD;
3268  return P.get<TemplateTemplateParmDecl *>();
3269 }
3270 
3272  auto *TD = dyn_cast<TemplateDecl>(D);
3273  return TD && (isa<ClassTemplateDecl>(TD) ||
3274  isa<ClassTemplatePartialSpecializationDecl>(TD) ||
3275  isa<TypeAliasTemplateDecl>(TD) ||
3276  isa<TemplateTemplateParmDecl>(TD))
3277  ? TD
3278  : nullptr;
3279 }
3280 
3281 } // namespace clang
3282 
3283 #endif // LLVM_CLANG_AST_DECLTEMPLATE_H
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
const TemplateArgumentLoc & getTemplateArg(unsigned I) const
Returns the nth template argument.
Definition: DeclTemplate.h:736
void setInstantiationOf(ClassTemplateDecl *TemplDecl)
Note that this class template specialization is an instantiation of the given class template...
spec_iterator spec_begin() const
Represents a function declaration or definition.
Definition: Decl.h:1783
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
Definition: DeclTemplate.h:549
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Definition: DeclTemplate.h:529
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr *> &AC) const
All associated constraints of this partial specialization, including the requires clause and any cons...
unsigned getNumTemplateArgs() const
Returns the number of explicit template arguments that were given.
Definition: DeclTemplate.h:733
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this function template specialization.
Definition: DeclTemplate.h:560
llvm::iterator_range< redecl_iterator > redecl_range
Definition: DeclBase.h:944
TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params)
Definition: DeclTemplate.h:412
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:654
RedeclarableTemplateDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Definition: DeclTemplate.h:851
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.
VarTemplateSpecializationDecl * getMostRecentDecl()
ArrayRef< const NamedDecl * > asArray() const
Definition: DeclTemplate.h:134
MemberSpecializationInfo * getMemberSpecializationInfo() const
Get the specialization info if this function template specialization is also a member specialization:...
Definition: DeclTemplate.h:600
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
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.
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
C Language Family Type Representation.
spec_range specializations() const
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:299
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:88
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
TypeAliasTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
ArrayRef< NamedDecl * > asArray()
Definition: DeclTemplate.h:131
void setInheritedDefaultArgument(const ASTContext &C, NonTypeTemplateParmDecl *Parm)
StringRef P
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:434
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr *> &AC) const
Get the associated-constraints of this template parameter.
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:102
void setSpecializationKind(TemplateSpecializationKind TSK)
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:138
static bool classofKind(Kind K)
A container of type source information.
Definition: Type.h:6227
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument&#39;s source information, if any.
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:820
Declaration of a redeclarable template.
Definition: DeclTemplate.h:751
NamedDecl *const * const_iterator
Iterates through the template parameters in this list.
Definition: DeclTemplate.h:122
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:532
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
static bool classofKind(Kind K)
const TemplateArgumentLoc * getTemplateArgs() const
Returns the explicit template arguments that were given.
Definition: DeclTemplate.h:728
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:196
TemplateParmPosition(unsigned D, unsigned P)
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:603
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:47
static const NamedDecl * getDefinition(const Decl *D)
Definition: SemaDecl.cpp:2613
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:644
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:443
Provides information about a dependent function-template specialization declaration.
Definition: DeclTemplate.h:686
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:206
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:84
TemplateArgumentList(const TemplateArgumentList *Other)
Produces a shallow copy of the given template argument list.
Definition: DeclTemplate.h:280
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:168
A C++ nested-name-specifier augmented with source location information.
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.
bool isExpandedParameterPack() const
Whether this parameter is a template type parameter pack that has a known list of different type-cons...
const DefArgStorage & getDefaultArgStorage() const
void * allocateDefaultArgStorageChain(const ASTContext &C)
Definition: Format.h:2445
ClassTemplateSpecializationDecl * getMostRecentDecl()
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
static bool classofKind(Kind K)
Definition: DeclTemplate.h:439
void Profile(llvm::FoldingSetNodeID &ID)
Definition: DeclTemplate.h:606
Declaration of a function specialization at template class scope.
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:195
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:470
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:487
FunctionTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Common * getCommonPtr() const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization. ...
static ClassScopeFunctionSpecializationDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, CXXMethodDecl *FD, bool HasExplicitTemplateArgs, const TemplateArgumentListInfo &TemplateArgs)
const RedeclarableTemplateDecl * getCanonicalDecl() const
Definition: DeclTemplate.h:866
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
void set(ArgType Arg)
Set the default argument.
Definition: DeclTemplate.h:371
bool isInherited() const
Determine whether the default argument for this parameter was inherited from a previous declaration o...
Definition: DeclTemplate.h:347
A convenient class for passing around template argument information.
Definition: TemplateBase.h:554
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr *> &AC) const
All associated constraints of this partial specialization, including the requires clause and any cons...
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
static bool classof(const Decl *D)
Definition: DeclTemplate.h:437
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Definition: DeclTemplate.h:888
static bool classofKind(Kind K)
static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef< TemplateArgument > TemplateArgs, ASTContext &Context)
Definition: DeclTemplate.h:611
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
Represents a declaration of a type.
Definition: Decl.h:3029
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:935
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:290
void setSpecializationKind(TemplateSpecializationKind TSK)
spec_range specializations() const
ArgType get() const
Get the default argument&#39;s value.
Definition: DeclTemplate.h:351
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:495
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
Definition: DeclTemplate.h:302
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:986
const VarTemplateDecl * getMostRecentDecl() const
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:336
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
Definition: DeclBase.h:104
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3193
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:671
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:388
unsigned getNumExpansionParameters() const
Retrieves the number of parameters in an expanded parameter pack.
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:142
const FunctionTemplateDecl * getMostRecentDecl() const
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:421
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:108
CommonBase * getCommonPtr() const
Retrieves the "common" pointer shared by all (re-)declarations of the same template.
SourceLocation End
const VarTemplateDecl * getPreviousDecl() const
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > PartialSpecializations
The variable template partial specializations for this variable template.
void setInherited(const ASTContext &C, ParmDecl *InheritedFrom)
Set that the default argument was inherited from another parameter.
Definition: DeclTemplate.h:377
int Id
Definition: ASTDiff.cpp:190
static bool classof(const Decl *D)
Expr * getPlaceholderTypeConstraint() const
Return the constraint introduced by the placeholder type of this non-type template parameter (if any)...
MemberSpecializationInfo(NamedDecl *IF, TemplateSpecializationKind TSK, SourceLocation POI=SourceLocation())
Definition: DeclTemplate.h:632
llvm::PointerUnion< NamedDecl *, TypeSourceInfo * > FriendUnion
static bool classof(const Decl *D)
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr *> &AC) const
Get the associated-constraints of this template parameter.
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:893
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
Definition: DeclTemplate.h:63
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:293
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:190
bool isTypeConcept() const
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
static bool classof(const Decl *D)
StorageClass
Storage classes.
Definition: Specifiers.h:235
Declaration of an alias template.
FunctionTemplateDecl * getTemplate(unsigned I) const
Returns the i&#39;th template candidate.
Definition: DeclTemplate.h:722
static ArrayRef< TemplateArgument > getTemplateArgs(EntryType *D)
Definition: DeclTemplate.h:777
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:199
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:773
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:288
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:566
NamedDecl * getInstantiatedFrom() const
Retrieve the member declaration from which this member was instantiated.
Definition: DeclTemplate.h:641
OnStackType
Type used to indicate that the template argument list itself is a stack object.
Definition: DeclTemplate.h:260
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration, or explicit instantiation definition.
Definition: DeclTemplate.h:543
#define false
Definition: stdbool.h:17
Stores a list of template parameters and the associated requires-clause (if any) for a TemplateDecl a...
Definition: DeclTemplate.h:217
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:491
bool hasTypeConstraint() const
Determine whether this template parameter has a type-constraint.
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.
bool isAbbreviated() const
Return whether this function template is an abbreviated function template, e.g.
void setPosition(unsigned P)
const Expr * getRequiresClause() const
The constraint-expression of the associated requires-clause.
Definition: DeclTemplate.h:181
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1931
void Profile(llvm::FoldingSetNodeID &ID) const
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
Definition: DeclTemplate.h:176
void Profile(llvm::FoldingSetNodeID &ID) const
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:983
void Profile(llvm::FoldingSetNodeID &ID) const
BuiltinTemplateKind
Kinds of BuiltinTemplateDecl.
Definition: Builtins.h:246
FunctionDecl * getFunction() const
Retrieve the declaration of the function template specialization.
Definition: DeclTemplate.h:526
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:719
static bool classof(const Decl *D)
Definition: DeclTemplate.h:955
Common * getCommonPtr() const
const TemplateArgumentListInfo & getTemplateArgsInfo() const
FunctionTemplateDecl(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
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:459
ConceptDecl(DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, Expr *ConstraintExpr)
void setPointOfInstantiation(SourceLocation Loc)
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
TemplateParameterList(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
ClassTemplateDecl * getMostRecentDecl()
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:178
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
const ParmDecl * getInheritedFrom() const
Get the parameter from which we inherit the default argument, if any.
Definition: DeclTemplate.h:362
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:197
size_t numTrailingObjects(OverloadToken< NamedDecl *>) const
Definition: DeclTemplate.h:98
void setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec)
static bool classofKind(Kind K)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
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:957
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:5511
NamedDecl * TemplatedDecl
Definition: DeclTemplate.h:449
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
Definition: DeclTemplate.h:653
Defines various enumerations that describe declaration and type specifiers.
bool hasPlaceholderTypeConstraint() const
Determine whether this non-type template parameter&#39;s type has a placeholder with a type-constraint...
Represents a template argument.
Definition: TemplateBase.h:50
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
TagTypeKind
The kind of a tag type.
Definition: Type.h:5187
void setPlaceholderTypeConstraint(Expr *E)
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.
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr *> &AC) const
All associated constraints derived from this template parameter list, including the requires clause a...
bool containsUnexpandedParameterPack() const
Determine whether this template parameter list contains an unexpanded parameter pack.
Definition: DeclTemplate.h:163
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
llvm::PointerIntPair< RedeclarableTemplateDecl *, 1, bool > InstantiatedFromMember
The template from which this was most directly instantiated (or null).
Definition: DeclTemplate.h:829
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:402
static ArrayRef< TemplateArgument > getTemplateArgs(FunctionTemplateSpecializationInfo *I)
Definition: DeclTemplate.h:971
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:340
static bool classof(const Decl *D)
void setInheritedDefaultArgument(const ASTContext &C, TemplateTypeParmDecl *Prev)
Set that this default argument was inherited from another parameter.
void print(raw_ostream &Out, const ASTContext &Context, bool OmitTemplateKW=false) const
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.
static bool classofKind(Kind K)
static bool classof(const Decl *D)
Kind getKind() const
Definition: DeclBase.h:432
static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef< TemplateArgument > TemplateArgs, ASTContext &Context)
bool isClassScopeExplicitSpecialization() const
Is this an explicit specialization at class scope (within the class that owns the primary template)...
TemplateParameterList * TemplateParams
Definition: DeclTemplate.h:450
void setTemplateParameters(TemplateParameterList *TParams)
Definition: DeclTemplate.h:452
llvm::iterator_range< redecl_iterator > redecl_range
Definition: Redeclarable.h:290
Storage for a default argument.
Definition: DeclTemplate.h:316
bool hasParameterPack() const
Determine whether this template parameter list contains a parameter pack.
Definition: DeclTemplate.h:168
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:175
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...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
FixedSizeTemplateParameterListStorage(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Definition: DeclTemplate.h:225
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)
Provides common interface for the Decls that cannot be redeclared, but can be merged if the same decl...
Definition: Redeclarable.h:312
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:449
const_iterator end() const
Definition: DeclTemplate.h:127
void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD)
Definition: DeclTemplate.h:939
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:185
friend TrailingObjects
Definition: OpenMPClause.h:98
static DeclType * getDecl(FunctionTemplateSpecializationInfo *I)
Definition: DeclTemplate.h:966
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:863
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:792
A template argument list.
Definition: DeclTemplate.h:239
redeclarable_base::redecl_iterator redecl_iterator
Definition: DeclTemplate.h:945
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:253
TypeAliasTemplateDecl * getInstantiatedFromMemberTemplate() const
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:622
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
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:805
void setExternLoc(SourceLocation Loc)
Sets the location of the extern keyword.
const_iterator begin() const
Definition: DeclTemplate.h:125
VarTemplateDecl * getInstantiatedFromMemberTemplate() const
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:91
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:343
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
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:223
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...
Expr * getConstraintExpr() const
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
Definition: DeclTemplate.h:662
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:667
This file provides AST data structures related to concepts.
SourceLocation getBegin() const
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:199
TrailingObjects::FixedSizeStorageOwner FixedSizeStorageOwner
Definition: DeclTemplate.h:210
Declaration of a template function.
Definition: DeclTemplate.h:977
bool isThisDeclarationADefinition() const
Returns whether this template declaration defines the primary pattern.
FunctionTemplateDecl * getMostRecentDecl()
TemplateArgumentList(OnStackType, ArrayRef< TemplateArgument > Args)
Construct a new, temporary template argument list on the stack.
Definition: DeclTemplate.h:271