Coverage Report

Created: 2018-11-16 02:38

/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
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
/// \file
11
/// Defines the C++ template declaration subclasses.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_AST_DECLTEMPLATE_H
16
#define LLVM_CLANG_AST_DECLTEMPLATE_H
17
18
#include "clang/AST/Decl.h"
19
#include "clang/AST/DeclBase.h"
20
#include "clang/AST/DeclCXX.h"
21
#include "clang/AST/DeclarationName.h"
22
#include "clang/AST/Redeclarable.h"
23
#include "clang/AST/TemplateBase.h"
24
#include "clang/AST/Type.h"
25
#include "clang/Basic/LLVM.h"
26
#include "clang/Basic/SourceLocation.h"
27
#include "clang/Basic/Specifiers.h"
28
#include "llvm/ADT/ArrayRef.h"
29
#include "llvm/ADT/FoldingSet.h"
30
#include "llvm/ADT/PointerIntPair.h"
31
#include "llvm/ADT/PointerUnion.h"
32
#include "llvm/ADT/iterator.h"
33
#include "llvm/ADT/iterator_range.h"
34
#include "llvm/Support/Casting.h"
35
#include "llvm/Support/Compiler.h"
36
#include "llvm/Support/TrailingObjects.h"
37
#include <cassert>
38
#include <cstddef>
39
#include <cstdint>
40
#include <iterator>
41
#include <utility>
42
43
namespace clang {
44
45
enum BuiltinTemplateKind : int;
46
class ClassTemplateDecl;
47
class ClassTemplatePartialSpecializationDecl;
48
class Expr;
49
class FunctionTemplateDecl;
50
class IdentifierInfo;
51
class NonTypeTemplateParmDecl;
52
class TemplateDecl;
53
class TemplateTemplateParmDecl;
54
class TemplateTypeParmDecl;
55
class UnresolvedSetImpl;
56
class VarTemplateDecl;
57
class VarTemplatePartialSpecializationDecl;
58
59
/// Stores a template parameter of any kind.
60
using TemplateParameter =
61
    llvm::PointerUnion3<TemplateTypeParmDecl *, NonTypeTemplateParmDecl *,
62
                        TemplateTemplateParmDecl *>;
63
64
NamedDecl *getAsNamedDecl(TemplateParameter P);
65
66
/// Stores a list of template parameters for a TemplateDecl and its
67
/// derived classes.
68
class TemplateParameterList final
69
    : private llvm::TrailingObjects<TemplateParameterList, NamedDecl *,
70
                                    Expr *> {
71
  /// The location of the 'template' keyword.
72
  SourceLocation TemplateLoc;
73
74
  /// The locations of the '<' and '>' angle brackets.
75
  SourceLocation LAngleLoc, RAngleLoc;
76
77
  /// The number of template parameters in this template
78
  /// parameter list.
79
  unsigned NumParams : 30;
80
81
  /// Whether this template parameter list contains an unexpanded parameter
82
  /// pack.
83
  unsigned ContainsUnexpandedParameterPack : 1;
84
85
  /// Whether this template parameter list has an associated requires-clause
86
  unsigned HasRequiresClause : 1;
87
88
protected:
89
  TemplateParameterList(SourceLocation TemplateLoc, SourceLocation LAngleLoc,
90
                        ArrayRef<NamedDecl *> Params, SourceLocation RAngleLoc,
91
                        Expr *RequiresClause);
92
93
54
  size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
94
54
    return NumParams;
95
54
  }
96
97
0
  size_t numTrailingObjects(OverloadToken<Expr *>) const {
98
0
    return HasRequiresClause;
99
0
  }
100
101
public:
102
  template <size_t N, bool HasRequiresClause>
103
  friend class FixedSizeTemplateParameterListStorage;
104
  friend TrailingObjects;
105
106
  static TemplateParameterList *Create(const ASTContext &C,
107
                                       SourceLocation TemplateLoc,
108
                                       SourceLocation LAngleLoc,
109
                                       ArrayRef<NamedDecl *> Params,
110
                                       SourceLocation RAngleLoc,
111
                                       Expr *RequiresClause);
112
113
  /// Iterates through the template parameters in this list.
114
  using iterator = NamedDecl **;
115
116
  /// Iterates through the template parameters in this list.
117
  using const_iterator = NamedDecl * const *;
118
119
27.9M
  iterator begin() { return getTrailingObjects<NamedDecl *>(); }
120
11.7M
  const_iterator begin() const { return getTrailingObjects<NamedDecl *>(); }
121
11.1M
  iterator end() { return begin() + NumParams; }
122
2.08M
  const_iterator end() const { return begin() + NumParams; }
123
124
21.8M
  unsigned size() const { return NumParams; }
125
126
34
  ArrayRef<NamedDecl*> asArray() {
127
34
    return llvm::makeArrayRef(begin(), end());
128
34
  }
129
5.74M
  ArrayRef<const NamedDecl*> asArray() const {
130
5.74M
    return llvm::makeArrayRef(begin(), size());
131
5.74M
  }
132
133
4.04M
  NamedDecl* getParam(unsigned Idx) {
134
4.04M
    assert(Idx < size() && "Template parameter index out-of-range");
135
4.04M
    return begin()[Idx];
136
4.04M
  }
137
1.88M
  const NamedDecl* getParam(unsigned Idx) const {
138
1.88M
    assert(Idx < size() && "Template parameter index out-of-range");
139
1.88M
    return begin()[Idx];
140
1.88M
  }
141
142
  /// Returns the minimum number of arguments needed to form a
143
  /// template specialization.
144
  ///
145
  /// This may be fewer than the number of template parameters, if some of
146
  /// the parameters have default arguments or if there is a parameter pack.
147
  unsigned getMinRequiredArguments() const;
148
149
  /// Get the depth of this template parameter list in the set of
150
  /// template parameter lists.
151
  ///
152
  /// The first template parameter list in a declaration will have depth 0,
153
  /// the second template parameter list will have depth 1, etc.
154
  unsigned getDepth() const;
155
156
  /// Determine whether this template parameter list contains an
157
  /// unexpanded parameter pack.
158
5.94k
  bool containsUnexpandedParameterPack() const {
159
5.94k
    return ContainsUnexpandedParameterPack;
160
5.94k
  }
161
162
  /// The constraint-expression of the associated requires-clause.
163
574k
  Expr *getRequiresClause() {
164
574k
    return HasRequiresClause ? 
*getTrailingObjects<Expr *>()16
:
nullptr574k
;
165
574k
  }
166
167
  /// The constraint-expression of the associated requires-clause.
168
0
  const Expr *getRequiresClause() const {
169
0
    return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
170
0
  }
171
172
1.62M
  SourceLocation getTemplateLoc() const { return TemplateLoc; }
173
311k
  SourceLocation getLAngleLoc() const { return LAngleLoc; }
174
311k
  SourceLocation getRAngleLoc() const { return RAngleLoc; }
175
176
69.2k
  SourceRange getSourceRange() const LLVM_READONLY {
177
69.2k
    return SourceRange(TemplateLoc, RAngleLoc);
178
69.2k
  }
179
180
public:
181
  // FIXME: workaround for MSVC 2013; remove when no longer needed
182
  using FixedSizeStorageOwner = TrailingObjects::FixedSizeStorageOwner;
183
};
184
185
/// Stores a list of template parameters and the associated
186
/// requires-clause (if any) for a TemplateDecl and its derived classes.
187
/// Suitable for creating on the stack.
188
template <size_t N, bool HasRequiresClause>
189
class FixedSizeTemplateParameterListStorage
190
    : public TemplateParameterList::FixedSizeStorageOwner {
191
  typename TemplateParameterList::FixedSizeStorage<
192
      NamedDecl *, Expr *>::with_counts<
193
      N, HasRequiresClause ? 1u : 0u
194
      >::type storage;
195
196
public:
197
  FixedSizeTemplateParameterListStorage(SourceLocation TemplateLoc,
198
                                        SourceLocation LAngleLoc,
199
                                        ArrayRef<NamedDecl *> Params,
200
                                        SourceLocation RAngleLoc,
201
                                        Expr *RequiresClause)
202
      : FixedSizeStorageOwner(
203
            (assert(N == Params.size()),
204
             assert(HasRequiresClause == static_cast<bool>(RequiresClause)),
205
             new (static_cast<void *>(&storage)) TemplateParameterList(
206
19.5k
                 TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause))) {}
207
};
208
209
/// A template argument list.
210
class TemplateArgumentList final
211
    : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {
212
  /// The template argument list.
213
  const TemplateArgument *Arguments;
214
215
  /// The number of template arguments in this template
216
  /// argument list.
217
  unsigned NumArguments;
218
219
  // Constructs an instance with an internal Argument list, containing
220
  // a copy of the Args array. (Called by CreateCopy)
221
  TemplateArgumentList(ArrayRef<TemplateArgument> Args);
222
223
public:
224
  friend TrailingObjects;
225
226
  TemplateArgumentList(const TemplateArgumentList &) = delete;
227
  TemplateArgumentList &operator=(const TemplateArgumentList &) = delete;
228
229
  /// Type used to indicate that the template argument list itself is a
230
  /// stack object. It does not own its template arguments.
231
  enum OnStackType { OnStack };
232
233
  /// Create a new template argument list that copies the given set of
234
  /// template arguments.
235
  static TemplateArgumentList *CreateCopy(ASTContext &Context,
236
                                          ArrayRef<TemplateArgument> Args);
237
238
  /// Construct a new, temporary template argument list on the stack.
239
  ///
240
  /// The template argument list does not own the template arguments
241
  /// provided.
242
  explicit TemplateArgumentList(OnStackType, ArrayRef<TemplateArgument> Args)
243
1.37M
      : Arguments(Args.data()), NumArguments(Args.size()) {}
244
245
  /// Produces a shallow copy of the given template argument list.
246
  ///
247
  /// This operation assumes that the input argument list outlives it.
248
  /// This takes the list as a pointer to avoid looking like a copy
249
  /// constructor, since this really really isn't safe to use that
250
  /// way.
251
  explicit TemplateArgumentList(const TemplateArgumentList *Other)
252
6.32k
      : Arguments(Other->data()), NumArguments(Other->size()) {}
253
254
  /// Retrieve the template argument at a given index.
255
3.73M
  const TemplateArgument &get(unsigned Idx) const {
256
3.73M
    assert(Idx < NumArguments && "Invalid template argument index");
257
3.73M
    return data()[Idx];
258
3.73M
  }
259
260
  /// Retrieve the template argument at a given index.
261
3.36M
  const TemplateArgument &operator[](unsigned Idx) const { return get(Idx); }
262
263
  /// Produce this as an array ref.
264
7.03M
  ArrayRef<TemplateArgument> asArray() const {
265
7.03M
    return llvm::makeArrayRef(data(), size());
266
7.03M
  }
267
268
  /// Retrieve the number of template arguments in this
269
  /// template argument list.
270
14.2M
  unsigned size() const { return NumArguments; }
271
272
  /// Retrieve a pointer to the template argument list.
273
15.7M
  const TemplateArgument *data() const { return Arguments; }
274
};
275
276
void *allocateDefaultArgStorageChain(const ASTContext &C);
277
278
/// Storage for a default argument. This is conceptually either empty, or an
279
/// argument value, or a pointer to a previous declaration that had a default
280
/// argument.
281
///
282
/// However, this is complicated by modules: while we require all the default
283
/// arguments for a template to be equivalent, there may be more than one, and
284
/// we need to track all the originating parameters to determine if the default
285
/// argument is visible.
286
template<typename ParmDecl, typename ArgType>
287
class DefaultArgStorage {
288
  /// Storage for both the value *and* another parameter from which we inherit
289
  /// the default argument. This is used when multiple default arguments for a
290
  /// parameter are merged together from different modules.
291
  struct Chain {
292
    ParmDecl *PrevDeclWithDefaultArg;
293
    ArgType Value;
294
  };
295
  static_assert(sizeof(Chain) == sizeof(void *) * 2,
296
                "non-pointer argument type?");
297
298
  llvm::PointerUnion3<ArgType, ParmDecl*, Chain*> ValueOrInherited;
299
300
13.1k
  static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {
301
13.1k
    const DefaultArgStorage &Storage = Parm->getDefaultArgStorage();
302
13.1k
    if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl *>())
303
5.32k
      Parm = Prev;
304
13.1k
    assert(!Parm->getDefaultArgStorage()
305
13.1k
                .ValueOrInherited.template is<ParmDecl *>() &&
306
13.1k
           "should only be one level of indirection");
307
13.1k
    return Parm;
308
13.1k
  }
