llvm-project

1
//===- DeclTemplate.cpp - Template Declaration AST Node Implementation ----===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This file implements the C++ related Decl classes for templates.
10
//
11
//===----------------------------------------------------------------------===//
12

13
#include "clang/AST/DeclTemplate.h"
14
#include "clang/AST/ASTContext.h"
15
#include "clang/AST/ASTMutationListener.h"
16
#include "clang/AST/DeclCXX.h"
17
#include "clang/AST/DeclarationName.h"
18
#include "clang/AST/Expr.h"
19
#include "clang/AST/ExternalASTSource.h"
20
#include "clang/AST/TemplateBase.h"
21
#include "clang/AST/TemplateName.h"
22
#include "clang/AST/Type.h"
23
#include "clang/AST/TypeLoc.h"
24
#include "clang/Basic/Builtins.h"
25
#include "clang/Basic/LLVM.h"
26
#include "clang/Basic/SourceLocation.h"
27
#include "llvm/ADT/ArrayRef.h"
28
#include "llvm/ADT/FoldingSet.h"
29
#include "llvm/ADT/PointerUnion.h"
30
#include "llvm/ADT/STLExtras.h"
31
#include "llvm/ADT/SmallVector.h"
32
#include "llvm/Support/Casting.h"
33
#include "llvm/Support/ErrorHandling.h"
34
#include <algorithm>
35
#include <cassert>
36
#include <cstdint>
37
#include <memory>
38
#include <optional>
39
#include <utility>
40

41
using namespace clang;
42

43
//===----------------------------------------------------------------------===//
44
// TemplateParameterList Implementation
45
//===----------------------------------------------------------------------===//
46

47

48
TemplateParameterList::TemplateParameterList(const ASTContext& C,
49
                                             SourceLocation TemplateLoc,
50
                                             SourceLocation LAngleLoc,
51
                                             ArrayRef<NamedDecl *> Params,
52
                                             SourceLocation RAngleLoc,
53
                                             Expr *RequiresClause)
54
    : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
55
      NumParams(Params.size()), ContainsUnexpandedParameterPack(false),
56
      HasRequiresClause(RequiresClause != nullptr),
57
      HasConstrainedParameters(false) {
58
  for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
59
    NamedDecl *P = Params[Idx];
60
    begin()[Idx] = P;
61

62
    bool IsPack = P->isTemplateParameterPack();
63
    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
64
      if (!IsPack && NTTP->getType()->containsUnexpandedParameterPack())
65
        ContainsUnexpandedParameterPack = true;
66
      if (NTTP->hasPlaceholderTypeConstraint())
67
        HasConstrainedParameters = true;
68
    } else if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P)) {
69
      if (!IsPack &&
70
          TTP->getTemplateParameters()->containsUnexpandedParameterPack())
71
        ContainsUnexpandedParameterPack = true;
72
    } else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
73
      if (const TypeConstraint *TC = TTP->getTypeConstraint()) {
74
        if (TC->getImmediatelyDeclaredConstraint()
75
            ->containsUnexpandedParameterPack())
76
          ContainsUnexpandedParameterPack = true;
77
      }
78
      if (TTP->hasTypeConstraint())
79
        HasConstrainedParameters = true;
80
    } else {
81
      llvm_unreachable("unexpected template parameter type");
82
    }
83
    // FIXME: If a default argument contains an unexpanded parameter pack, the
84
    // template parameter list does too.
85
  }
86

87
  if (HasRequiresClause) {
88
    if (RequiresClause->containsUnexpandedParameterPack())
89
      ContainsUnexpandedParameterPack = true;
90
    *getTrailingObjects<Expr *>() = RequiresClause;
91
  }
92
}
93

94
bool TemplateParameterList::containsUnexpandedParameterPack() const {
95
  if (ContainsUnexpandedParameterPack)
96
    return true;
97
  if (!HasConstrainedParameters)
98
    return false;
99

100
  // An implicit constrained parameter might have had a use of an unexpanded
101
  // pack added to it after the template parameter list was created. All
102
  // implicit parameters are at the end of the parameter list.
103
  for (const NamedDecl *Param : llvm::reverse(asArray())) {
104
    if (!Param->isImplicit())
105
      break;
106

107
    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
108
      const auto *TC = TTP->getTypeConstraint();
109
      if (TC && TC->getImmediatelyDeclaredConstraint()
110
                    ->containsUnexpandedParameterPack())
111
        return true;
112
    }
113
  }
114

115
  return false;
116
}
117

118
TemplateParameterList *
119
TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc,
120
                              SourceLocation LAngleLoc,
121
                              ArrayRef<NamedDecl *> Params,
122
                              SourceLocation RAngleLoc, Expr *RequiresClause) {
123
  void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
124
                             Params.size(), RequiresClause ? 1u : 0u),
125
                         alignof(TemplateParameterList));
126
  return new (Mem) TemplateParameterList(C, TemplateLoc, LAngleLoc, Params,
127
                                         RAngleLoc, RequiresClause);
128
}
129

130
void TemplateParameterList::Profile(llvm::FoldingSetNodeID &ID,
131
                                    const ASTContext &C) const {
132
  const Expr *RC = getRequiresClause();
133
  ID.AddBoolean(RC != nullptr);
134
  if (RC)
135
    RC->Profile(ID, C, /*Canonical=*/true);
136
  ID.AddInteger(size());
137
  for (NamedDecl *D : *this) {
138
    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
139
      ID.AddInteger(0);
140
      ID.AddBoolean(NTTP->isParameterPack());
141
      NTTP->getType().getCanonicalType().Profile(ID);
142
      ID.AddBoolean(NTTP->hasPlaceholderTypeConstraint());
143
      if (const Expr *E = NTTP->getPlaceholderTypeConstraint())
144
        E->Profile(ID, C, /*Canonical=*/true);
145
      continue;
146
    }
147
    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D)) {
148
      ID.AddInteger(1);
149
      ID.AddBoolean(TTP->isParameterPack());
150
      ID.AddBoolean(TTP->hasTypeConstraint());
151
      if (const TypeConstraint *TC = TTP->getTypeConstraint())
152
        TC->getImmediatelyDeclaredConstraint()->Profile(ID, C,
153
                                                        /*Canonical=*/true);
154
      continue;
155
    }
156
    const auto *TTP = cast<TemplateTemplateParmDecl>(D);
157
    ID.AddInteger(2);
158
    ID.AddBoolean(TTP->isParameterPack());
159
    TTP->getTemplateParameters()->Profile(ID, C);
160
  }
161
}
162

163
unsigned TemplateParameterList::getMinRequiredArguments() const {
164
  unsigned NumRequiredArgs = 0;
165
  for (const NamedDecl *P : asArray()) {
166
    if (P->isTemplateParameterPack()) {
167
      if (std::optional<unsigned> Expansions = getExpandedPackSize(P)) {
168
        NumRequiredArgs += *Expansions;
169
        continue;
170
      }
171
      break;
172
    }
173

174
    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
175
      if (TTP->hasDefaultArgument())
176
        break;
177
    } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
178
      if (NTTP->hasDefaultArgument())
179
        break;
180
    } else if (cast<TemplateTemplateParmDecl>(P)->hasDefaultArgument())
181
      break;
182

183
    ++NumRequiredArgs;
184
  }
185

186
  return NumRequiredArgs;
187
}
188

189
unsigned TemplateParameterList::getDepth() const {
190
  if (size() == 0)
191
    return 0;
192

193
  const NamedDecl *FirstParm = getParam(0);
194
  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(FirstParm))
195
    return TTP->getDepth();
196
  else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
197
    return NTTP->getDepth();
198
  else
199
    return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
200
}
201

202
static bool AdoptTemplateParameterList(TemplateParameterList *Params,
203
                                       DeclContext *Owner) {
204
  bool Invalid = false;
205
  for (NamedDecl *P : *Params) {
206
    P->setDeclContext(Owner);
207

208
    if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
209
      if (AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner))
210
        Invalid = true;
211

212
    if (P->isInvalidDecl())
213
      Invalid = true;
214
  }
215
  return Invalid;
216
}
217

218
void TemplateParameterList::
219
getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
220
  if (HasConstrainedParameters)
221
    for (const NamedDecl *Param : *this) {
222
      if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
223
        if (const auto *TC = TTP->getTypeConstraint())
224
          AC.push_back(TC->getImmediatelyDeclaredConstraint());
225
      } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
226
        if (const Expr *E = NTTP->getPlaceholderTypeConstraint())
227
          AC.push_back(E);
228
      }
229
    }
230
  if (HasRequiresClause)
231
    AC.push_back(getRequiresClause());
232
}
233

234
bool TemplateParameterList::hasAssociatedConstraints() const {
235
  return HasRequiresClause || HasConstrainedParameters;
236
}
237

