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