clang::DefaultArgStorage<clang::TemplateTypeParmDecl, clang::TypeSourceInfo*>::getParmOwningDefaultArg(clang::TemplateTypeParmDecl*)
Line
Count
Source
300
12.1k
  static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {
301
12.1k
    const DefaultArgStorage &Storage = Parm->getDefaultArgStorage();
302
12.1k
    if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl *>())
303
5.25k
      Parm = Prev;
304
12.1k
    assert(!Parm->getDefaultArgStorage()
305
12.1k
                .ValueOrInherited.template is<ParmDecl *>() &&
306
12.1k
           "should only be one level of indirection");
307
12.1k
    return Parm;
308
12.1k
  }
clang::DefaultArgStorage<clang::NonTypeTemplateParmDecl, clang::Expr*>::getParmOwningDefaultArg(clang::NonTypeTemplateParmDecl*)
Line
Count
Source
300
939
  static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {
301
939
    const DefaultArgStorage &Storage = Parm->getDefaultArgStorage();
302
939
    if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl *>())
303
74
      Parm = Prev;
304
939
    assert(!Parm->getDefaultArgStorage()
305
939
                .ValueOrInherited.template is<ParmDecl *>() &&
306
939
           "should only be one level of indirection");
307
939
    return Parm;
308
939
  }
clang::DefaultArgStorage<clang::TemplateTemplateParmDecl, clang::TemplateArgumentLoc*>::getParmOwningDefaultArg(clang::TemplateTemplateParmDecl*)
Line
Count
Source
300
91
  static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {
301
91
    const DefaultArgStorage &Storage = Parm->getDefaultArgStorage();
302
91
    if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl *>())
303
3
      Parm = Prev;
304
91
    assert(!Parm->getDefaultArgStorage()
305
91
                .ValueOrInherited.template is<ParmDecl *>() &&
306
91
           "should only be one level of indirection");
307
91
    return Parm;
308
91
  }
309
310
public:
311
2.68M
  DefaultArgStorage() : ValueOrInherited(ArgType()) {}
clang::DefaultArgStorage<clang::TemplateTypeParmDecl, clang::TypeSourceInfo*>::DefaultArgStorage()
Line
Count
Source
311
2.36M
  DefaultArgStorage() : ValueOrInherited(ArgType()) {}
clang::DefaultArgStorage<clang::NonTypeTemplateParmDecl, clang::Expr*>::DefaultArgStorage()
Line
Count
Source
311
312k
  DefaultArgStorage() : ValueOrInherited(ArgType()) {}
clang::DefaultArgStorage<clang::TemplateTemplateParmDecl, clang::TemplateArgumentLoc*>::DefaultArgStorage()
Line
Count
Source
311
7.72k
  DefaultArgStorage() : ValueOrInherited(ArgType()) {}
312
313
  /// Determine whether there is a default argument for this parameter.
314
18.3M
  bool isSet() const { return !ValueOrInherited.isNull(); }
clang::DefaultArgStorage<clang::TemplateTemplateParmDecl, clang::TemplateArgumentLoc*>::isSet() const
Line
Count
Source
314
11.1k
  bool isSet() const { return !ValueOrInherited.isNull(); }
clang::DefaultArgStorage<clang::TemplateTypeParmDecl, clang::TypeSourceInfo*>::isSet() const
Line
Count
Source
314
15.4M
  bool isSet() const { return !ValueOrInherited.isNull(); }
clang::DefaultArgStorage<clang::NonTypeTemplateParmDecl, clang::Expr*>::isSet() const
Line
Count
Source
314
2.85M
  bool isSet() const { return !ValueOrInherited.isNull(); }
315
316
  /// Determine whether the default argument for this parameter was inherited
317
  /// from a previous declaration of the same entity.
318
2.50M
  bool isInherited() const { return ValueOrInherited.template is<ParmDecl*>(); }
clang::DefaultArgStorage<clang::TemplateTemplateParmDecl, clang::TemplateArgumentLoc*>::isInherited() const
Line
Count
Source
318
719
  bool isInherited() const { return ValueOrInherited.template is<ParmDecl*>(); }
clang::DefaultArgStorage<clang::TemplateTypeParmDecl, clang::TypeSourceInfo*>::isInherited() const
Line
Count
Source
318
1.74M
  bool isInherited() const { return ValueOrInherited.template is<ParmDecl*>(); }
clang::DefaultArgStorage<clang::NonTypeTemplateParmDecl, clang::Expr*>::isInherited() const
Line
Count
Source
318
756k
  bool isInherited() const { return ValueOrInherited.template is<ParmDecl*>(); }
319
320
  /// Get the default argument's value. This does not consider whether the
321
  /// default argument is visible.
322
1.44M
  ArgType get() const {
323
1.44M
    const DefaultArgStorage *Storage = this;
324
1.44M
    if (const auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl *>())
325
148k
      Storage = &Prev->getDefaultArgStorage();
326
1.44M
    if (const auto *C = Storage->ValueOrInherited.template dyn_cast<Chain *>())
327
378
      return C->Value;
328
1.44M
    return Storage->ValueOrInherited.template get<ArgType>();
329
1.44M
  }
clang::DefaultArgStorage<clang::TemplateTemplateParmDecl, clang::TemplateArgumentLoc*>::get() const
Line
Count
Source
322
1.07k
  ArgType get() const {
323
1.07k
    const DefaultArgStorage *Storage = this;
324
1.07k
    if (const auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl *>())
325
93
      Storage = &Prev->getDefaultArgStorage();
326
1.07k
    if (const auto *C = Storage->ValueOrInherited.template dyn_cast<Chain *>())
327
175
      return C->Value;
328
896
    return Storage->ValueOrInherited.template get<ArgType>();
329
896
  }