238
bool TemplateParameterList::shouldIncludeTypeForArgument(
239
    const PrintingPolicy &Policy, const TemplateParameterList *TPL,
240
    unsigned Idx) {
241
  if (!TPL || Idx >= TPL->size() || Policy.AlwaysIncludeTypeForTemplateArgument)
242
    return true;
243
  const NamedDecl *TemplParam = TPL->getParam(Idx);
244
  if (const auto *ParamValueDecl =
245
          dyn_cast<NonTypeTemplateParmDecl>(TemplParam))
246
    if (ParamValueDecl->getType()->getContainedDeducedType())
247
      return true;
248
  return false;
249
}
250

251
namespace clang {
252

253
void *allocateDefaultArgStorageChain(const ASTContext &C) {
254
  return new (C) char[sizeof(void*) * 2];
255
}
256

257
} // namespace clang
258

259
//===----------------------------------------------------------------------===//
260
// TemplateDecl Implementation
261
//===----------------------------------------------------------------------===//
262

263
TemplateDecl::TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L,
264
                           DeclarationName Name, TemplateParameterList *Params,
265
                           NamedDecl *Decl)
266
    : NamedDecl(DK, DC, L, Name), TemplatedDecl(Decl), TemplateParams(Params) {}
267

268
void TemplateDecl::anchor() {}
269

270
void TemplateDecl::
271
getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
272
  TemplateParams->getAssociatedConstraints(AC);
273
  if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
274
    if (const Expr *TRC = FD->getTrailingRequiresClause())
275
      AC.push_back(TRC);
276
}
277

278
bool TemplateDecl::hasAssociatedConstraints() const {
279
  if (TemplateParams->hasAssociatedConstraints())
280
    return true;
281
  if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
282
    return FD->getTrailingRequiresClause();
283
  return false;
284
}
285

286
bool TemplateDecl::isTypeAlias() const {
287
  switch (getKind()) {
288
  case TemplateDecl::TypeAliasTemplate:
289
  case TemplateDecl::BuiltinTemplate:
290
    return true;
291
  default:
292
    return false;
293
  };
294
}
295

296
//===----------------------------------------------------------------------===//
297
// RedeclarableTemplateDecl Implementation
298
//===----------------------------------------------------------------------===//
299

300
void RedeclarableTemplateDecl::anchor() {}
301

302
RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const {
303
  if (Common)
304
    return Common;
305

306
  // Walk the previous-declaration chain until we either find a declaration
307
  // with a common pointer or we run out of previous declarations.
308
  SmallVector<const RedeclarableTemplateDecl *, 2> PrevDecls;
309
  for (const RedeclarableTemplateDecl *Prev = getPreviousDecl(); Prev;
310
       Prev = Prev->getPreviousDecl()) {
311
    if (Prev->Common) {
312
      Common = Prev->Common;
313
      break;
314
    }
315

316
    PrevDecls.push_back(Prev);
317
  }
318

319
  // If we never found a common pointer, allocate one now.
320
  if (!Common) {
321
    // FIXME: If any of the declarations is from an AST file, we probably
322
    // need an update record to add the common data.
323

324
    Common = newCommon(getASTContext());
325
  }
326

327
  // Update any previous declarations we saw with the common pointer.
328
  for (const RedeclarableTemplateDecl *Prev : PrevDecls)
329
    Prev->Common = Common;
330

331
  return Common;
332
}
333

334
void RedeclarableTemplateDecl::loadLazySpecializationsImpl() const {
335
  // Grab the most recent declaration to ensure we've loaded any lazy
336
  // redeclarations of this template.
337
  CommonBase *CommonBasePtr = getMostRecentDecl()->getCommonPtr();
338
  if (CommonBasePtr->LazySpecializations) {
339
    ASTContext &Context = getASTContext();
340
    GlobalDeclID *Specs = CommonBasePtr->LazySpecializations;
341
    CommonBasePtr->LazySpecializations = nullptr;
342
    unsigned SpecSize = (*Specs++).getRawValue();
343
    for (unsigned I = 0; I != SpecSize; ++I)
344
      (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
345
  }
346
}
347

348
template<class EntryType, typename... ProfileArguments>
349
typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
350
RedeclarableTemplateDecl::findSpecializationImpl(
351
    llvm::FoldingSetVector<EntryType> &Specs, void *&InsertPos,
352
    ProfileArguments&&... ProfileArgs) {
353
  using SETraits = SpecEntryTraits<EntryType>;
354

355
  llvm::FoldingSetNodeID ID;
356
  EntryType::Profile(ID, std::forward<ProfileArguments>(ProfileArgs)...,
357
                     getASTContext());
358
  EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);
359
  return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr;
360
}
361

362
template<class Derived, class EntryType>
363
void RedeclarableTemplateDecl::addSpecializationImpl(
364
    llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
365
    void *InsertPos) {
366
  using SETraits = SpecEntryTraits<EntryType>;
367

368
  if (InsertPos) {
369
#ifndef NDEBUG
370
    void *CorrectInsertPos;
371
    assert(!findSpecializationImpl(Specializations,
372
                                   CorrectInsertPos,
373
                                   SETraits::getTemplateArgs(Entry)) &&
374
           InsertPos == CorrectInsertPos &&
375
           "given incorrect InsertPos for specialization");
376
#endif
377
    Specializations.InsertNode(Entry, InsertPos);
378
  } else {
379
    EntryType *Existing = Specializations.GetOrInsertNode(Entry);
380
    (void)Existing;
381
    assert(SETraits::getDecl(Existing)->isCanonicalDecl() &&
382
           "non-canonical specialization?");
383
  }
384

385
  if (ASTMutationListener *L = getASTMutationListener())
386
    L->AddedCXXTemplateSpecialization(cast<Derived>(this),
387
                                      SETraits::getDecl(Entry));
388
}
389

390
ArrayRef<TemplateArgument> RedeclarableTemplateDecl::getInjectedTemplateArgs() {
391
  TemplateParameterList *Params = getTemplateParameters();
392
  auto *CommonPtr = getCommonPtr();
393
  if (!CommonPtr->InjectedArgs) {
394
    auto &Context = getASTContext();
395
    SmallVector<TemplateArgument, 16> TemplateArgs;
396
    Context.getInjectedTemplateArgs(Params, TemplateArgs);
397
    CommonPtr->InjectedArgs =
398
        new (Context) TemplateArgument[TemplateArgs.size()];
399
    std::copy(TemplateArgs.begin(), TemplateArgs.end(),
400
              CommonPtr->InjectedArgs);
401
  }
402

403
  return llvm::ArrayRef(CommonPtr->InjectedArgs, Params->size());
404
}
405

406
//===----------------------------------------------------------------------===//
407
// FunctionTemplateDecl Implementation
408
//===----------------------------------------------------------------------===//
409

410
FunctionTemplateDecl *
411
FunctionTemplateDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
412
                             DeclarationName Name,
413
                             TemplateParameterList *Params, NamedDecl *Decl) {
414
  bool Invalid = AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
415
  auto *TD = new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl);
416
  if (Invalid)
417
    TD->setInvalidDecl();
418
  return TD;
419
}
420

421
FunctionTemplateDecl *
422
FunctionTemplateDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) {
423
  return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(),
424
                                          DeclarationName(), nullptr, nullptr);
425
}
426

427
RedeclarableTemplateDecl::CommonBase *
428
FunctionTemplateDecl::newCommon(ASTContext &C) const {
429
  auto *CommonPtr = new (C) Common;
430
  C.addDestruction(CommonPtr);
431
  return CommonPtr;
432
}
433

434
void FunctionTemplateDecl::LoadLazySpecializations() const {
435
  loadLazySpecializationsImpl();
436
}
437

438
llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
439
FunctionTemplateDecl::getSpecializations() const {
440
  LoadLazySpecializations();
441
  return getCommonPtr()->Specializations;
442
}
443

444
FunctionDecl *
445
FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
446
                                         void *&InsertPos) {
447
  return findSpecializationImpl(getSpecializations(), InsertPos, Args);
448
}
449

450
void FunctionTemplateDecl::addSpecialization(
451
      FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
452
  addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
453
                                              InsertPos);
454
}
455

