Coverage Report

Created: 2019-02-21 13:17

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