clang::DefaultArgStorage<clang::TemplateTypeParmDecl, clang::TypeSourceInfo*>::get() const
Line
Count
Source
322
862k
  ArgType get() const {
323
862k
    const DefaultArgStorage *Storage = this;
324
862k
    if (const auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl *>())
325
89.9k
      Storage = &Prev->getDefaultArgStorage();
326
862k
    if (const auto *C = Storage->ValueOrInherited.template dyn_cast<Chain *>())
327
126
      return C->Value;
328
862k
    return Storage->ValueOrInherited.template get<ArgType>();
329
862k
  }
clang::DefaultArgStorage<clang::NonTypeTemplateParmDecl, clang::Expr*>::get() const
Line
Count
Source
322
580k
  ArgType get() const {
323
580k
    const DefaultArgStorage *Storage = this;
324
580k
    if (const auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl *>())
325
58.8k
      Storage = &Prev->getDefaultArgStorage();
326
580k
    if (const auto *C = Storage->ValueOrInherited.template dyn_cast<Chain *>())
327
77
      return C->Value;
328
580k
    return Storage->ValueOrInherited.template get<ArgType>();
329
580k
  }
330
331
  /// Get the parameter from which we inherit the default argument, if any.
332
  /// This is the parameter on which the default argument was actually written.
333
423k
  const ParmDecl *getInheritedFrom() const {
334
423k
    if (const auto *D = ValueOrInherited.template dyn_cast<ParmDecl *>())
335
423k
      return D;
336
576
    if (const auto *C = ValueOrInherited.template dyn_cast<Chain *>())
337
38
      return C->PrevDeclWithDefaultArg;
338
538
    return nullptr;
339
538
  }
clang::DefaultArgStorage<clang::TemplateTypeParmDecl, clang::TypeSourceInfo*>::getInheritedFrom() const
Line
Count
Source
333
357k
  const ParmDecl *getInheritedFrom() const {
334
357k
    if (const auto *D = ValueOrInherited.template dyn_cast<ParmDecl *>())
335
357k
      return D;
336
384
    if (const auto *C = ValueOrInherited.template dyn_cast<Chain *>())
337
16
      return C->PrevDeclWithDefaultArg;
338
368
    return nullptr;
339
368
  }
clang::DefaultArgStorage<clang::NonTypeTemplateParmDecl, clang::Expr*>::getInheritedFrom() const
Line
Count
Source
333
65.7k
  const ParmDecl *getInheritedFrom() const {
334
65.7k
    if (const auto *D = ValueOrInherited.template dyn_cast<ParmDecl *>())
335
65.6k
      return D;
336
118
    if (const auto *C = ValueOrInherited.template dyn_cast<Chain *>())
337
11
      return C->PrevDeclWithDefaultArg;
338
107
    return nullptr;
339
107
  }
clang::DefaultArgStorage<clang::TemplateTemplateParmDecl, clang::TemplateArgumentLoc*>::getInheritedFrom() const
Line
Count
Source
333
116
  const ParmDecl *getInheritedFrom() const {
334
116
    if (const auto *D = ValueOrInherited.template dyn_cast<ParmDecl *>())
335
42
      return D;
336
74
    if (const auto *C = ValueOrInherited.template dyn_cast<Chain *>())
337
11
      return C->PrevDeclWithDefaultArg;
338
63
    return nullptr;
339
63
  }
340
341
  /// Set the default argument.
342
182k
  void set(ArgType Arg) {
343
182k
    assert(!isSet() && "default argument already set");
344
182k
    ValueOrInherited = Arg;
345
182k
  }
clang::DefaultArgStorage<clang::TemplateTypeParmDecl, clang::TypeSourceInfo*>::set(clang::TypeSourceInfo*)
Line
Count
Source
342
101k
  void set(ArgType Arg) {
343
101k
    assert(!isSet() && "default argument already set");
344
101k
    ValueOrInherited = Arg;
345
101k
  }
clang::DefaultArgStorage<clang::NonTypeTemplateParmDecl, clang::Expr*>::set(clang::Expr*)
Line
Count
Source
342
80.3k
  void set(ArgType Arg) {
343
80.3k
    assert(!isSet() && "default argument already set");
344
80.3k
    ValueOrInherited = Arg;
345
80.3k
  }
clang::DefaultArgStorage<clang::TemplateTemplateParmDecl, clang::TemplateArgumentLoc*>::set(clang::TemplateArgumentLoc*)
Line
Count
Source
342
257
  void set(ArgType Arg) {
343
257
    assert(!isSet() && "default argument already set");
344
257
    ValueOrInherited = Arg;
345
257
  }
346
347
  /// Set that the default argument was inherited from another parameter.
348
13.1k
  void setInherited(const ASTContext &C, ParmDecl *InheritedFrom) {
349
13.1k
    assert(!isInherited() && "default argument already inherited");
350
13.1k
    InheritedFrom = getParmOwningDefaultArg(InheritedFrom);
351
13.1k
    if (!isSet())
352
12.9k
      ValueOrInherited = InheritedFrom;
353
205
    else
354
205
      ValueOrInherited = new (allocateDefaultArgStorageChain(C))
355
205
          Chain{InheritedFrom, ValueOrInherited.template get<ArgType>()};
356
13.1k
  }
clang::DefaultArgStorage<clang::TemplateTypeParmDecl, clang::TypeSourceInfo*>::setInherited(clang::ASTContext const&, clang::TemplateTypeParmDecl*)
Line
Count
Source
348
12.1k
  void setInherited(const ASTContext &C, ParmDecl *InheritedFrom) {
349
12.1k
    assert(!isInherited() && "default argument already inherited");
350
12.1k
    InheritedFrom = getParmOwningDefaultArg(InheritedFrom);
351
12.1k
    if (!isSet())
352
12.0k
      ValueOrInherited = InheritedFrom;
353
89
    else
354
89
      ValueOrInherited = new (allocateDefaultArgStorageChain(C))
355
89
          Chain{InheritedFrom, ValueOrInherited.template get<ArgType>()};
356
12.1k
  }
clang::DefaultArgStorage<clang::NonTypeTemplateParmDecl, clang::Expr*>::setInherited(clang::ASTContext const&, clang::NonTypeTemplateParmDecl*)
Line
Count
Source
348
939
  void setInherited(const ASTContext &C, ParmDecl *InheritedFrom) {
349
939
    assert(!isInherited() && "default argument already inherited");
350
939
    InheritedFrom = getParmOwningDefaultArg(InheritedFrom);
351
939
    if (!isSet())
352
881
      ValueOrInherited = InheritedFrom;
353
58
    else
354
58
      ValueOrInherited = new (allocateDefaultArgStorageChain(C))
355
58
          Chain{InheritedFrom, ValueOrInherited.template get<ArgType>()};
356
939
  }
clang::DefaultArgStorage<clang::TemplateTemplateParmDecl, clang::TemplateArgumentLoc*>::setInherited(clang::ASTContext const&, clang::TemplateTemplateParmDecl*)
Line
Count
Source
348
91
  void setInherited(const ASTContext &C, ParmDecl *InheritedFrom) {
349
91
    assert(!isInherited() && "default argument already inherited");
350
91
    InheritedFrom = getParmOwningDefaultArg(InheritedFrom);
351
91
    if (!isSet())
352
33
      ValueOrInherited = InheritedFrom;
353
58
    else
354
58
      ValueOrInherited = new (allocateDefaultArgStorageChain(C))
355
58
          Chain{InheritedFrom, ValueOrInherited.template get<ArgType>()};
356
91
  }
357
358
  /// Remove the default argument, even if it was inherited.
359
60
  void clear() {
360
60
    ValueOrInherited = ArgType();
361
60
  }
clang::DefaultArgStorage<clang::TemplateTypeParmDecl, clang::TypeSourceInfo*>::clear()
Line
Count
Source
359
40
  void clear() {
360
40
    ValueOrInherited = ArgType();
361
40
  }
clang::DefaultArgStorage<clang::NonTypeTemplateParmDecl, clang::Expr*>::clear()
Line
Count
Source
359
10
  void clear() {
360
10
    ValueOrInherited = ArgType();
361
10
  }
clang::DefaultArgStorage<clang::TemplateTemplateParmDecl, clang::TemplateArgumentLoc*>::clear()
Line
Count
Source
359
10
  void clear() {
360
10
    ValueOrInherited = ArgType();
361
10
  }
362
};
363
364
//===----------------------------------------------------------------------===//
365
// Kinds of Templates
366
//===----------------------------------------------------------------------===//
367
368
/// Stores the template parameter list and associated constraints for
369
/// \c TemplateDecl objects that track associated constraints.
370
class ConstrainedTemplateDeclInfo {
371
  friend TemplateDecl;
372
373
public:
374
8
  ConstrainedTemplateDeclInfo() = default;
375
376
73
  TemplateParameterList *getTemplateParameters() const {
377
73
    return TemplateParams;
378
73
  }
379
380
9
  Expr *getAssociatedConstraints() const { return AssociatedConstraints; }
381
382
protected:
383
8
  void setTemplateParameters(TemplateParameterList *TParams) {
384
8
    TemplateParams = TParams;
385
8
  }
386
387
8
  void setAssociatedConstraints(Expr *AC) { AssociatedConstraints = AC; }
388
389
  TemplateParameterList *TemplateParams = nullptr;
390
  Expr *AssociatedConstraints = nullptr;
391
};
392
393
394
/// The base class of all kinds of template declarations (e.g.,
395
/// class, function, etc.).
396
///
397
/// The TemplateDecl class stores the list of template parameters and a
398
/// reference to the templated scoped declaration: the underlying AST node.
399
class TemplateDecl : public NamedDecl {
400
  void anchor() override;
401
402
protected:
403
  // Construct a template decl with the given name and parameters.
404
  // Used when there is no templated element (e.g., for tt-params).
405
  TemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK, DeclContext *DC,
406
               SourceLocation L, DeclarationName Name,
407
               TemplateParameterList *Params)