456
void FunctionTemplateDecl::mergePrevDecl(FunctionTemplateDecl *Prev) {
457
  using Base = RedeclarableTemplateDecl;
458

459
  // If we haven't created a common pointer yet, then it can just be created
460
  // with the usual method.
461
  if (!Base::Common)
462
    return;
463

464
  Common *ThisCommon = static_cast<Common *>(Base::Common);
465
  Common *PrevCommon = nullptr;
466
  SmallVector<FunctionTemplateDecl *, 8> PreviousDecls;
467
  for (; Prev; Prev = Prev->getPreviousDecl()) {
468
    if (Prev->Base::Common) {
469
      PrevCommon = static_cast<Common *>(Prev->Base::Common);
470
      break;
471
    }
472
    PreviousDecls.push_back(Prev);
473
  }
474

475
  // If the previous redecl chain hasn't created a common pointer yet, then just
476
  // use this common pointer.
477
  if (!PrevCommon) {
478
    for (auto *D : PreviousDecls)
479
      D->Base::Common = ThisCommon;
480
    return;
481
  }
482

483
  // Ensure we don't leak any important state.
484
  assert(ThisCommon->Specializations.size() == 0 &&
485
         "Can't merge incompatible declarations!");
486

487
  Base::Common = PrevCommon;
488
}
489

490
//===----------------------------------------------------------------------===//
491
// ClassTemplateDecl Implementation
492
//===----------------------------------------------------------------------===//
493

494
ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C, DeclContext *DC,
495
                                             SourceLocation L,
496
                                             DeclarationName Name,
497
                                             TemplateParameterList *Params,
498
                                             NamedDecl *Decl) {
499
  bool Invalid = AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
500
  auto *TD = new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl);
501
  if (Invalid)
502
    TD->setInvalidDecl();
503
  return TD;
504
}
505

506
ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
507
                                                         GlobalDeclID ID) {
508
  return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
509
                                       DeclarationName(), nullptr, nullptr);
510
}
511

512
void ClassTemplateDecl::LoadLazySpecializations() const {
513
  loadLazySpecializationsImpl();
514
}
515

516
llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
517
ClassTemplateDecl::getSpecializations() const {
518
  LoadLazySpecializations();
519
  return getCommonPtr()->Specializations;
520
}
521

522
llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
523
ClassTemplateDecl::getPartialSpecializations() const {
524
  LoadLazySpecializations();
525
  return getCommonPtr()->PartialSpecializations;
526
}
527

528
RedeclarableTemplateDecl::CommonBase *
529
ClassTemplateDecl::newCommon(ASTContext &C) const {
530
  auto *CommonPtr = new (C) Common;
531
  C.addDestruction(CommonPtr);
532
  return CommonPtr;
533
}
534

535
ClassTemplateSpecializationDecl *
536
ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
537
                                      void *&InsertPos) {
538
  return findSpecializationImpl(getSpecializations(), InsertPos, Args);
539
}
540

541
void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
542
                                          void *InsertPos) {
543
  addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
544
}
545

546
ClassTemplatePartialSpecializationDecl *
547
ClassTemplateDecl::findPartialSpecialization(
548
    ArrayRef<TemplateArgument> Args,
549
    TemplateParameterList *TPL, void *&InsertPos) {
550
  return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
551
                                TPL);
552
}
553

554
void ClassTemplatePartialSpecializationDecl::Profile(
555
    llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
556
    TemplateParameterList *TPL, const ASTContext &Context) {
557
  ID.AddInteger(TemplateArgs.size());
558
  for (const TemplateArgument &TemplateArg : TemplateArgs)
559
    TemplateArg.Profile(ID, Context);
560
  TPL->Profile(ID, Context);
561
}
562

563
void ClassTemplateDecl::AddPartialSpecialization(
564
                                      ClassTemplatePartialSpecializationDecl *D,
565
                                      void *InsertPos) {
566
  if (InsertPos)
567
    getPartialSpecializations().InsertNode(D, InsertPos);
568
  else {
569
    ClassTemplatePartialSpecializationDecl *Existing
570
      = getPartialSpecializations().GetOrInsertNode(D);
571
    (void)Existing;
572
    assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
573
  }
574

575
  if (ASTMutationListener *L = getASTMutationListener())
576
    L->AddedCXXTemplateSpecialization(this, D);
577
}
578

579
void ClassTemplateDecl::getPartialSpecializations(
580
    SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) const {
581
  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
582
    = getPartialSpecializations();
583
  PS.clear();
584
  PS.reserve(PartialSpecs.size());
585
  for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs)
586
    PS.push_back(P.getMostRecentDecl());
587
}
588

589
ClassTemplatePartialSpecializationDecl *
590
ClassTemplateDecl::findPartialSpecialization(QualType T) {
591
  ASTContext &Context = getASTContext();
592
  for (ClassTemplatePartialSpecializationDecl &P :
593
       getPartialSpecializations()) {
594
    if (Context.hasSameType(P.getInjectedSpecializationType(), T))
595
      return P.getMostRecentDecl();
596
  }
597

598
  return nullptr;
599
}
600

601
ClassTemplatePartialSpecializationDecl *
602
ClassTemplateDecl::findPartialSpecInstantiatedFromMember(
603
                                    ClassTemplatePartialSpecializationDecl *D) {
604
  Decl *DCanon = D->getCanonicalDecl();
605
  for (ClassTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
606
    if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
607
      return P.getMostRecentDecl();
608
  }
609

610
  return nullptr;
611
}
612

613
QualType
614
ClassTemplateDecl::getInjectedClassNameSpecialization() {
615
  Common *CommonPtr = getCommonPtr();
616
  if (!CommonPtr->InjectedClassNameType.isNull())
617
    return CommonPtr->InjectedClassNameType;
618

619
  // C++0x [temp.dep.type]p2:
620
  //  The template argument list of a primary template is a template argument
621
  //  list in which the nth template argument has the value of the nth template
622
  //  parameter of the class template. If the nth template parameter is a
623
  //  template parameter pack (14.5.3), the nth template argument is a pack
624
  //  expansion (14.5.3) whose pattern is the name of the template parameter
625
  //  pack.
626
  ASTContext &Context = getASTContext();
627
  TemplateParameterList *Params = getTemplateParameters();
628
  SmallVector<TemplateArgument, 16> TemplateArgs;
629
  Context.getInjectedTemplateArgs(Params, TemplateArgs);
630
  TemplateName Name = Context.getQualifiedTemplateName(
631
      /*NNS=*/nullptr, /*TemplateKeyword=*/false, TemplateName(this));
632
  CommonPtr->InjectedClassNameType =
633
      Context.getTemplateSpecializationType(Name, TemplateArgs);
634
  return CommonPtr->InjectedClassNameType;
635
}
636

637
//===----------------------------------------------------------------------===//
638
// TemplateTypeParm Allocation/Deallocation Method Implementations
639
//===----------------------------------------------------------------------===//
640

641
TemplateTypeParmDecl *TemplateTypeParmDecl::Create(
642
    const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc,
643
    SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id,
644
    bool Typename, bool ParameterPack, bool HasTypeConstraint,
645
    std::optional<unsigned> NumExpanded) {
646
  auto *TTPDecl =
647
      new (C, DC,
648
           additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
649
      TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename,
650
                           HasTypeConstraint, NumExpanded);
651
  QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
652
  TTPDecl->setTypeForDecl(TTPType.getTypePtr());
653
  return TTPDecl;
654
}
655

656
TemplateTypeParmDecl *
657
TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, GlobalDeclID ID) {
658
  return new (C, ID)
659
      TemplateTypeParmDecl(nullptr, SourceLocation(), SourceLocation(), nullptr,
660
                           false, false, std::nullopt);
661
}
662

663
TemplateTypeParmDecl *
664
TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, GlobalDeclID ID,
665
                                         bool HasTypeConstraint) {
666
  return new (C, ID,
667
              additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
668
      TemplateTypeParmDecl(nullptr, SourceLocation(), SourceLocation(), nullptr,
669
                           false, HasTypeConstraint, std::nullopt);
670
}
671

672
SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
673
  return hasDefaultArgument() ? getDefaultArgument().getLocation()
674
                              : SourceLocation();
675
}
676

677
SourceRange TemplateTypeParmDecl::getSourceRange() const {
678
  if (hasDefaultArgument() && !defaultArgumentWasInherited())
679
    return SourceRange(getBeginLoc(),
680
                       getDefaultArgument().getSourceRange().getEnd());
681
  // TypeDecl::getSourceRange returns a range containing name location, which is
682
  // wrong for unnamed template parameters. e.g:
683
  // it will return <[[typename>]] instead of <[[typename]]>
684
  if (getDeclName().isEmpty())
685
    return SourceRange(getBeginLoc());
686
  return TypeDecl::getSourceRange();
687
}
688

689
void TemplateTypeParmDecl::setDefaultArgument(
690
    const ASTContext &C, const TemplateArgumentLoc &DefArg) {
691
  if (DefArg.getArgument().isNull())
692
    DefaultArgument.set(nullptr);
693
  else
694
    DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg));
695
}
696

697
unsigned TemplateTypeParmDecl::getDepth() const {
698
  return getTypeForDecl()->castAs<TemplateTypeParmType>()->getDepth();
699
}
700

