clang 10.0.0git

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