408
      : NamedDecl(DK, DC, L, Name), TemplatedDecl(nullptr),
409
8.34k
        TemplateParams(CTDI) {
410
8.34k
    this->setTemplateParameters(Params);
411
8.34k
  }
412
413
  TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,
414
               TemplateParameterList *Params)
415
8.34k
      : TemplateDecl(nullptr, DK, DC, L, Name, Params) {}
416
417
  // Construct a template decl with name, parameters, and templated element.
418
  TemplateDecl(ConstrainedTemplateDeclInfo *CTDI, Kind DK, DeclContext *DC,
419
               SourceLocation L, DeclarationName Name,
420
               TemplateParameterList *Params, NamedDecl *Decl)
421
      : NamedDecl(DK, DC, L, Name), TemplatedDecl(Decl),
422
1.10M
        TemplateParams(CTDI) {
423
1.10M
    this->setTemplateParameters(Params);
424
1.10M
  }
425
426
  TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,
427
               TemplateParameterList *Params, NamedDecl *Decl)
428
      : TemplateDecl(nullptr, DK, DC, L, Name, Params, Decl) {}
429
430
public:
431
  /// Get the list of template parameters
432
26.3M
  TemplateParameterList *getTemplateParameters() const {
433
26.3M
    const auto *const CTDI =
434
26.3M
        TemplateParams.dyn_cast<ConstrainedTemplateDeclInfo *>();
435
26.3M
    return CTDI ? 
CTDI->getTemplateParameters()73
436
26.3M
                : 
TemplateParams.get<TemplateParameterList *>()26.3M
;
437
26.3M
  }
438
439
  /// Get the constraint-expression from the associated requires-clause (if any)
440
0
  const Expr *getRequiresClause() const {
441
0
    const TemplateParameterList *const TP = getTemplateParameters();
442
0
    return TP ? TP->getRequiresClause() : nullptr;
443
0
  }
444
445
21.3k
  Expr *getAssociatedConstraints() const {
446
21.3k
    const auto *const C = cast<TemplateDecl>(getCanonicalDecl());
447
21.3k
    const auto *const CTDI =
448
21.3k
        C->TemplateParams.dyn_cast<ConstrainedTemplateDeclInfo *>();
449
21.3k
    return CTDI ? 
CTDI->getAssociatedConstraints()9
:
nullptr21.3k
;
450
21.3k
  }
451
452
  /// Get the underlying, templated declaration.
453
2.65M
  NamedDecl *getTemplatedDecl() const { return TemplatedDecl; }
454
455
  // Implement isa/cast/dyncast/etc.
456
48.1M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
457
458
48.1M
  static bool classofKind(Kind K) {
459
48.1M
    return K >= firstTemplate && 
K <= lastTemplate45.6M
;
460
48.1M
  }
461
462
1.07M
  SourceRange getSourceRange() const override LLVM_READONLY {
463
1.07M
    return SourceRange(getTemplateParameters()->getTemplateLoc(),
464
1.07M
                       TemplatedDecl->getSourceRange().getEnd());
465
1.07M
  }
466
467
protected:
468
  NamedDecl *TemplatedDecl;
469
470
  /// The template parameter list and optional requires-clause
471
  /// associated with this declaration; alternatively, a
472
  /// \c ConstrainedTemplateDeclInfo if the associated constraints of the
473
  /// template are being tracked by this particular declaration.
474
  llvm::PointerUnion<TemplateParameterList *,
475
                     ConstrainedTemplateDeclInfo *>
476
      TemplateParams;
477
478
1.11M
  void setTemplateParameters(TemplateParameterList *TParams) {
479
1.11M
    if (auto *const CTDI =
480
8
            TemplateParams.dyn_cast<ConstrainedTemplateDeclInfo *>()) {
481
8
      CTDI->setTemplateParameters(TParams);
482
1.11M
    } else {
483
1.11M
      TemplateParams = TParams;
484
1.11M
    }
485
1.11M
  }
486
487
8
  void setAssociatedConstraints(Expr *AC) {
488
8
    assert(isCanonicalDecl() &&
489
8
           "Attaching associated constraints to non-canonical Decl");
490
8
    TemplateParams.get<ConstrainedTemplateDeclInfo *>()
491
8
        ->setAssociatedConstraints(AC);
492
8
  }
493
494
public:
495
  /// Initialize the underlying templated declaration and
496
  /// template parameters.
497
4.89k
  void init(NamedDecl *templatedDecl, TemplateParameterList* templateParams) {
498
4.89k
    assert(!TemplatedDecl && "TemplatedDecl already set!");
499
4.89k
    assert(!TemplateParams && "TemplateParams already set!");
500
4.89k
    TemplatedDecl = templatedDecl;
501
4.89k
    TemplateParams = templateParams;
502
4.89k
  }
503
};
504
505
/// Provides information about a function template specialization,
506
/// which is a FunctionDecl that has been explicitly specialization or
507
/// instantiated from a function template.
508
class FunctionTemplateSpecializationInfo : public llvm::FoldingSetNode {
509
  FunctionTemplateSpecializationInfo(FunctionDecl *FD,
510
                                     FunctionTemplateDecl *Template,
511
                                     TemplateSpecializationKind TSK,
512
                                     const TemplateArgumentList *TemplateArgs,
513
                       const ASTTemplateArgumentListInfo *TemplateArgsAsWritten,
514
                                     SourceLocation POI)
515
      : Function(FD), Template(Template, TSK - 1),
516
        TemplateArguments(TemplateArgs),
517
        TemplateArgumentsAsWritten(TemplateArgsAsWritten),
518
273k
        PointOfInstantiation(POI) {}
519
520
public:
521
  static FunctionTemplateSpecializationInfo *
522
  Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template,
523
         TemplateSpecializationKind TSK,
524
         const TemplateArgumentList *TemplateArgs,
525
         const TemplateArgumentListInfo *TemplateArgsAsWritten,
526
         SourceLocation POI);
527
528
  /// The function template specialization that this structure
529
  /// describes.
530
  FunctionDecl *Function;
531
532
  /// The function template from which this function template
533
  /// specialization was generated.
534
  ///
535
  /// The two bits contain the top 4 values of TemplateSpecializationKind.
536
  llvm::PointerIntPair<FunctionTemplateDecl *, 2> Template;
537
538
  /// The template arguments used to produce the function template
539
  /// specialization from the function template.
540
  const TemplateArgumentList *TemplateArguments;
541
542
  /// The template arguments as written in the sources, if provided.
543
  const ASTTemplateArgumentListInfo *TemplateArgumentsAsWritten;
544
545
  /// The point at which this function template specialization was
546
  /// first instantiated.
547
  SourceLocation PointOfInstantiation;
548
549
  /// Retrieve the template from which this function was specialized.
550
557k
  FunctionTemplateDecl *getTemplate() const { return Template.getPointer(); }
551
552
  /// Determine what kind of template specialization this is.
553
1.92M
  TemplateSpecializationKind getTemplateSpecializationKind() const {
554
1.92M
    return (TemplateSpecializationKind)(Template.getInt() + 1);
555
1.92M
  }
556
557
87.9k
  bool isExplicitSpecialization() const {
558
87.9k
    return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
559
87.9k
  }
560
561
  /// True if this declaration is an explicit specialization,
562
  /// explicit instantiation declaration, or explicit instantiation
563
  /// definition.
564
328k
  bool isExplicitInstantiationOrSpecialization() const {
565
328k
    return isTemplateExplicitInstantiationOrSpecialization(
566
328k
        getTemplateSpecializationKind());
567
328k
  }
568
569
  /// Set the template specialization kind.
570
120k
  void setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
571
120k
    assert(TSK != TSK_Undeclared &&
572
120k
         "Cannot encode TSK_Undeclared for a function template specialization");
573
120k
    Template.setInt(TSK - 1);
574
120k
  }
575
576
  /// Retrieve the first point of instantiation of this function
577
  /// template specialization.
578
  ///
579
  /// The point of instantiation may be an invalid source location if this
580
  /// function has yet to be instantiated.
581
280k
  SourceLocation getPointOfInstantiation() const {
582
280k
    return PointOfInstantiation;
583
280k
  }
584
585
  /// Set the (first) point of instantiation of this function template
586
  /// specialization.
587
117k
  void setPointOfInstantiation(SourceLocation POI) {
588
117k
    PointOfInstantiation = POI;
589
117k
  }
590
591
740k
  void Profile(llvm::FoldingSetNodeID &ID) {
592
740k
    Profile(ID, TemplateArguments->asArray(),
593
740k
            Function->getASTContext());
594
740k
  }
595
596
  static void
597
  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
598
1.35M
          ASTContext &Context) {
599
1.35M
    ID.AddInteger(TemplateArgs.size());
600
1.35M
    for (const TemplateArgument &TemplateArg : TemplateArgs)
601
1.70M
      TemplateArg.Profile(ID, Context);
602
1.35M
  }