701
unsigned TemplateTypeParmDecl::getIndex() const {
702
  return getTypeForDecl()->castAs<TemplateTypeParmType>()->getIndex();
703
}
704

705
bool TemplateTypeParmDecl::isParameterPack() const {
706
  return getTypeForDecl()->castAs<TemplateTypeParmType>()->isParameterPack();
707
}
708

709
void TemplateTypeParmDecl::setTypeConstraint(
710
    ConceptReference *Loc, Expr *ImmediatelyDeclaredConstraint) {
711
  assert(HasTypeConstraint &&
712
         "HasTypeConstraint=true must be passed at construction in order to "
713
         "call setTypeConstraint");
714
  assert(!TypeConstraintInitialized &&
715
         "TypeConstraint was already initialized!");
716
  new (getTrailingObjects<TypeConstraint>())
717
      TypeConstraint(Loc, ImmediatelyDeclaredConstraint);
718
  TypeConstraintInitialized = true;
719
}
720

721
//===----------------------------------------------------------------------===//
722
// NonTypeTemplateParmDecl Method Implementations
723
//===----------------------------------------------------------------------===//
724

725
NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
726
    DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D,
727
    unsigned P, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
728
    ArrayRef<QualType> ExpandedTypes, ArrayRef<TypeSourceInfo *> ExpandedTInfos)
729
    : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
730
      TemplateParmPosition(D, P), ParameterPack(true),
731
      ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {
732
  if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {
733
    auto TypesAndInfos =
734
        getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
735
    for (unsigned I = 0; I != NumExpandedTypes; ++I) {
736
      new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]);
737
      TypesAndInfos[I].second = ExpandedTInfos[I];
738
    }
739
  }
740
}
741

742
NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
743
    const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
744
    SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id,
745
    QualType T, bool ParameterPack, TypeSourceInfo *TInfo) {
746
  AutoType *AT =
747
      C.getLangOpts().CPlusPlus20 ? T->getContainedAutoType() : nullptr;
748
  return new (C, DC,
749
              additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
750
                                    Expr *>(0,
751
                                            AT && AT->isConstrained() ? 1 : 0))
752
      NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, ParameterPack,
753
                              TInfo);
754
}
755

756
NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
757
    const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
758
    SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id,
759
    QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
760
    ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
761
  AutoType *AT = TInfo->getType()->getContainedAutoType();
762
  return new (C, DC,
763
              additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
764
                                    Expr *>(
765
                  ExpandedTypes.size(), AT && AT->isConstrained() ? 1 : 0))
766
      NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
767
                              ExpandedTypes, ExpandedTInfos);
768
}
769

770
NonTypeTemplateParmDecl *
771
NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID,
772
                                            bool HasTypeConstraint) {
773
  return new (C, ID, additionalSizeToAlloc<std::pair<QualType,
774
                                                     TypeSourceInfo *>,
775
                                           Expr *>(0,
776
                                                   HasTypeConstraint ? 1 : 0))
777
          NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
778
                                  0, 0, nullptr, QualType(), false, nullptr);
779
}
780

781
NonTypeTemplateParmDecl *
782
NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID,
783
                                            unsigned NumExpandedTypes,
784
                                            bool HasTypeConstraint) {
785
  auto *NTTP =
786
      new (C, ID,
787
           additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, Expr *>(
788
               NumExpandedTypes, HasTypeConstraint ? 1 : 0))
789
          NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
790
                                  0, 0, nullptr, QualType(), nullptr,
791
                                  std::nullopt, std::nullopt);
792
  NTTP->NumExpandedTypes = NumExpandedTypes;
793
  return NTTP;
794
}
795

796
SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
797
  if (hasDefaultArgument() && !defaultArgumentWasInherited())
798
    return SourceRange(getOuterLocStart(),
799
                       getDefaultArgument().getSourceRange().getEnd());
800
  return DeclaratorDecl::getSourceRange();
801
}
802

803
SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
804
  return hasDefaultArgument() ? getDefaultArgument().getSourceRange().getBegin()
805
                              : SourceLocation();
806
}
807

808
void NonTypeTemplateParmDecl::setDefaultArgument(
809
    const ASTContext &C, const TemplateArgumentLoc &DefArg) {
810
  if (DefArg.getArgument().isNull())
811
    DefaultArgument.set(nullptr);
812
  else
813
    DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg));
814
}
815

816
//===----------------------------------------------------------------------===//
817
// TemplateTemplateParmDecl Method Implementations
818
//===----------------------------------------------------------------------===//
819

820
void TemplateTemplateParmDecl::anchor() {}
821

822
TemplateTemplateParmDecl::TemplateTemplateParmDecl(
823
    DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
824
    IdentifierInfo *Id, bool Typename, TemplateParameterList *Params,
825
    ArrayRef<TemplateParameterList *> Expansions)
826
    : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
827
      TemplateParmPosition(D, P), Typename(Typename), ParameterPack(true),
828
      ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {
829
  if (!Expansions.empty())
830
    std::uninitialized_copy(Expansions.begin(), Expansions.end(),
831
                            getTrailingObjects<TemplateParameterList *>());
832
}
833

834
TemplateTemplateParmDecl *
835
TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
836
                                 SourceLocation L, unsigned D, unsigned P,
837
                                 bool ParameterPack, IdentifierInfo *Id,
838
                                 bool Typename, TemplateParameterList *Params) {
839
  return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
840
                                              Typename, Params);
841
}
842

843
TemplateTemplateParmDecl *
844
TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
845
                                 SourceLocation L, unsigned D, unsigned P,
846
                                 IdentifierInfo *Id, bool Typename,
847
                                 TemplateParameterList *Params,
848
                                 ArrayRef<TemplateParameterList *> Expansions) {
849
  return new (C, DC,
850
              additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
851
      TemplateTemplateParmDecl(DC, L, D, P, Id, Typename, Params, Expansions);
852
}
853

854
TemplateTemplateParmDecl *
855
TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) {
856
  return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
857
                                              false, nullptr, false, nullptr);
858
}
859

860
TemplateTemplateParmDecl *
861
TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID,
862
                                             unsigned NumExpansions) {
863
  auto *TTP =
864
      new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
865
          TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
866
                                   false, nullptr, std::nullopt);
867
  TTP->NumExpandedParams = NumExpansions;
868
  return TTP;
869
}
870

871
SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
872
  return hasDefaultArgument() ? getDefaultArgument().getLocation()
873
                              : SourceLocation();
874
}
875

876
void TemplateTemplateParmDecl::setDefaultArgument(
877
    const ASTContext &C, const TemplateArgumentLoc &DefArg) {
878
  if (DefArg.getArgument().isNull())
879
    DefaultArgument.set(nullptr);
880
  else
881
    DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg));
882
}
883

884
//===----------------------------------------------------------------------===//
885
// TemplateArgumentList Implementation
886
//===----------------------------------------------------------------------===//
887
TemplateArgumentList::TemplateArgumentList(ArrayRef<TemplateArgument> Args)
888
    : NumArguments(Args.size()) {
889
  std::uninitialized_copy(Args.begin(), Args.end(),
890
                          getTrailingObjects<TemplateArgument>());
891
}
892

893
TemplateArgumentList *
894
TemplateArgumentList::CreateCopy(ASTContext &Context,
895
                                 ArrayRef<TemplateArgument> Args) {
896
  void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
897
  return new (Mem) TemplateArgumentList(Args);
898
}
899

900
FunctionTemplateSpecializationInfo *FunctionTemplateSpecializationInfo::Create(
901
    ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template,
902
    TemplateSpecializationKind TSK, TemplateArgumentList *TemplateArgs,
903
    const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI,
904
    MemberSpecializationInfo *MSInfo) {
905
  const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
906
  if (TemplateArgsAsWritten)
907
    ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C,
908
                                                        *TemplateArgsAsWritten);
909

910
  void *Mem =
911
      C.Allocate(totalSizeToAlloc<MemberSpecializationInfo *>(MSInfo ? 1 : 0));
912
  return new (Mem) FunctionTemplateSpecializationInfo(
913
      FD, Template, TSK, TemplateArgs, ArgsAsWritten, POI, MSInfo);
914
}
915

916
//===----------------------------------------------------------------------===//
917
// ClassTemplateSpecializationDecl Implementation
918
//===----------------------------------------------------------------------===//
919

920
ClassTemplateSpecializationDecl::
921
ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
922
                                DeclContext *DC, SourceLocation StartLoc,
923
                                SourceLocation IdLoc,
924
                                ClassTemplateDecl *SpecializedTemplate,
925
                                ArrayRef<TemplateArgument> Args,
926
                                ClassTemplateSpecializationDecl *PrevDecl)
927
    : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,
928
                    SpecializedTemplate->getIdentifier(), PrevDecl),
929
    SpecializedTemplate(SpecializedTemplate),
930
    TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
931
    SpecializationKind(TSK_Undeclared) {
932
}
933

934
ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
935
                                                                 Kind DK)
936
    : CXXRecordDecl(DK, TagTypeKind::Struct, C, nullptr, SourceLocation(),
937
                    SourceLocation(), nullptr, nullptr),
938
      SpecializationKind(TSK_Undeclared) {}
939

940
ClassTemplateSpecializationDecl *
941
ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
942
                                        DeclContext *DC,
943
                                        SourceLocation StartLoc,
944
                                        SourceLocation IdLoc,
945
                                        ClassTemplateDecl *SpecializedTemplate,
946
                                        ArrayRef<TemplateArgument> Args,
947
                                   ClassTemplateSpecializationDecl *PrevDecl) {
948
  auto *Result =
949
      new (Context, DC) ClassTemplateSpecializationDecl(
950
          Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
951
          SpecializedTemplate, Args, PrevDecl);
952
  Result->setMayHaveOutOfDateDef(false);
953

954
  // If the template decl is incomplete, copy the external lexical storage from
955
  // the base template. This allows instantiations of incomplete types to
956
  // complete using the external AST if the template's declaration came from an
957
  // external AST.
958
  if (!SpecializedTemplate->getTemplatedDecl()->isCompleteDefinition())
959
    Result->setHasExternalLexicalStorage(
960
      SpecializedTemplate->getTemplatedDecl()->hasExternalLexicalStorage());
961

962
  Context.getTypeDeclType(Result, PrevDecl);
963
  return Result;
964
}
965

966
ClassTemplateSpecializationDecl *
967
ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
968
                                                    GlobalDeclID ID) {
969
  auto *Result =
970
    new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
971
  Result->setMayHaveOutOfDateDef(false);
972
  return Result;
973
}
974

975
void ClassTemplateSpecializationDecl::getNameForDiagnostic(
976
    raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
977
  NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
978

979
  const auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
980
  if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
981
          PS ? PS->getTemplateArgsAsWritten() : nullptr) {
982
    printTemplateArgumentList(
983
        OS, ArgsAsWritten->arguments(), Policy,
984
        getSpecializedTemplate()->getTemplateParameters());
985
  } else {
986
    const TemplateArgumentList &TemplateArgs = getTemplateArgs();
987
    printTemplateArgumentList(
988
        OS, TemplateArgs.asArray(), Policy,
989
        getSpecializedTemplate()->getTemplateParameters());
990
  }
991
}
992

993
ClassTemplateDecl *
994
ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
995
  if (const auto *PartialSpec =
996
          SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
997
    return PartialSpec->PartialSpecialization->getSpecializedTemplate();
998
  return SpecializedTemplate.get<ClassTemplateDecl*>();
999
}
1000

1001
SourceRange
1002
ClassTemplateSpecializationDecl::getSourceRange() const {
1003
  switch (getSpecializationKind()) {
1004
  case TSK_Undeclared:
1005
  case TSK_ImplicitInstantiation: {
1006
    llvm::PointerUnion<ClassTemplateDecl *,
1007
                       ClassTemplatePartialSpecializationDecl *>
1008
        Pattern = getSpecializedTemplateOrPartial();
1009
    assert(!Pattern.isNull() &&
1010
           "Class template specialization without pattern?");
1011
    if (const auto *CTPSD =
1012
            Pattern.dyn_cast<ClassTemplatePartialSpecializationDecl *>())
1013
      return CTPSD->getSourceRange();
1014
    return Pattern.get<ClassTemplateDecl *>()->getSourceRange();
1015
  }
1016
  case TSK_ExplicitSpecialization: {
1017
    SourceRange Range = CXXRecordDecl::getSourceRange();
1018
    if (const ASTTemplateArgumentListInfo *Args = getTemplateArgsAsWritten();
1019
        !isThisDeclarationADefinition() && Args)
1020
      Range.setEnd(Args->getRAngleLoc());
1021
    return Range;
1022
  }
1023
  case TSK_ExplicitInstantiationDeclaration:
1024
  case TSK_ExplicitInstantiationDefinition: {
1025
    SourceRange Range = CXXRecordDecl::getSourceRange();
1026
    if (SourceLocation ExternKW = getExternKeywordLoc(); ExternKW.isValid())
1027
      Range.setBegin(ExternKW);
1028
    else if (SourceLocation TemplateKW = getTemplateKeywordLoc();
1029
             TemplateKW.isValid())
1030
      Range.setBegin(TemplateKW);
1031
    if (const ASTTemplateArgumentListInfo *Args = getTemplateArgsAsWritten())
1032
      Range.setEnd(Args->getRAngleLoc());
1033
    return Range;
1034
  }
1035
  }
1036
  llvm_unreachable("unhandled template specialization kind");
1037
}
1038

1039
void ClassTemplateSpecializationDecl::setExternKeywordLoc(SourceLocation Loc) {
1040
  auto *Info = ExplicitInfo.dyn_cast<ExplicitInstantiationInfo *>();
1041
  if (!Info) {
1042
    // Don't allocate if the location is invalid.
1043
    if (Loc.isInvalid())
1044
      return;
1045
    Info = new (getASTContext()) ExplicitInstantiationInfo;
1046
    Info->TemplateArgsAsWritten = getTemplateArgsAsWritten();
1047
    ExplicitInfo = Info;
1048
  }
1049
  Info->ExternKeywordLoc = Loc;
1050
}
1051

1052
void ClassTemplateSpecializationDecl::setTemplateKeywordLoc(
1053
    SourceLocation Loc) {
1054
  auto *Info = ExplicitInfo.dyn_cast<ExplicitInstantiationInfo *>();
1055
  if (!Info) {
1056
    // Don't allocate if the location is invalid.
1057
    if (Loc.isInvalid())
1058
      return;
1059
    Info = new (getASTContext()) ExplicitInstantiationInfo;
1060
    Info->TemplateArgsAsWritten = getTemplateArgsAsWritten();
1061
    ExplicitInfo = Info;
1062
  }
1063
  Info->TemplateKeywordLoc = Loc;
1064
}
1065

1066
//===----------------------------------------------------------------------===//
1067
// ConceptDecl Implementation
1068
//===----------------------------------------------------------------------===//
1069
ConceptDecl *ConceptDecl::Create(ASTContext &C, DeclContext *DC,
1070
                                 SourceLocation L, DeclarationName Name,
1071
                                 TemplateParameterList *Params,
1072
                                 Expr *ConstraintExpr) {
1073
  bool Invalid = AdoptTemplateParameterList(Params, DC);
1074
  auto *TD = new (C, DC) ConceptDecl(DC, L, Name, Params, ConstraintExpr);
1075
  if (Invalid)
1076
    TD->setInvalidDecl();
1077
  return TD;
1078
}
1079

1080
ConceptDecl *ConceptDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) {
1081
  ConceptDecl *Result = new (C, ID) ConceptDecl(nullptr, SourceLocation(),
1082
                                                DeclarationName(),
1083
                                                nullptr, nullptr);
1084

1085
  return Result;
1086
}
1087

1088
//===----------------------------------------------------------------------===//
1089
// ImplicitConceptSpecializationDecl Implementation
1090
//===----------------------------------------------------------------------===//
1091
ImplicitConceptSpecializationDecl::ImplicitConceptSpecializationDecl(
1092
    DeclContext *DC, SourceLocation SL,
1093
    ArrayRef<TemplateArgument> ConvertedArgs)
1094
    : Decl(ImplicitConceptSpecialization, DC, SL),
1095
      NumTemplateArgs(ConvertedArgs.size()) {
1096
  setTemplateArguments(ConvertedArgs);
1097
}
1098

1099
ImplicitConceptSpecializationDecl::ImplicitConceptSpecializationDecl(
1100
    EmptyShell Empty, unsigned NumTemplateArgs)
1101
    : Decl(ImplicitConceptSpecialization, Empty),
1102
      NumTemplateArgs(NumTemplateArgs) {}
1103

1104
ImplicitConceptSpecializationDecl *ImplicitConceptSpecializationDecl::Create(
1105
    const ASTContext &C, DeclContext *DC, SourceLocation SL,
1106
    ArrayRef<TemplateArgument> ConvertedArgs) {
1107
  return new (C, DC,
1108
              additionalSizeToAlloc<TemplateArgument>(ConvertedArgs.size()))
1109
      ImplicitConceptSpecializationDecl(DC, SL, ConvertedArgs);
1110
}
1111