603
};
604
605
/// Provides information a specialization of a member of a class
606
/// template, which may be a member function, static data member,
607
/// member class or member enumeration.
608
class MemberSpecializationInfo {
609
  // The member declaration from which this member was instantiated, and the
610
  // manner in which the instantiation occurred (in the lower two bits).
611
  llvm::PointerIntPair<NamedDecl *, 2> MemberAndTSK;
612
613
  // The point at which this member was first instantiated.
614
  SourceLocation PointOfInstantiation;
615
616
public:
617
  explicit
618
  MemberSpecializationInfo(NamedDecl *IF, TemplateSpecializationKind TSK,
619
                           SourceLocation POI = SourceLocation())
620
1.34M
      : MemberAndTSK(IF, TSK - 1), PointOfInstantiation(POI) {
621
1.34M
    assert(TSK != TSK_Undeclared &&
622
1.34M
           "Cannot encode undeclared template specializations for members");
623
1.34M
  }
624
625
  /// Retrieve the member declaration from which this member was
626
  /// instantiated.
627
23.5M
  NamedDecl *getInstantiatedFrom() const { return MemberAndTSK.getPointer(); }
628
629
  /// Determine what kind of template specialization this is.
630
16.6M
  TemplateSpecializationKind getTemplateSpecializationKind() const {
631
16.6M
    return (TemplateSpecializationKind)(MemberAndTSK.getInt() + 1);
632
16.6M
  }
633
634
632k
  bool isExplicitSpecialization() const {
635
632k
    return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
636
632k
  }
637
638
  /// Set the template specialization kind.
639
1.13M
  void setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
640
1.13M
    assert(TSK != TSK_Undeclared &&
641
1.13M
           "Cannot encode undeclared template specializations for members");
642
1.13M
    MemberAndTSK.setInt(TSK - 1);
643
1.13M
  }
644
645
  /// Retrieve the first point of instantiation of this member.
646
  /// If the point of instantiation is an invalid location, then this member
647
  /// has not yet been instantiated.
648
2.42M
  SourceLocation getPointOfInstantiation() const {
649
2.42M
    return PointOfInstantiation;
650
2.42M
  }
651
652
  /// Set the first point of instantiation.
653
445k
  void setPointOfInstantiation(SourceLocation POI) {
654
445k
    PointOfInstantiation = POI;
655
445k
  }
656
};
657
658
/// Provides information about a dependent function-template
659
/// specialization declaration.
660
///
661
/// Since explicit function template specialization and instantiation
662
/// declarations can only appear in namespace scope, and you can only
663
/// specialize a member of a fully-specialized class, the only way to
664
/// get one of these is in a friend declaration like the following:
665
///
666
/// \code
667
///   template \<class T> void foo(T);
668
///   template \<class T> class A {
669
///     friend void foo<>(T);
670
///   };
671
/// \endcode
672
class DependentFunctionTemplateSpecializationInfo final
673
    : private llvm::TrailingObjects<DependentFunctionTemplateSpecializationInfo,
674
                                    TemplateArgumentLoc,
675
                                    FunctionTemplateDecl *> {
676
  /// The number of potential template candidates.
677
  unsigned NumTemplates;
678
679
  /// The number of template arguments.
680
  unsigned NumArgs;
681
682
  /// The locations of the left and right angle brackets.
683
  SourceRange AngleLocs;
684
685
35.6k
  size_t numTrailingObjects(OverloadToken<TemplateArgumentLoc>) const {
686
35.6k
    return NumArgs;
687
35.6k
  }
688
0
  size_t numTrailingObjects(OverloadToken<FunctionTemplateDecl *>) const {
689
0
    return NumTemplates;
690
0
  }
691
692
  DependentFunctionTemplateSpecializationInfo(
693
                                 const UnresolvedSetImpl &Templates,
694
                                 const TemplateArgumentListInfo &TemplateArgs);
695
696
public:
697
  friend TrailingObjects;
698
699
  static DependentFunctionTemplateSpecializationInfo *
700
  Create(ASTContext &Context, const UnresolvedSetImpl &Templates,
701
         const TemplateArgumentListInfo &TemplateArgs);
702
703
  /// Returns the number of function templates that this might
704
  /// be a specialization of.
705
4.29k
  unsigned getNumTemplates() const { return NumTemplates; }
706
707
  /// Returns the i'th template candidate.
708
34.1k
  FunctionTemplateDecl *getTemplate(unsigned I) const {
709
34.1k
    assert(I < getNumTemplates() && "template index out of range");
710
34.1k
    return getTrailingObjects<FunctionTemplateDecl *>()[I];
711
34.1k
  }
712
713
  /// Returns the explicit template arguments that were given.
714
4.28k
  const TemplateArgumentLoc *getTemplateArgs() const {
715
4.28k
    return getTrailingObjects<TemplateArgumentLoc>();
716
4.28k
  }
717
718
  /// Returns the number of explicit template arguments that were given.
719
4.29k
  unsigned getNumTemplateArgs() const { return NumArgs; }
720
721
  /// Returns the nth template argument.
722
0
  const TemplateArgumentLoc &getTemplateArg(unsigned I) const {
723
0
    assert(I < getNumTemplateArgs() && "template arg index out of range");
724
0
    return getTemplateArgs()[I];
725
0
  }
726
727
4.29k
  SourceLocation getLAngleLoc() const {
728
4.29k
    return AngleLocs.getBegin();
729
4.29k
  }
730
731
4.29k
  SourceLocation getRAngleLoc() const {
732
4.29k
    return AngleLocs.getEnd();
733
4.29k
  }
734
};
735
736
/// Declaration of a redeclarable template.
737
class RedeclarableTemplateDecl : public TemplateDecl,
738
                                 public Redeclarable<RedeclarableTemplateDecl>
739
{
740
  using redeclarable_base = Redeclarable<RedeclarableTemplateDecl>;
741
742
726k
  RedeclarableTemplateDecl *getNextRedeclarationImpl() override {
743
726k
    return getNextRedeclaration();
744
726k
  }
745
746
90.0k
  RedeclarableTemplateDecl *getPreviousDeclImpl() override {
747
90.0k
    return getPreviousDecl();
748
90.0k
  }
749
750
7.84M
  RedeclarableTemplateDecl *getMostRecentDeclImpl() override {
751
7.84M
    return getMostRecentDecl();
752
7.84M
  }
753
754
protected:
755
  template <typename EntryType> struct SpecEntryTraits {
756
    using DeclType = EntryType;
757
758
1.31M
    static DeclType *getDecl(EntryType *D) {
759
1.31M
      return D;
760
1.31M
    }
clang::RedeclarableTemplateDecl::SpecEntryTraits<clang::ClassTemplateSpecializationDecl>::getDecl(clang::ClassTemplateSpecializationDecl*)
Line
Count
Source
758
1.31M
    static DeclType *getDecl(EntryType *D) {
759
1.31M
      return D;
760
1.31M
    }
clang::RedeclarableTemplateDecl::SpecEntryTraits<clang::VarTemplateSpecializationDecl>::getDecl(clang::VarTemplateSpecializationDecl*)
Line
Count
Source
758
558
    static DeclType *getDecl(EntryType *D) {
759
558
      return D;
760
558
    }
clang::RedeclarableTemplateDecl::SpecEntryTraits<clang::ClassTemplatePartialSpecializationDecl>::getDecl(clang::ClassTemplatePartialSpecializationDecl*)
Line
Count
Source
758
800
    static DeclType *getDecl(EntryType *D) {
759
800
      return D;
760
800
    }
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
7.91k
        : 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
3.62k
        : 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
4.07k
        : 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
216
        : SpecIterator::iterator_adaptor_base(std::move(SetIter)) {}
780
781
2.61k
    DeclType *operator*() const {
782
2.61k
      return SETraits::getDecl(&*this->I)->getMostRecentDecl();
783
2.61k
    }
clang::RedeclarableTemplateDecl::SpecIterator<clang::ClassTemplateSpecializationDecl, clang::RedeclarableTemplateDecl::SpecEntryTraits<clang::ClassTemplateSpecializationDecl>, clang::ClassTemplateSpecializationDecl>::operator*() const
Line
Count
Source
781
1.23k
    DeclType *operator*() const {
782
1.23k
      return SETraits::getDecl(&*this->I)->getMostRecentDecl();
783
1.23k
    }
clang::RedeclarableTemplateDecl::SpecIterator<clang::FunctionTemplateSpecializationInfo, clang::RedeclarableTemplateDecl::SpecEntryTraits<clang::FunctionTemplateSpecializationInfo>, clang::FunctionDecl>::operator*() const
Line
Count
Source
781
1.29k
    DeclType *operator*() const {
782
1.29k
      return SETraits::getDecl(&*this->I)->getMostRecentDecl();
783
1.29k
    }
clang::RedeclarableTemplateDecl::SpecIterator<clang::VarTemplateSpecializationDecl, clang::RedeclarableTemplateDecl::SpecEntryTraits<clang::VarTemplateSpecializationDecl>, clang::VarTemplateSpecializationDecl>::operator*() const
Line
Count
Source
781
89
    DeclType *operator*() const {
782
89
      return SETraits::getDecl(&*this->I)->getMostRecentDecl();
783
89
    }
784
785
    DeclType *operator->() const { return **this; }
786
  };
787
788
  template <typename EntryType>
789
  static SpecIterator<EntryType>
790
7.91k
  makeSpecIterator(llvm::FoldingSetVector<EntryType> &Specs, bool isEnd) {
791
7.91k
    return SpecIterator<EntryType>(isEnd ? 
Specs.end()3.95k
:
Specs.begin()3.96k
);
792
7.91k
  }
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
3.62k
  makeSpecIterator(llvm::FoldingSetVector<EntryType> &Specs, bool isEnd) {
791
3.62k
    return SpecIterator<EntryType>(isEnd ? 
Specs.end()1.81k
:
Specs.begin()1.81k
);
792
3.62k
  }
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
4.07k
  makeSpecIterator(llvm::FoldingSetVector<EntryType> &Specs, bool isEnd) {
791
4.07k
    return SpecIterator<EntryType>(isEnd ? 
Specs.end()2.03k
:
Specs.begin()2.04k
);
792
4.07k
  }
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
216
  makeSpecIterator(llvm::FoldingSetVector<EntryType> &Specs, bool isEnd) {
791
216
    return SpecIterator<EntryType>(isEnd ? 
Specs.end()108
:
Specs.begin()108
);
792
216
  }
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
591k
    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.10M
        {}
841
842
  RedeclarableTemplateDecl(Kind DK, ASTContext &C, DeclContext *DC,
843
                           SourceLocation L, DeclarationName Name,
844
                           TemplateParameterList *Params, NamedDecl *Decl)
845
812k
      : 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
68.3M
  RedeclarableTemplateDecl *getCanonicalDecl() override {
855
68.3M
    return getFirstDecl();
856
68.3M
  }
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.58M
  bool isMemberSpecialization() const {
880
2.58M
    return getCommonPtr()->InstantiatedFromMember.getInt();
881
2.58M
  }
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.80M
  RedeclarableTemplateDecl *getInstantiatedFromMemberTemplate() const {
927
1.80M
    return getCommonPtr()->InstantiatedFromMember.getPointer();
928
1.80M
  }
929
930
244k
  void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD) {
931
244k
    assert(!getCommonPtr()->InstantiatedFromMember.getPointer());
932
244k
    getCommonPtr()->InstantiatedFromMember.setPointer(TD);
933
244k
  }
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.26k
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
947
948
8.26k
  static bool classofKind(Kind K) {
949
8.26k
    return K >= firstRedeclarableTemplate && 
K <= lastRedeclarableTemplate6.70k
;
950
8.26k
  }