1112
ImplicitConceptSpecializationDecl *
1113
ImplicitConceptSpecializationDecl::CreateDeserialized(
1114
    const ASTContext &C, GlobalDeclID ID, unsigned NumTemplateArgs) {
1115
  return new (C, ID, additionalSizeToAlloc<TemplateArgument>(NumTemplateArgs))
1116
      ImplicitConceptSpecializationDecl(EmptyShell{}, NumTemplateArgs);
1117
}
1118

1119
void ImplicitConceptSpecializationDecl::setTemplateArguments(
1120
    ArrayRef<TemplateArgument> Converted) {
1121
  assert(Converted.size() == NumTemplateArgs);
1122
  std::uninitialized_copy(Converted.begin(), Converted.end(),
1123
                          getTrailingObjects<TemplateArgument>());
1124
}
1125

1126
//===----------------------------------------------------------------------===//
1127
// ClassTemplatePartialSpecializationDecl Implementation
1128
//===----------------------------------------------------------------------===//
1129
void ClassTemplatePartialSpecializationDecl::anchor() {}
1130

1131
ClassTemplatePartialSpecializationDecl::ClassTemplatePartialSpecializationDecl(
1132
    ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc,
1133
    SourceLocation IdLoc, TemplateParameterList *Params,
1134
    ClassTemplateDecl *SpecializedTemplate, ArrayRef<TemplateArgument> Args,
1135
    ClassTemplatePartialSpecializationDecl *PrevDecl)
1136
    : ClassTemplateSpecializationDecl(
1137
          Context, ClassTemplatePartialSpecialization, TK, DC, StartLoc, IdLoc,
1138
          SpecializedTemplate, Args, PrevDecl),
1139
      TemplateParams(Params), InstantiatedFromMember(nullptr, false) {
1140
  if (AdoptTemplateParameterList(Params, this))
1141
    setInvalidDecl();
1142
}
1143

1144
ClassTemplatePartialSpecializationDecl *
1145
ClassTemplatePartialSpecializationDecl::Create(
1146
    ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc,
1147
    SourceLocation IdLoc, TemplateParameterList *Params,
1148
    ClassTemplateDecl *SpecializedTemplate, ArrayRef<TemplateArgument> Args,
1149
    QualType CanonInjectedType,
1150
    ClassTemplatePartialSpecializationDecl *PrevDecl) {
1151
  auto *Result = new (Context, DC) ClassTemplatePartialSpecializationDecl(
1152
      Context, TK, DC, StartLoc, IdLoc, Params, SpecializedTemplate, Args,
1153
      PrevDecl);
1154
  Result->setSpecializationKind(TSK_ExplicitSpecialization);
1155
  Result->setMayHaveOutOfDateDef(false);
1156

1157
  Context.getInjectedClassNameType(Result, CanonInjectedType);
1158
  return Result;
1159
}
1160

1161
ClassTemplatePartialSpecializationDecl *
1162
ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
1163
                                                           GlobalDeclID ID) {
1164
  auto *Result = new (C, ID) ClassTemplatePartialSpecializationDecl(C);
1165
  Result->setMayHaveOutOfDateDef(false);
1166
  return Result;
1167
}
1168

1169
SourceRange ClassTemplatePartialSpecializationDecl::getSourceRange() const {
1170
  if (const ClassTemplatePartialSpecializationDecl *MT =
1171
          getInstantiatedFromMember();
1172
      MT && !isMemberSpecialization())
1173
    return MT->getSourceRange();
1174
  SourceRange Range = ClassTemplateSpecializationDecl::getSourceRange();
1175
  if (const TemplateParameterList *TPL = getTemplateParameters();
1176
      TPL && !getNumTemplateParameterLists())
1177
    Range.setBegin(TPL->getTemplateLoc());
1178
  return Range;
1179
}
1180

1181
//===----------------------------------------------------------------------===//
1182
// FriendTemplateDecl Implementation
1183
//===----------------------------------------------------------------------===//
1184

1185
void FriendTemplateDecl::anchor() {}
1186

1187
FriendTemplateDecl *
1188
FriendTemplateDecl::Create(ASTContext &Context, DeclContext *DC,
1189
                           SourceLocation L,
1190
                           MutableArrayRef<TemplateParameterList *> Params,
1191
                           FriendUnion Friend, SourceLocation FLoc) {
1192
  TemplateParameterList **TPL = nullptr;
1193
  if (!Params.empty()) {
1194
    TPL = new (Context) TemplateParameterList *[Params.size()];
1195
    llvm::copy(Params, TPL);
1196
  }
1197
  return new (Context, DC)
1198
      FriendTemplateDecl(DC, L, TPL, Params.size(), Friend, FLoc);
1199
}
1200

1201
FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
1202
                                                           GlobalDeclID ID) {
1203
  return new (C, ID) FriendTemplateDecl(EmptyShell());
1204
}
1205

1206
//===----------------------------------------------------------------------===//
1207
// TypeAliasTemplateDecl Implementation
1208
//===----------------------------------------------------------------------===//
1209

1210
TypeAliasTemplateDecl *
1211
TypeAliasTemplateDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
1212
                              DeclarationName Name,
1213
                              TemplateParameterList *Params, NamedDecl *Decl) {
1214
  bool Invalid = AdoptTemplateParameterList(Params, DC);
1215
  auto *TD = new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl);
1216
  if (Invalid)
1217
    TD->setInvalidDecl();
1218
  return TD;
1219
}
1220

1221
TypeAliasTemplateDecl *
1222
TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) {
1223
  return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
1224
                                           DeclarationName(), nullptr, nullptr);
1225
}
1226

1227
RedeclarableTemplateDecl::CommonBase *
1228
TypeAliasTemplateDecl::newCommon(ASTContext &C) const {
1229
  auto *CommonPtr = new (C) Common;
1230
  C.addDestruction(CommonPtr);
1231
  return CommonPtr;
1232
}
1233

1234
//===----------------------------------------------------------------------===//
1235
// VarTemplateDecl Implementation
1236
//===----------------------------------------------------------------------===//
1237

1238
VarTemplateDecl *VarTemplateDecl::getDefinition() {
1239
  VarTemplateDecl *CurD = this;
1240
  while (CurD) {
1241
    if (CurD->isThisDeclarationADefinition())
1242
      return CurD;
1243
    CurD = CurD->getPreviousDecl();
1244
  }
1245
  return nullptr;
1246
}
1247

1248
VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC,
1249
                                         SourceLocation L, DeclarationName Name,
1250
                                         TemplateParameterList *Params,
1251
                                         VarDecl *Decl) {
1252
  bool Invalid = AdoptTemplateParameterList(Params, DC);
1253
  auto *TD = new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl);
1254
  if (Invalid)
1255
    TD->setInvalidDecl();
1256
  return TD;
1257
}
1258

1259
VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C,
1260
                                                     GlobalDeclID ID) {
1261
  return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
1262
                                     DeclarationName(), nullptr, nullptr);
1263
}
1264

1265
void VarTemplateDecl::LoadLazySpecializations() const {
1266
  loadLazySpecializationsImpl();
1267
}
1268

1269
llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
1270
VarTemplateDecl::getSpecializations() const {
1271
  LoadLazySpecializations();
1272
  return getCommonPtr()->Specializations;
1273
}
1274

1275
llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
1276
VarTemplateDecl::getPartialSpecializations() const {
1277
  LoadLazySpecializations();
1278
  return getCommonPtr()->PartialSpecializations;
1279
}
1280

1281
RedeclarableTemplateDecl::CommonBase *
1282
VarTemplateDecl::newCommon(ASTContext &C) const {
1283
  auto *CommonPtr = new (C) Common;
1284
  C.addDestruction(CommonPtr);
1285
  return CommonPtr;
1286
}
1287

1288
VarTemplateSpecializationDecl *
1289
VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
1290
                                    void *&InsertPos) {
1291
  return findSpecializationImpl(getSpecializations(), InsertPos, Args);
1292
}
1293

1294
void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D,
1295
                                        void *InsertPos) {
1296
  addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
1297
}
1298

1299
VarTemplatePartialSpecializationDecl *
1300
VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
1301
     TemplateParameterList *TPL, void *&InsertPos) {
1302
  return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
1303
                                TPL);
1304
}
1305

1306
void VarTemplatePartialSpecializationDecl::Profile(
1307
    llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
1308
    TemplateParameterList *TPL, const ASTContext &Context) {
1309
  ID.AddInteger(TemplateArgs.size());
1310
  for (const TemplateArgument &TemplateArg : TemplateArgs)
1311
    TemplateArg.Profile(ID, Context);
1312
  TPL->Profile(ID, Context);
1313
}
1314

1315
void VarTemplateDecl::AddPartialSpecialization(
1316
    VarTemplatePartialSpecializationDecl *D, void *InsertPos) {
1317
  if (InsertPos)
1318
    getPartialSpecializations().InsertNode(D, InsertPos);
1319
  else {
1320
    VarTemplatePartialSpecializationDecl *Existing =
1321
        getPartialSpecializations().GetOrInsertNode(D);
1322
    (void)Existing;
1323
    assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
1324
  }
1325

1326
  if (ASTMutationListener *L = getASTMutationListener())
1327
    L->AddedCXXTemplateSpecialization(this, D);
1328
}
1329

1330
void VarTemplateDecl::getPartialSpecializations(
1331
    SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) const {
1332
  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
1333
      getPartialSpecializations();
1334
  PS.clear();
1335
  PS.reserve(PartialSpecs.size());
1336
  for (VarTemplatePartialSpecializationDecl &P : PartialSpecs)
1337
    PS.push_back(P.getMostRecentDecl());
1338
}
1339

1340
VarTemplatePartialSpecializationDecl *
1341
VarTemplateDecl::findPartialSpecInstantiatedFromMember(
1342
    VarTemplatePartialSpecializationDecl *D) {
1343
  Decl *DCanon = D->getCanonicalDecl();
1344
  for (VarTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
1345
    if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
1346
      return P.getMostRecentDecl();
1347
  }
1348

1349
  return nullptr;
1350
}
1351

1352
//===----------------------------------------------------------------------===//
1353
// VarTemplateSpecializationDecl Implementation
1354
//===----------------------------------------------------------------------===//
1355

1356
VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(
1357
    Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1358
    SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1359
    TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args)
1360
    : VarDecl(DK, Context, DC, StartLoc, IdLoc,
1361
              SpecializedTemplate->getIdentifier(), T, TInfo, S),
1362
      SpecializedTemplate(SpecializedTemplate),
1363
      TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
1364
      SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1365

1366
VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(Kind DK,
1367
                                                             ASTContext &C)
1368
    : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1369
              QualType(), nullptr, SC_None),
1370
      SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1371

1372
VarTemplateSpecializationDecl *VarTemplateSpecializationDecl::Create(
1373
    ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1374
    SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1375
    TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) {
1376
  return new (Context, DC) VarTemplateSpecializationDecl(
1377
      VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,
1378
      SpecializedTemplate, T, TInfo, S, Args);
1379
}
1380

1381
VarTemplateSpecializationDecl *
1382
VarTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
1383
                                                  GlobalDeclID ID) {
1384
  return new (C, ID)
1385
      VarTemplateSpecializationDecl(VarTemplateSpecialization, C);
1386
}
1387

1388
void VarTemplateSpecializationDecl::getNameForDiagnostic(
1389
    raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
1390
  NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
1391

1392
  const auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
1393
  if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
1394
          PS ? PS->getTemplateArgsAsWritten() : nullptr) {
1395
    printTemplateArgumentList(
1396
        OS, ArgsAsWritten->arguments(), Policy,
1397
        getSpecializedTemplate()->getTemplateParameters());
1398
  } else {
1399
    const TemplateArgumentList &TemplateArgs = getTemplateArgs();
1400
    printTemplateArgumentList(
1401
        OS, TemplateArgs.asArray(), Policy,
1402
        getSpecializedTemplate()->getTemplateParameters());
1403
  }
1404
}
1405

1406
VarTemplateDecl *VarTemplateSpecializationDecl::getSpecializedTemplate() const {
1407
  if (const auto *PartialSpec =
1408
          SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1409
    return PartialSpec->PartialSpecialization->getSpecializedTemplate();
1410
  return SpecializedTemplate.get<VarTemplateDecl *>();
1411
}
1412

1413
SourceRange VarTemplateSpecializationDecl::getSourceRange() const {
1414
  switch (getSpecializationKind()) {
1415
  case TSK_Undeclared:
1416
  case TSK_ImplicitInstantiation: {
1417
    llvm::PointerUnion<VarTemplateDecl *,
1418
                       VarTemplatePartialSpecializationDecl *>
1419
        Pattern = getSpecializedTemplateOrPartial();
1420
    assert(!Pattern.isNull() &&
1421
           "Variable template specialization without pattern?");
1422
    if (const auto *VTPSD =
1423
            Pattern.dyn_cast<VarTemplatePartialSpecializationDecl *>())
1424
      return VTPSD->getSourceRange();
1425
    VarTemplateDecl *VTD = Pattern.get<VarTemplateDecl *>();
1426
    if (hasInit()) {
1427
      if (VarTemplateDecl *Definition = VTD->getDefinition())
1428
        return Definition->getSourceRange();
1429
    }
1430
    return VTD->getCanonicalDecl()->getSourceRange();
1431
  }
1432
  case TSK_ExplicitSpecialization: {
1433
    SourceRange Range = VarDecl::getSourceRange();
1434
    if (const ASTTemplateArgumentListInfo *Args = getTemplateArgsAsWritten();
1435
        !hasInit() && Args)
1436
      Range.setEnd(Args->getRAngleLoc());
1437
    return Range;
1438
  }
1439
  case TSK_ExplicitInstantiationDeclaration:
1440
  case TSK_ExplicitInstantiationDefinition: {
1441
    SourceRange Range = VarDecl::getSourceRange();
1442
    if (SourceLocation ExternKW = getExternKeywordLoc(); ExternKW.isValid())
1443
      Range.setBegin(ExternKW);
1444
    else if (SourceLocation TemplateKW = getTemplateKeywordLoc();
1445
             TemplateKW.isValid())
1446
      Range.setBegin(TemplateKW);
1447
    if (const ASTTemplateArgumentListInfo *Args = getTemplateArgsAsWritten())
1448
      Range.setEnd(Args->getRAngleLoc());
1449
    return Range;
1450
  }
1451
  }
1452
  llvm_unreachable("unhandled template specialization kind");
1453
}
1454

1455
void VarTemplateSpecializationDecl::setExternKeywordLoc(SourceLocation Loc) {
1456
  auto *Info = ExplicitInfo.dyn_cast<ExplicitInstantiationInfo *>();
1457
  if (!Info) {
1458
    // Don't allocate if the location is invalid.
1459
    if (Loc.isInvalid())
1460
      return;
1461
    Info = new (getASTContext()) ExplicitInstantiationInfo;
1462
    Info->TemplateArgsAsWritten = getTemplateArgsAsWritten();
1463
    ExplicitInfo = Info;
1464
  }
1465
  Info->ExternKeywordLoc = Loc;
1466
}
1467

1468
void VarTemplateSpecializationDecl::setTemplateKeywordLoc(SourceLocation Loc) {
1469
  auto *Info = ExplicitInfo.dyn_cast<ExplicitInstantiationInfo *>();
1470
  if (!Info) {
1471
    // Don't allocate if the location is invalid.
1472
    if (Loc.isInvalid())
1473
      return;
1474
    Info = new (getASTContext()) ExplicitInstantiationInfo;
1475
    Info->TemplateArgsAsWritten = getTemplateArgsAsWritten();
1476
    ExplicitInfo = Info;
1477
  }
1478
  Info->TemplateKeywordLoc = Loc;
1479
}
1480

1481
//===----------------------------------------------------------------------===//
1482
// VarTemplatePartialSpecializationDecl Implementation
1483
//===----------------------------------------------------------------------===//
1484

1485
void VarTemplatePartialSpecializationDecl::anchor() {}
1486

1487
VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(
1488
    ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1489
    SourceLocation IdLoc, TemplateParameterList *Params,
1490
    VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1491
    StorageClass S, ArrayRef<TemplateArgument> Args)
1492
    : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context,
1493
                                    DC, StartLoc, IdLoc, SpecializedTemplate, T,
1494
                                    TInfo, S, Args),
1495
      TemplateParams(Params), InstantiatedFromMember(nullptr, false) {
1496
  if (AdoptTemplateParameterList(Params, DC))
1497
    setInvalidDecl();
1498
}
1499

1500
VarTemplatePartialSpecializationDecl *
1501
VarTemplatePartialSpecializationDecl::Create(
1502
    ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1503
    SourceLocation IdLoc, TemplateParameterList *Params,
1504
    VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1505
    StorageClass S, ArrayRef<TemplateArgument> Args) {
1506
  auto *Result = new (Context, DC) VarTemplatePartialSpecializationDecl(
1507
      Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo, S,
1508
      Args);
1509
  Result->setSpecializationKind(TSK_ExplicitSpecialization);
1510
  return Result;
1511
}
1512

1513
VarTemplatePartialSpecializationDecl *
1514
VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
1515
                                                         GlobalDeclID ID) {
1516
  return new (C, ID) VarTemplatePartialSpecializationDecl(C);
1517
}
1518