951
};
952
953
template <> struct RedeclarableTemplateDecl::
954
SpecEntryTraits<FunctionTemplateSpecializationInfo> {
955
  using DeclType = FunctionDecl;
956
957
282k
  static DeclType *getDecl(FunctionTemplateSpecializationInfo *I) {
958
282k
    return I->Function;
959
282k
  }
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
299k
    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
758k
                                 Decl) {}
996
997
  CommonBase *newCommon(ASTContext &C) const override;
998
999
888k
  Common *getCommonPtr() const {
1000
888k
    return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
1001
888k
  }
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
14.8M
  FunctionDecl *getTemplatedDecl() const {
1024
14.8M
    return static_cast<FunctionDecl *>(TemplatedDecl);
1025
14.8M
  }
1026
1027
  /// Returns whether this template declaration defines the primary
1028
  /// pattern.
1029
0
  bool isThisDeclarationADefinition() const {
1030
0
    return getTemplatedDecl()->isThisDeclarationADefinition();
1031
0
  }
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
44.6M
  FunctionTemplateDecl *getCanonicalDecl() override {
1039
44.6M
    return cast<FunctionTemplateDecl>(
1040
44.6M
             RedeclarableTemplateDecl::getCanonicalDecl());
1041
44.6M
  }
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
560k
  FunctionTemplateDecl *getPreviousDecl() {
1050
560k
    return cast_or_null<FunctionTemplateDecl>(
1051
560k
             static_cast<RedeclarableTemplateDecl *>(this)->getPreviousDecl());
1052
560k
  }
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
881k
  FunctionTemplateDecl *getInstantiatedFromMemberTemplate() const {
1068
881k
    return cast_or_null<FunctionTemplateDecl>(
1069
881k
             RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
1070
881k
  }
1071
1072
  using spec_iterator = SpecIterator<FunctionTemplateSpecializationInfo>;
1073
  using spec_range = llvm::iterator_range<spec_iterator>;
1074
1075
2.03k
  spec_range specializations() const {
1076
2.03k
    return spec_range(spec_begin(), spec_end());
1077
2.03k
  }
1078
1079
2.04k
  spec_iterator spec_begin() const {
1080
2.04k
    return makeSpecIterator(getSpecializations(), false);
1081
2.04k
  }
1082
1083
2.03k
  spec_iterator spec_end() const {
1084
2.03k
    return makeSpecIterator(getSpecializations(), true);
1085
2.03k
  }
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
221M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1111
221M
  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
319k
  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.62M
  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
848k
  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.01M
  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.36M
      : 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
369k
  bool wasDeclaredWithTypename() const { return Typename; }
1192
1193
1.45M
  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1194
1195
  /// Determine whether this template parameter has a default
1196
  /// argument.
1197
15.4M
  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1198
1199
  /// Retrieve the default argument, if any.
1200
85
  QualType getDefaultArgument() const {
1201
85
    return DefaultArgument.get()->getType();
1202
85
  }
1203
1204
  /// Retrieves the default argument's source information, if any.
1205
862k
  TypeSourceInfo *getDefaultArgumentInfo() const {
1206
862k
    return DefaultArgument.get();
1207
862k
  }
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
31.0k
  bool defaultArgumentWasInherited() const {
1215
31.0k
    return DefaultArgument.isInherited();
1216
31.0k
  }
1217
1218
  /// Set the default argument for this template parameter.
1219
101k
  void setDefaultArgument(TypeSourceInfo *DefArg) {
1220
101k
    DefaultArgument.set(DefArg);
1221
101k
  }
1222
1223
  /// Set that this default argument was inherited from another
1224
  /// parameter.
1225
  void setInheritedDefaultArgument(const ASTContext &C,
1226
12.1k
                                   TemplateTypeParmDecl *Prev) {
1227
12.1k
    DefaultArgument.setInherited(C, Prev);
1228
12.1k
  }
1229
1230
  /// Removes the default argument of this template parameter.
1231
40
  void removeDefaultArgument() {
1232
40
    DefaultArgument.clear();
1233
40
  }
1234
1235
  /// Set whether this template type parameter was declared with
1236
  /// the 'typename' or 'class' keyword.
1237
4.23k
  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
87.9M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1252
87.9M
  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
312k
        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
717k
  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1333
1334
  /// Determine whether this template parameter has a default
1335
  /// argument.
1336
2.85M
  bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
1337
1338
  /// Retrieve the default argument, if any.
1339
580k
  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
33.0k
  bool defaultArgumentWasInherited() const {
1347
33.0k
    return DefaultArgument.isInherited();
1348
33.0k
  }
1349
1350
  /// Set the default argument for this template parameter, and
1351
  /// whether that default argument was inherited from another
1352
  /// declaration.
1353
80.3k
  void setDefaultArgument(Expr *DefArg) { DefaultArgument.set(DefArg); }
1354
  void setInheritedDefaultArgument(const ASTContext &C,
1355
939
                                   NonTypeTemplateParmDecl *Parm) {
1356
939
    DefaultArgument.setInherited(C, Parm);
1357
939
  }
1358
1359
  /// Removes the default argument of this template parameter.
1360
10
  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.70M
  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
104k
  bool isPackExpansion() const {
1379
104k
    return ParameterPack && 
getType()->getAs<PackExpansionType>()18.1k
;
1380
104k
  }
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.78M
  bool isExpandedParameterPack() const { return ExpandedParameterPack; }
1407
1408
  /// Retrieves the number of expansion types in an expanded parameter
1409
  /// pack.
1410
153
  unsigned getNumExpansionTypes() const {
1411
153
    assert(ExpandedParameterPack && "Not an expansion parameter pack");
1412
153
    return NumExpandedTypes;
1413
153
  }
1414
1415
  /// Retrieve a particular expansion type within an expanded parameter
1416
  /// pack.
1417
114
  QualType getExpansionType(unsigned I) const {
1418
114
    assert(I < NumExpandedTypes && "Out-of-range expansion type index");
1419
114
    auto TypesAndInfos =
1420
114
        getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
1421
114
    return TypesAndInfos[I].first;
1422
114
  }
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
78.8M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1435
78.8M
  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.70k
        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
91.3k
  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.41k
  bool isPackExpansion() const {
1521
1.41k
    return ParameterPack &&
1522
1.41k
           
getTemplateParameters()->containsUnexpandedParameterPack()100
;
1523
1.41k
  }
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
51.4k
  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
673
  const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
1560
1561
  /// Determine whether this template parameter has a default
1562
  /// argument.
1563
9.98k
  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
140
  bool defaultArgumentWasInherited() const {
1577
140
    return DefaultArgument.isInherited();
1578
140
  }
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
91
                                   TemplateTemplateParmDecl *Prev) {
1587
91
    DefaultArgument.setInherited(C, Prev);
1588
91
  }
1589
1590
  /// Removes the default argument of this template parameter.