1519
SourceRange VarTemplatePartialSpecializationDecl::getSourceRange() const {
1520
  if (const VarTemplatePartialSpecializationDecl *MT =
1521
          getInstantiatedFromMember();
1522
      MT && !isMemberSpecialization())
1523
    return MT->getSourceRange();
1524
  SourceRange Range = VarTemplateSpecializationDecl::getSourceRange();
1525
  if (const TemplateParameterList *TPL = getTemplateParameters();
1526
      TPL && !getNumTemplateParameterLists())
1527
    Range.setBegin(TPL->getTemplateLoc());
1528
  return Range;
1529
}
1530

1531
static TemplateParameterList *
1532
createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
1533
  // typename T
1534
  auto *T = TemplateTypeParmDecl::Create(
1535
      C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
1536
      /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false,
1537
      /*HasTypeConstraint=*/false);
1538
  T->setImplicit(true);
1539

1540
  // T ...Ints
1541
  TypeSourceInfo *TI =
1542
      C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));
1543
  auto *N = NonTypeTemplateParmDecl::Create(
1544
      C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1545
      /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
1546
  N->setImplicit(true);
1547

1548
  // <typename T, T ...Ints>
1549
  NamedDecl *P[2] = {T, N};
1550
  auto *TPL = TemplateParameterList::Create(
1551
      C, SourceLocation(), SourceLocation(), P, SourceLocation(), nullptr);
1552

1553
  // template <typename T, ...Ints> class IntSeq
1554
  auto *TemplateTemplateParm = TemplateTemplateParmDecl::Create(
1555
      C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
1556
      /*ParameterPack=*/false, /*Id=*/nullptr, /*Typename=*/false, TPL);
1557
  TemplateTemplateParm->setImplicit(true);
1558

1559
  // typename T
1560
  auto *TemplateTypeParm = TemplateTypeParmDecl::Create(
1561
      C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1562
      /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false,
1563
      /*HasTypeConstraint=*/false);
1564
  TemplateTypeParm->setImplicit(true);
1565

1566
  // T N
1567
  TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(
1568
      QualType(TemplateTypeParm->getTypeForDecl(), 0));
1569
  auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
1570
      C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
1571
      /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1572
  NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,
1573
                         NonTypeTemplateParm};
1574

1575
  // template <template <typename T, T ...Ints> class IntSeq, typename T, T N>
1576
  return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1577
                                       Params, SourceLocation(), nullptr);
1578
}
1579

1580
static TemplateParameterList *
1581
createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
1582
  // std::size_t Index
1583
  TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
1584
  auto *Index = NonTypeTemplateParmDecl::Create(
1585
      C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
1586
      /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1587

1588
  // typename ...T
1589
  auto *Ts = TemplateTypeParmDecl::Create(
1590
      C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1591
      /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/true,
1592
      /*HasTypeConstraint=*/false);
1593
  Ts->setImplicit(true);
1594

1595
  // template <std::size_t Index, typename ...T>
1596
  NamedDecl *Params[] = {Index, Ts};
1597
  return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1598
                                       llvm::ArrayRef(Params), SourceLocation(),
1599
                                       nullptr);
1600
}
1601

1602
static TemplateParameterList *createBuiltinTemplateParameterList(
1603
    const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
1604
  switch (BTK) {
1605
  case BTK__make_integer_seq:
1606
    return createMakeIntegerSeqParameterList(C, DC);
1607
  case BTK__type_pack_element:
1608
    return createTypePackElementParameterList(C, DC);
1609
  }
1610

1611
  llvm_unreachable("unhandled BuiltinTemplateKind!");
1612
}
1613

1614
void BuiltinTemplateDecl::anchor() {}
1615

1616
BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
1617
                                         DeclarationName Name,
1618
                                         BuiltinTemplateKind BTK)
1619
    : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
1620
                   createBuiltinTemplateParameterList(C, DC, BTK)),
1621
      BTK(BTK) {}
1622

1623
TemplateParamObjectDecl *TemplateParamObjectDecl::Create(const ASTContext &C,
1624
                                                         QualType T,
1625
                                                         const APValue &V) {
1626
  DeclContext *DC = C.getTranslationUnitDecl();
1627
  auto *TPOD = new (C, DC) TemplateParamObjectDecl(DC, T, V);
1628
  C.addDestruction(&TPOD->Value);
1629
  return TPOD;
1630
}
1631

1632
TemplateParamObjectDecl *
1633
TemplateParamObjectDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) {
1634
  auto *TPOD = new (C, ID) TemplateParamObjectDecl(nullptr, QualType(), APValue());
1635
  C.addDestruction(&TPOD->Value);
1636
  return TPOD;
1637
}
1638

1639
void TemplateParamObjectDecl::printName(llvm::raw_ostream &OS,
1640
                                        const PrintingPolicy &Policy) const {
1641
  OS << "<template param ";
1642
  printAsExpr(OS, Policy);
1643
  OS << ">";
1644
}
1645

1646
void TemplateParamObjectDecl::printAsExpr(llvm::raw_ostream &OS) const {
1647
  printAsExpr(OS, getASTContext().getPrintingPolicy());
1648
}
1649

1650
void TemplateParamObjectDecl::printAsExpr(llvm::raw_ostream &OS,
1651
                                          const PrintingPolicy &Policy) const {
1652
  getType().getUnqualifiedType().print(OS, Policy);
1653
  printAsInit(OS, Policy);
1654
}
1655

1656
void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS) const {
1657
  printAsInit(OS, getASTContext().getPrintingPolicy());
1658
}
1659

1660
void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS,
1661
                                          const PrintingPolicy &Policy) const {
1662
  getValue().printPretty(OS, Policy, getType(), &getASTContext());
1663
}
1664

1665
TemplateParameterList *clang::getReplacedTemplateParameterList(Decl *D) {
1666
  switch (D->getKind()) {
1667
  case Decl::Kind::CXXRecord:
1668
    return cast<CXXRecordDecl>(D)
1669
        ->getDescribedTemplate()
1670
        ->getTemplateParameters();
1671
  case Decl::Kind::ClassTemplate:
1672
    return cast<ClassTemplateDecl>(D)->getTemplateParameters();
1673
  case Decl::Kind::ClassTemplateSpecialization: {
1674
    const auto *CTSD = cast<ClassTemplateSpecializationDecl>(D);
1675
    auto P = CTSD->getSpecializedTemplateOrPartial();
1676
    if (const auto *CTPSD =
1677
            P.dyn_cast<ClassTemplatePartialSpecializationDecl *>())
1678
      return CTPSD->getTemplateParameters();
1679
    return cast<ClassTemplateDecl *>(P)->getTemplateParameters();
1680
  }
1681
  case Decl::Kind::ClassTemplatePartialSpecialization:
1682
    return cast<ClassTemplatePartialSpecializationDecl>(D)
1683
        ->getTemplateParameters();
1684
  case Decl::Kind::TypeAliasTemplate:
1685
    return cast<TypeAliasTemplateDecl>(D)->getTemplateParameters();
1686
  case Decl::Kind::BuiltinTemplate:
1687
    return cast<BuiltinTemplateDecl>(D)->getTemplateParameters();
1688
  case Decl::Kind::CXXDeductionGuide:
1689
  case Decl::Kind::CXXConversion:
1690
  case Decl::Kind::CXXConstructor:
1691
  case Decl::Kind::CXXDestructor:
1692
  case Decl::Kind::CXXMethod:
1693
  case Decl::Kind::Function:
1694
    return cast<FunctionDecl>(D)
1695
        ->getTemplateSpecializationInfo()
1696
        ->getTemplate()
1697
        ->getTemplateParameters();
1698
  case Decl::Kind::FunctionTemplate:
1699
    return cast<FunctionTemplateDecl>(D)->getTemplateParameters();
1700
  case Decl::Kind::VarTemplate:
1701
    return cast<VarTemplateDecl>(D)->getTemplateParameters();
1702
  case Decl::Kind::VarTemplateSpecialization: {
1703
    const auto *VTSD = cast<VarTemplateSpecializationDecl>(D);
1704
    auto P = VTSD->getSpecializedTemplateOrPartial();
1705
    if (const auto *VTPSD =
1706
            P.dyn_cast<VarTemplatePartialSpecializationDecl *>())
1707
      return VTPSD->getTemplateParameters();
1708
    return cast<VarTemplateDecl *>(P)->getTemplateParameters();
1709
  }
1710
  case Decl::Kind::VarTemplatePartialSpecialization:
1711
    return cast<VarTemplatePartialSpecializationDecl>(D)
1712
        ->getTemplateParameters();
1713
  case Decl::Kind::TemplateTemplateParm:
1714
    return cast<TemplateTemplateParmDecl>(D)->getTemplateParameters();
1715
  case Decl::Kind::Concept:
1716
    return cast<ConceptDecl>(D)->getTemplateParameters();
1717
  default:
1718
    llvm_unreachable("Unhandled templated declaration kind");
1719
  }
1720
}
1721