1591
10
  void removeDefaultArgument() { DefaultArgument.clear(); }
1592
1593
116
  SourceRange getSourceRange() const override LLVM_READONLY {
1594
116
    SourceLocation End = getLocation();
1595
116
    if (hasDefaultArgument() && 
!defaultArgumentWasInherited()11
)
1596
10
      End = getDefaultArgument().getSourceRange().getEnd();
1597
116
    return SourceRange(getTemplateParameters()->getTemplateLoc(), End);
1598
116
  }
1599
1600
  // Implement isa/cast/dyncast/etc.
1601
83.3M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1602
83.3M
  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.20M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1619
1.20M
  static bool classofKind(Kind K) { return K == BuiltinTemplate; }
1620
1621
  static BuiltinTemplateDecl *Create(const ASTContext &C, DeclContext *DC,
1622
                                     DeclarationName Name,
1623
620
                                     BuiltinTemplateKind BTK) {
1624
620
    return new (C, DC) BuiltinTemplateDecl(C, DC, Name, BTK);
1625
620
  }
1626
1627
0
  SourceRange getSourceRange() const override LLVM_READONLY {
1628
0
    return {};
1629
0
  }
1630
1631
1.71k
  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
235k
    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.17M
  ClassTemplateSpecializationDecl *getMostRecentDecl() {
1726
2.17M
    return cast<ClassTemplateSpecializationDecl>(
1727
2.17M
        getMostRecentNonInjectedDecl());
1728
2.17M
  }
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
6.79M
  const TemplateArgumentList &getTemplateArgs() const {
1736
6.79M
    return *TemplateArgs;
1737
6.79M
  }
1738
1739
  /// Determine the kind of specialization that this
1740
  /// declaration represents.
1741
7.68M
  TemplateSpecializationKind getSpecializationKind() const {
1742
7.68M
    return static_cast<TemplateSpecializationKind>(SpecializationKind);
1743
7.68M
  }
1744
1745
238k
  bool isExplicitSpecialization() const {
1746
238k
    return getSpecializationKind() == TSK_ExplicitSpecialization;
1747
238k
  }
1748
1749
  /// True if this declaration is an explicit specialization,
1750
  /// explicit instantiation declaration, or explicit instantiation
1751
  /// definition.
1752
1.47M
  bool isExplicitInstantiationOrSpecialization() const {
1753
1.47M
    return isTemplateExplicitInstantiationOrSpecialization(
1754
1.47M
        getTemplateSpecializationKind());
1755
1.47M
  }
1756
1757
1.37M
  void setSpecializationKind(TemplateSpecializationKind TSK) {
1758
1.37M
    SpecializationKind = TSK;
1759
1.37M
  }
1760
1761
  /// Get the point of instantiation (if any), or null if none.
1762
9.00k
  SourceLocation getPointOfInstantiation() const {
1763
9.00k
    return PointOfInstantiation;
1764
9.00k
  }
1765
1766
979k
  void setPointOfInstantiation(SourceLocation Loc) {
1767
979k
    assert(Loc.isValid() && "point of instantiation must be valid!");
1768
979k
    PointOfInstantiation = Loc;
1769
979k
  }
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.1k
  getInstantiatedFrom() const {
1778
27.1k
    if (!isTemplateInstantiation(getSpecializationKind()))
1779
6.23k
      return llvm::PointerUnion<ClassTemplateDecl *,
1780
6.23k
                                ClassTemplatePartialSpecializationDecl *>();
1781
20.8k
1782
20.8k
    return getSpecializedTemplateOrPartial();
1783
20.8k
  }
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.05M
  getSpecializedTemplateOrPartial() const {
1790
2.05M
    if (const auto *PartialSpec =
1791
204k
            SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1792
204k
      return PartialSpec->PartialSpecialization;
1793
1.84M
1794
1.84M
    return SpecializedTemplate.get<ClassTemplateDecl*>();
1795
1.84M
  }
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.19M
  const TemplateArgumentList &getTemplateInstantiationArgs() const {
1809
2.19M
    if (const auto *PartialSpec =
1810
278k
            SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1811
278k
      return *PartialSpec->TemplateArgs;
1812
1.91M
1813
1.91M
    return getTemplateArgs();
1814
1.91M
  }
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
204k
                          const TemplateArgumentList *TemplateArgs) {
1821
204k
    assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
1822
204k
           "Already set to a class template partial specialization!");
1823
204k
    auto *PS = new (getASTContext()) SpecializedPartialSpecialization();
1824
204k
    PS->PartialSpecialization = PartialSpec;
1825
204k
    PS->TemplateArgs = TemplateArgs;
1826
204k
    SpecializedTemplate = PS;
1827
204k
  }
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
235k
  void setTypeAsWritten(TypeSourceInfo *T) {
1840
235k
    if (!ExplicitInfo)
1841
235k
      ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1842
235k
    ExplicitInfo->TypeAsWritten = T;
1843
235k
  }
1844
1845
  /// Gets the type of this specialization as it was written by
1846
  /// the user, if it was so written.
1847
172k
  TypeSourceInfo *getTypeAsWritten() const {
1848
172k
    return ExplicitInfo ? 
ExplicitInfo->TypeAsWritten28.9k
:
nullptr143k
;
1849
172k
  }
1850
1851
  /// Gets the location of the extern keyword, if present.
1852
425k
  SourceLocation getExternLoc() const {
1853
425k
    return ExplicitInfo ? ExplicitInfo->ExternLoc : 
SourceLocation()0
;
1854
425k
  }
1855
1856
  /// Sets the location of the extern keyword.
1857
13.3k
  void setExternLoc(SourceLocation Loc) {
1858
13.3k
    if (!ExplicitInfo)
1859
0
      ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1860
13.3k
    ExplicitInfo->ExternLoc = Loc;
1861
13.3k
  }
1862
1863
  /// Sets the location of the template keyword.
1864
232k
  void setTemplateKeywordLoc(SourceLocation Loc) {
1865
232k
    if (!ExplicitInfo)
1866
0
      ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
1867
232k
    ExplicitInfo->TemplateKeywordLoc = Loc;
1868
232k
  }
1869
1870
  /// Gets the location of the template keyword, if present.
1871
426k
  SourceLocation getTemplateKeywordLoc() const {
1872
426k
    return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : 
SourceLocation()0
;
1873
426k
  }
1874
1875
  SourceRange getSourceRange() const override LLVM_READONLY;
1876
1877
2.29M
  void Profile(llvm::FoldingSetNodeID &ID) const {
1878
2.29M
    Profile(ID, TemplateArgs->asArray(), getASTContext());
1879
2.29M
  }
1880
1881
  static void
1882
  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
1883
4.87M
          ASTContext &Context) {
1884
4.87M
    ID.AddInteger(TemplateArgs.size());
1885
4.87M
    for (const TemplateArgument &TemplateArg : TemplateArgs)
1886
7.65M
      TemplateArg.Profile(ID, Context);
1887
4.87M
  }
1888
1889
50.2M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1890
1891
53.2M
  static bool classofKind(Kind K) {
1892
53.2M
    return K >= firstClassTemplateSpecialization &&
1893
53.2M
           
K <= lastClassTemplateSpecialization37.4M
;
1894
53.2M
  }
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
869k
  ClassTemplatePartialSpecializationDecl *getMostRecentDecl() {
1948
869k
    return cast<ClassTemplatePartialSpecializationDecl>(
1949
869k
             static_cast<ClassTemplateSpecializationDecl *>(
1950
869k
               this)->getMostRecentDecl());
1951
869k
  }
1952
1953
  /// Get the list of template parameters
1954
2.48M
  TemplateParameterList *getTemplateParameters() const {
1955
2.48M
    return TemplateParams;
1956
2.48M
  }
1957
1958
  /// Get the template arguments as written.
1959
257k
  const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
1960
257k
    return ArgsAsWritten;
1961
257k
  }
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
208k
  ClassTemplatePartialSpecializationDecl *getInstantiatedFromMember() const {
1984
208k
    const auto *First =
1985
208k
        cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
1986
208k
    return First->InstantiatedFromMember.getPointer();
1987
208k
  }
1988
  ClassTemplatePartialSpecializationDecl *
1989
0
  getInstantiatedFromMemberTemplate() const {
1990
0
    return getInstantiatedFromMember();
1991
0
  }
1992
1993
  void setInstantiatedFromMember(
1994
3.41k
                          ClassTemplatePartialSpecializationDecl *PartialSpec) {
1995
3.41k
    auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
1996
3.41k
    First->InstantiatedFromMember.setPointer(PartialSpec);
1997
3.41k
  }
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
985
  bool isMemberSpecialization() {
2016
985
    const auto *First =
2017
985
        cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
2018
985
    return First->InstantiatedFromMember.getInt();
2019
985
  }
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
311k
  QualType getInjectedSpecializationType() const {
2033
311k
    assert(getTypeForDecl() && "partial specialization has no type set!");
2034
311k
    return cast<InjectedClassNameType>(getTypeForDecl())
2035
311k
             ->getInjectedSpecializationType();
2036
311k
  }
2037
2038
  // FIXME: Add Profile support!
2039
2040
4.44M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2041
2042
109M
  static bool classofKind(Kind K) {
2043
109M
    return K == ClassTemplatePartialSpecialization;
2044
109M
  }
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
269k
    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
5.89M
  Common *getCommonPtr() const {
2091
5.89M
    return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2092
5.89M
  }
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.01M
  CXXRecordDecl *getTemplatedDecl() const {
2103
6.01M
    return static_cast<CXXRecordDecl *>(TemplatedDecl);
2104
6.01M
  }
2105
2106
  /// Returns whether this template declaration defines the primary
2107
  /// class pattern.
2108
309
  bool isThisDeclarationADefinition() const {
2109
309
    return getTemplatedDecl()->isThisDeclarationADefinition();
2110
309
  }
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.3M
  ClassTemplateDecl *getCanonicalDecl() override {
2134
23.3M
    return cast<ClassTemplateDecl>(
2135
23.3M
             RedeclarableTemplateDecl::getCanonicalDecl());
2136
23.3M
  }
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
20.9k
  ClassTemplateDecl *getMostRecentDecl() {
2155
20.9k
    return cast<ClassTemplateDecl>(
2156
20.9k
        static_cast<RedeclarableTemplateDecl *>(this)->getMostRecentDecl());
2157
20.9k
  }
2158
0
  const ClassTemplateDecl *getMostRecentDecl() const {
2159
0
    return const_cast<ClassTemplateDecl*>(this)->getMostRecentDecl();
2160
0
  }
2161
2162
918k
  ClassTemplateDecl *getInstantiatedFromMemberTemplate() const {
2163
918k
    return cast_or_null<ClassTemplateDecl>(
2164
918k
             RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
2165
918k
  }
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
1.80k
  spec_range specializations() const {
2223
1.80k
    return spec_range(spec_begin(), spec_end());
2224
1.80k
  }
2225
2226
1.81k
  spec_iterator spec_begin() const {
2227
1.81k
    return makeSpecIterator(getSpecializations(), false);
2228
1.81k
  }
2229
2230
1.81k
  spec_iterator spec_end() const {
2231
1.81k
    return makeSpecIterator(getSpecializations(), true);
2232
1.81k
  }
2233
2234
  // Implement isa/cast/dyncast support
2235
20.0M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2236
20.0M
  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
52.6k
                                 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
215k
  TypeAliasDecl *getTemplatedDecl() const {
2350
215k
    return static_cast<TypeAliasDecl *>(TemplatedDecl);
2351
215k
  }
2352
2353
2354
318k
  TypeAliasTemplateDecl *getCanonicalDecl() override {
2355
318k
    return cast<TypeAliasTemplateDecl>(
2356
318k
             RedeclarableTemplateDecl::getCanonicalDecl());
2357
318k
  }
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.4M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2392
13.4M
  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
23
        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
21
  CXXMethodDecl *getSpecialization() const { return Specialization; }
2433
17
  bool hasExplicitTemplateArgs() const { return HasExplicitTemplateArgs; }
2434
11
  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
21
                                        TemplateArgumentListInfo TemplateArgs) {
2442
21
    return new (C, DC) ClassScopeFunctionSpecializationDecl(
2443
21
        DC, Loc, FD, HasExplicitTemplateArgs, std::move(TemplateArgs));
2444
21
  }
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
840
  VarTemplateSpecializationDecl *getMostRecentDecl() {
2556
840
    VarDecl *Recent = static_cast<VarDecl *>(this)->getMostRecentDecl();
2557
840
    return cast<VarTemplateSpecializationDecl>(Recent);
2558
840
  }
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.05k
  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
862
  const TemplateArgumentListInfo &getTemplateArgsInfo() const {
2571
862
    return TemplateArgsInfo;
2572
862
  }
2573
2574
  /// Determine the kind of specialization that this
2575
  /// declaration represents.
2576
14.1k
  TemplateSpecializationKind getSpecializationKind() const {
2577
14.1k
    return static_cast<TemplateSpecializationKind>(SpecializationKind);
2578
14.1k
  }
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.77k
  bool isExplicitInstantiationOrSpecialization() const {
2588
1.77k
    return isTemplateExplicitInstantiationOrSpecialization(
2589
1.77k
        getTemplateSpecializationKind());
2590
1.77k
  }
2591
2592
2.39k
  void setSpecializationKind(TemplateSpecializationKind TSK) {
2593
2.39k
    SpecializationKind = TSK;
2594
2.39k
  }
2595
2596
  /// Get the point of instantiation (if any), or null if none.
2597
3.25k
  SourceLocation getPointOfInstantiation() const {
2598
3.25k
    return PointOfInstantiation;
2599
3.25k
  }
2600
2601
894
  void setPointOfInstantiation(SourceLocation Loc) {
2602
894
    assert(Loc.isValid() && "point of instantiation must be valid!");
2603
894
    PointOfInstantiation = Loc;
2604
894
  }
2605
2606
388
  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.16k
  getSpecializedTemplateOrPartial() const {
2625
2.16k
    if (const auto *PartialSpec =
2626
709
            SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2627
709
      return PartialSpec->PartialSpecialization;
2628
1.45k
2629
1.45k
    return SpecializedTemplate.get<VarTemplateDecl *>();
2630
1.45k
  }
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.01k
  const TemplateArgumentList &getTemplateInstantiationArgs() const {
2644
1.01k
    if (const auto *PartialSpec =
2645
363
            SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
2646
363
      return *PartialSpec->TemplateArgs;
2647
652
2648
652
    return getTemplateArgs();
2649
652
  }
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
123
  TypeSourceInfo *getTypeAsWritten() const {
2683
123
    return ExplicitInfo ? 
ExplicitInfo->TypeAsWritten41
:
nullptr82
;
2684
123
  }
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
786
  SourceLocation getTemplateKeywordLoc() const {
2707
786
    return ExplicitInfo ? 
ExplicitInfo->TemplateKeywordLoc95
:
SourceLocation()691
;
2708
786
  }
2709
2710
590
  void Profile(llvm::FoldingSetNodeID &ID) const {
2711
590
    Profile(ID, TemplateArgs->asArray(), getASTContext());
2712
590
  }
2713
2714
  static void Profile(llvm::FoldingSetNodeID &ID,
2715
                      ArrayRef<TemplateArgument> TemplateArgs,
2716
2.38k
                      ASTContext &Context) {
2717
2.38k
    ID.AddInteger(TemplateArgs.size());
2718
2.38k
    for (const TemplateArgument &TemplateArg : TemplateArgs)
2719
2.84k
      TemplateArg.Profile(ID, Context);
2720
2.38k
  }
2721
2722
87.6M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2723
2724
87.6M
  static bool classofKind(Kind K) {
2725
87.6M
    return K >= firstVarTemplateSpecialization &&
2726
87.6M
           
K <= lastVarTemplateSpecialization400k
;
2727
87.6M
  }
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.85M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2854
2855
2.85M
  static bool classofKind(Kind K) {
2856
2.85M
    return K == VarTemplatePartialSpecialization;
2857
2.85M
  }
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
832
    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.30k
      : RedeclarableTemplateDecl(VarTemplate, C, DC, L, Name, Params, Decl) {}
2891
2892
  CommonBase *newCommon(ASTContext &C) const override;
2893
2894
4.36k
  Common *getCommonPtr() const {
2895
4.36k
    return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
2896
4.36k
  }
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.12k
  VarDecl *getTemplatedDecl() const {
2907
4.12k
    return static_cast<VarDecl *>(TemplatedDecl);
2908
4.12k
  }
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
13.3k
  VarTemplateDecl *getCanonicalDecl() override {
2937
13.3k
    return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
2938
13.3k
  }
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
998
  VarTemplateDecl *getInstantiatedFromMemberTemplate() const {
2964
998
    return cast_or_null<VarTemplateDecl>(
2965
998
        RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
2966
998
  }
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
108
  spec_range specializations() const {
2999
108
    return spec_range(spec_begin(), spec_end());
3000
108
  }
3001
3002
108
  spec_iterator spec_begin() const {
3003
108
    return makeSpecIterator(getSpecializations(), false);
3004
108
  }
3005
3006
108
  spec_iterator spec_end() const {
3007
108
    return makeSpecIterator(getSpecializations(), true);
3008
108
  }
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
610k
inline NamedDecl *getAsNamedDecl(TemplateParameter P) {
3016
610k
  if (auto *PD = P.dyn_cast<TemplateTypeParmDecl *>())
3017
198k
    return PD;
3018
412k
  if (auto *PD = P.dyn_cast<NonTypeTemplateParmDecl *>())
3019
412k
    return PD;
3020
134
  return P.get<TemplateTemplateParmDecl *>();
3021
134
}
3022
3023
13.1k
inline TemplateDecl *getAsTypeTemplateDecl(Decl *D) {
3024
13.1k
  auto *TD = dyn_cast<TemplateDecl>(D);
3025
13.1k
  return TD && 
(1.13k
isa<ClassTemplateDecl>(TD)1.13k
||
3026
1.13k
                
isa<ClassTemplatePartialSpecializationDecl>(TD)26
||
3027
1.13k
                
isa<TypeAliasTemplateDecl>(TD)26
||
3028
1.13k
                
isa<TemplateTemplateParmDecl>(TD)17
)
3029
13.1k
             ? 
TD1.13k
3030
13.1k
             : 
nullptr12.0k
;
3031
13.1k
}
3032
3033
} // namespace clang
3034
3035
#endif // LLVM_CLANG_AST_DECLTEMPLATE_H