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/None.h"
30 #include "llvm/ADT/PointerUnion.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 <utility>
39 
40 using namespace clang;
41 
42 //===----------------------------------------------------------------------===//
43 // TemplateParameterList Implementation
44 //===----------------------------------------------------------------------===//
45 
46 TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
47                                              SourceLocation LAngleLoc,
48                                              ArrayRef<NamedDecl *> Params,
49                                              SourceLocation RAngleLoc,
50                                              Expr *RequiresClause)
51     : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
52       NumParams(Params.size()), ContainsUnexpandedParameterPack(false),
53       HasRequiresClause(static_cast<bool>(RequiresClause)) {
54   for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
55     NamedDecl *P = Params[Idx];
56     begin()[Idx] = P;
57 
58     if (!P->isTemplateParameterPack()) {
59       if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
60         if (NTTP->getType()->containsUnexpandedParameterPack())
61           ContainsUnexpandedParameterPack = true;
62 
63       if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
64         if (TTP->getTemplateParameters()->containsUnexpandedParameterPack())
65           ContainsUnexpandedParameterPack = true;
66 
67       // FIXME: If a default argument contains an unexpanded parameter pack, the
68       // template parameter list does too.
69     }
70   }
71   if (RequiresClause) {
72     *getTrailingObjects<Expr *>() = RequiresClause;
73   }
74 }
75 
76 TemplateParameterList *
77 TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc,
78                               SourceLocation LAngleLoc,
79                               ArrayRef<NamedDecl *> Params,
80                               SourceLocation RAngleLoc, Expr *RequiresClause) {
81   void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
82                              Params.size(), RequiresClause ? 1u : 0u),
83                          alignof(TemplateParameterList));
84   return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params,
85                                          RAngleLoc, RequiresClause);
86 }
87 
88 unsigned TemplateParameterList::getMinRequiredArguments() const {
89   unsigned NumRequiredArgs = 0;
90   for (const NamedDecl *P : asArray()) {
91     if (P->isTemplateParameterPack()) {
92       if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
93         if (NTTP->isExpandedParameterPack()) {
94           NumRequiredArgs += NTTP->getNumExpansionTypes();
95           continue;
96         }
97 
98       break;
99     }
100 
101     if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
102       if (TTP->hasDefaultArgument())
103         break;
104     } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
105       if (NTTP->hasDefaultArgument())
106         break;
107     } else if (cast<TemplateTemplateParmDecl>(P)->hasDefaultArgument())
108       break;
109 
110     ++NumRequiredArgs;
111   }
112 
113   return NumRequiredArgs;
114 }
115 
116 unsigned TemplateParameterList::getDepth() const {
117   if (size() == 0)
118     return 0;
119 
120   const NamedDecl *FirstParm = getParam(0);
121   if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(FirstParm))
122     return TTP->getDepth();
123   else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
124     return NTTP->getDepth();
125   else
126     return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
127 }
128 
129 static void AdoptTemplateParameterList(TemplateParameterList *Params,
130                                        DeclContext *Owner) {
131   for (NamedDecl *P : *Params) {
132     P->setDeclContext(Owner);
133 
134     if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
135       AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner);
136   }
137 }
138 
139 namespace clang {
140 
141 void *allocateDefaultArgStorageChain(const ASTContext &C) {
142   return new (C) char[sizeof(void*) * 2];
143 }
144 
145 } // namespace clang
146 
147 //===----------------------------------------------------------------------===//
148 // RedeclarableTemplateDecl Implementation
149 //===----------------------------------------------------------------------===//
150 
151 void RedeclarableTemplateDecl::anchor() {}
152 
153 RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const {
154   if (Common)
155     return Common;
156 
157   // Walk the previous-declaration chain until we either find a declaration
158   // with a common pointer or we run out of previous declarations.
159   SmallVector<const RedeclarableTemplateDecl *, 2> PrevDecls;
160   for (const RedeclarableTemplateDecl *Prev = getPreviousDecl(); Prev;
161        Prev = Prev->getPreviousDecl()) {
162     if (Prev->Common) {
163       Common = Prev->Common;
164       break;
165     }
166 
167     PrevDecls.push_back(Prev);
168   }
169 
170   // If we never found a common pointer, allocate one now.
171   if (!Common) {
172     // FIXME: If any of the declarations is from an AST file, we probably
173     // need an update record to add the common data.
174 
175     Common = newCommon(getASTContext());
176   }
177 
178   // Update any previous declarations we saw with the common pointer.
179   for (const RedeclarableTemplateDecl *Prev : PrevDecls)
180     Prev->Common = Common;
181 
182   return Common;
183 }
184 
185 void RedeclarableTemplateDecl::loadLazySpecializationsImpl() const {
186   // Grab the most recent declaration to ensure we've loaded any lazy
187   // redeclarations of this template.
188   CommonBase *CommonBasePtr = getMostRecentDecl()->getCommonPtr();
189   if (CommonBasePtr->LazySpecializations) {
190     ASTContext &Context = getASTContext();
191     uint32_t *Specs = CommonBasePtr->LazySpecializations;
192     CommonBasePtr->LazySpecializations = nullptr;
193     for (uint32_t I = 0, N = *Specs++; I != N; ++I)
194       (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
195   }
196 }
197 
198 template<class EntryType>
199 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
200 RedeclarableTemplateDecl::findSpecializationImpl(
201     llvm::FoldingSetVector<EntryType> &Specs, ArrayRef<TemplateArgument> Args,
202     void *&InsertPos) {
203   using SETraits = SpecEntryTraits<EntryType>;
204 
205   llvm::FoldingSetNodeID ID;
206   EntryType::Profile(ID, Args, getASTContext());
207   EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);
208   return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr;
209 }
210 
211 template<class Derived, class EntryType>
212 void RedeclarableTemplateDecl::addSpecializationImpl(
213     llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
214     void *InsertPos) {
215   using SETraits = SpecEntryTraits<EntryType>;
216 
217   if (InsertPos) {
218 #ifndef NDEBUG
219     void *CorrectInsertPos;
220     assert(!findSpecializationImpl(Specializations,
221                                    SETraits::getTemplateArgs(Entry),
222                                    CorrectInsertPos) &&
223            InsertPos == CorrectInsertPos &&
224            "given incorrect InsertPos for specialization");
225 #endif
226     Specializations.InsertNode(Entry, InsertPos);
227   } else {
228     EntryType *Existing = Specializations.GetOrInsertNode(Entry);
229     (void)Existing;
230     assert(SETraits::getDecl(Existing)->isCanonicalDecl() &&
231            "non-canonical specialization?");
232   }
233 
234   if (ASTMutationListener *L = getASTMutationListener())
235     L->AddedCXXTemplateSpecialization(cast<Derived>(this),
236                                       SETraits::getDecl(Entry));
237 }
238 
239 //===----------------------------------------------------------------------===//
240 // FunctionTemplateDecl Implementation
241 //===----------------------------------------------------------------------===//
242 
243 FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
244                                                    DeclContext *DC,
245                                                    SourceLocation L,
246                                                    DeclarationName Name,
247                                                TemplateParameterList *Params,
248                                                    NamedDecl *Decl) {
249   AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
250   return new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl);
251 }
252 
253 FunctionTemplateDecl *FunctionTemplateDecl::CreateDeserialized(ASTContext &C,
254                                                                unsigned ID) {
255   return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(),
256                                           DeclarationName(), nullptr, nullptr);
257 }
258 
259 RedeclarableTemplateDecl::CommonBase *
260 FunctionTemplateDecl::newCommon(ASTContext &C) const {
261   auto *CommonPtr = new (C) Common;
262   C.addDestruction(CommonPtr);
263   return CommonPtr;
264 }
265 
266 void FunctionTemplateDecl::LoadLazySpecializations() const {
267   loadLazySpecializationsImpl();
268 }
269 
270 llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
271 FunctionTemplateDecl::getSpecializations() const {
272   LoadLazySpecializations();
273   return getCommonPtr()->Specializations;
274 }
275 
276 FunctionDecl *
277 FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
278                                          void *&InsertPos) {
279   return findSpecializationImpl(getSpecializations(), Args, InsertPos);
280 }
281 
282 void FunctionTemplateDecl::addSpecialization(
283       FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
284   addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
285                                               InsertPos);
286 }
287 
288 ArrayRef<TemplateArgument> FunctionTemplateDecl::getInjectedTemplateArgs() {
289   TemplateParameterList *Params = getTemplateParameters();
290   Common *CommonPtr = getCommonPtr();
291   if (!CommonPtr->InjectedArgs) {
292     auto &Context = getASTContext();
293     SmallVector<TemplateArgument, 16> TemplateArgs;
294     Context.getInjectedTemplateArgs(Params, TemplateArgs);
295     CommonPtr->InjectedArgs =
296         new (Context) TemplateArgument[TemplateArgs.size()];
297     std::copy(TemplateArgs.begin(), TemplateArgs.end(),
298               CommonPtr->InjectedArgs);
299   }
300 
301   return llvm::makeArrayRef(CommonPtr->InjectedArgs, Params->size());
302 }
303 
304 void FunctionTemplateDecl::mergePrevDecl(FunctionTemplateDecl *Prev) {
305   using Base = RedeclarableTemplateDecl;
306 
307   // If we haven't created a common pointer yet, then it can just be created
308   // with the usual method.
309   if (!Base::Common)
310     return;
311 
312   Common *ThisCommon = static_cast<Common *>(Base::Common);
313   Common *PrevCommon = nullptr;
314   SmallVector<FunctionTemplateDecl *, 8> PreviousDecls;
315   for (; Prev; Prev = Prev->getPreviousDecl()) {
316     if (Prev->Base::Common) {
317       PrevCommon = static_cast<Common *>(Prev->Base::Common);
318       break;
319     }
320     PreviousDecls.push_back(Prev);
321   }
322 
323   // If the previous redecl chain hasn't created a common pointer yet, then just
324   // use this common pointer.
325   if (!PrevCommon) {
326     for (auto *D : PreviousDecls)
327       D->Base::Common = ThisCommon;
328     return;
329   }
330 
331   // Ensure we don't leak any important state.
332   assert(ThisCommon->Specializations.size() == 0 &&
333          "Can't merge incompatible declarations!");
334 
335   Base::Common = PrevCommon;
336 }
337 
338 //===----------------------------------------------------------------------===//
339 // ClassTemplateDecl Implementation
340 //===----------------------------------------------------------------------===//
341 
342 ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
343                                              DeclContext *DC,
344                                              SourceLocation L,
345                                              DeclarationName Name,
346                                              TemplateParameterList *Params,
347                                              NamedDecl *Decl,
348                                              Expr *AssociatedConstraints) {
349   AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
350 
351   if (!AssociatedConstraints) {
352     return new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl);
353   }
354 
355   auto *const CTDI = new (C) ConstrainedTemplateDeclInfo;
356   auto *const New =
357       new (C, DC) ClassTemplateDecl(CTDI, C, DC, L, Name, Params, Decl);
358   New->setAssociatedConstraints(AssociatedConstraints);
359   return New;
360 }
361 
362 ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
363                                                          unsigned ID) {
364   return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
365                                        DeclarationName(), nullptr, nullptr);
366 }
367 
368 void ClassTemplateDecl::LoadLazySpecializations() const {
369   loadLazySpecializationsImpl();
370 }
371 
372 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
373 ClassTemplateDecl::getSpecializations() const {
374   LoadLazySpecializations();
375   return getCommonPtr()->Specializations;
376 }
377 
378 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
379 ClassTemplateDecl::getPartialSpecializations() {
380   LoadLazySpecializations();
381   return getCommonPtr()->PartialSpecializations;
382 }
383 
384 RedeclarableTemplateDecl::CommonBase *
385 ClassTemplateDecl::newCommon(ASTContext &C) const {
386   auto *CommonPtr = new (C) Common;
387   C.addDestruction(CommonPtr);
388   return CommonPtr;
389 }
390 
391 ClassTemplateSpecializationDecl *
392 ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
393                                       void *&InsertPos) {
394   return findSpecializationImpl(getSpecializations(), Args, InsertPos);
395 }
396 
397 void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
398                                           void *InsertPos) {
399   addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
400 }
401 
402 ClassTemplatePartialSpecializationDecl *
403 ClassTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
404                                              void *&InsertPos) {
405   return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
406 }
407 
408 void ClassTemplateDecl::AddPartialSpecialization(
409                                       ClassTemplatePartialSpecializationDecl *D,
410                                       void *InsertPos) {
411   if (InsertPos)
412     getPartialSpecializations().InsertNode(D, InsertPos);
413   else {
414     ClassTemplatePartialSpecializationDecl *Existing
415       = getPartialSpecializations().GetOrInsertNode(D);
416     (void)Existing;
417     assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
418   }
419 
420   if (ASTMutationListener *L = getASTMutationListener())
421     L->AddedCXXTemplateSpecialization(this, D);
422 }
423 
424 void ClassTemplateDecl::getPartialSpecializations(
425           SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) {
426   llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
427     = getPartialSpecializations();
428   PS.clear();
429   PS.reserve(PartialSpecs.size());
430   for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs)
431     PS.push_back(P.getMostRecentDecl());
432 }
433 
434 ClassTemplatePartialSpecializationDecl *
435 ClassTemplateDecl::findPartialSpecialization(QualType T) {
436   ASTContext &Context = getASTContext();
437   for (ClassTemplatePartialSpecializationDecl &P :
438        getPartialSpecializations()) {
439     if (Context.hasSameType(P.getInjectedSpecializationType(), T))
440       return P.getMostRecentDecl();
441   }
442 
443   return nullptr;
444 }
445 
446 ClassTemplatePartialSpecializationDecl *
447 ClassTemplateDecl::findPartialSpecInstantiatedFromMember(
448                                     ClassTemplatePartialSpecializationDecl *D) {
449   Decl *DCanon = D->getCanonicalDecl();
450   for (ClassTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
451     if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
452       return P.getMostRecentDecl();
453   }
454 
455   return nullptr;
456 }
457 
458 QualType
459 ClassTemplateDecl::getInjectedClassNameSpecialization() {
460   Common *CommonPtr = getCommonPtr();
461   if (!CommonPtr->InjectedClassNameType.isNull())
462     return CommonPtr->InjectedClassNameType;
463 
464   // C++0x [temp.dep.type]p2:
465   //  The template argument list of a primary template is a template argument
466   //  list in which the nth template argument has the value of the nth template
467   //  parameter of the class template. If the nth template parameter is a
468   //  template parameter pack (14.5.3), the nth template argument is a pack
469   //  expansion (14.5.3) whose pattern is the name of the template parameter
470   //  pack.
471   ASTContext &Context = getASTContext();
472   TemplateParameterList *Params = getTemplateParameters();
473   SmallVector<TemplateArgument, 16> TemplateArgs;
474   Context.getInjectedTemplateArgs(Params, TemplateArgs);
475   CommonPtr->InjectedClassNameType
476     = Context.getTemplateSpecializationType(TemplateName(this),
477                                             TemplateArgs);
478   return CommonPtr->InjectedClassNameType;
479 }
480 
481 //===----------------------------------------------------------------------===//
482 // TemplateTypeParm Allocation/Deallocation Method Implementations
483 //===----------------------------------------------------------------------===//
484 
485 TemplateTypeParmDecl *
486 TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC,
487                              SourceLocation KeyLoc, SourceLocation NameLoc,
488                              unsigned D, unsigned P, IdentifierInfo *Id,
489                              bool Typename, bool ParameterPack) {
490   auto *TTPDecl =
491       new (C, DC) TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename);
492   QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
493   TTPDecl->setTypeForDecl(TTPType.getTypePtr());
494   return TTPDecl;
495 }
496 
497 TemplateTypeParmDecl *
498 TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
499   return new (C, ID) TemplateTypeParmDecl(nullptr, SourceLocation(),
500                                           SourceLocation(), nullptr, false);
501 }
502 
503 SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
504   return hasDefaultArgument()
505              ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc()
506              : SourceLocation();
507 }
508 
509 SourceRange TemplateTypeParmDecl::getSourceRange() const {
510   if (hasDefaultArgument() && !defaultArgumentWasInherited())
511     return SourceRange(getBeginLoc(),
512                        getDefaultArgumentInfo()->getTypeLoc().getEndLoc());
513   else
514     return TypeDecl::getSourceRange();
515 }
516 
517 unsigned TemplateTypeParmDecl::getDepth() const {
518   return getTypeForDecl()->getAs<TemplateTypeParmType>()->getDepth();
519 }
520 
521 unsigned TemplateTypeParmDecl::getIndex() const {
522   return getTypeForDecl()->getAs<TemplateTypeParmType>()->getIndex();
523 }
524 
525 bool TemplateTypeParmDecl::isParameterPack() const {
526   return getTypeForDecl()->getAs<TemplateTypeParmType>()->isParameterPack();
527 }
528 
529 //===----------------------------------------------------------------------===//
530 // NonTypeTemplateParmDecl Method Implementations
531 //===----------------------------------------------------------------------===//
532 
533 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
534     DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D,
535     unsigned P, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
536     ArrayRef<QualType> ExpandedTypes, ArrayRef<TypeSourceInfo *> ExpandedTInfos)
537     : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
538       TemplateParmPosition(D, P), ParameterPack(true),
539       ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {
540   if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {
541     auto TypesAndInfos =
542         getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
543     for (unsigned I = 0; I != NumExpandedTypes; ++I) {
544       new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]);
545       TypesAndInfos[I].second = ExpandedTInfos[I];
546     }
547   }
548 }
549 
550 NonTypeTemplateParmDecl *
551 NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
552                                 SourceLocation StartLoc, SourceLocation IdLoc,
553                                 unsigned D, unsigned P, IdentifierInfo *Id,
554                                 QualType T, bool ParameterPack,
555                                 TypeSourceInfo *TInfo) {
556   return new (C, DC) NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id,
557                                              T, ParameterPack, TInfo);
558 }
559 
560 NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
561     const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
562     SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
563     QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
564     ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
565   return new (C, DC,
566               additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
567                   ExpandedTypes.size()))
568       NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
569                               ExpandedTypes, ExpandedTInfos);
570 }
571 
572 NonTypeTemplateParmDecl *
573 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
574   return new (C, ID) NonTypeTemplateParmDecl(nullptr, SourceLocation(),
575                                              SourceLocation(), 0, 0, nullptr,
576                                              QualType(), false, nullptr);
577 }
578 
579 NonTypeTemplateParmDecl *
580 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
581                                             unsigned NumExpandedTypes) {
582   auto *NTTP =
583       new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
584                       NumExpandedTypes))
585           NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
586                                   0, 0, nullptr, QualType(), nullptr, None,
587                                   None);
588   NTTP->NumExpandedTypes = NumExpandedTypes;
589   return NTTP;
590 }
591 
592 SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
593   if (hasDefaultArgument() && !defaultArgumentWasInherited())
594     return SourceRange(getOuterLocStart(),
595                        getDefaultArgument()->getSourceRange().getEnd());
596   return DeclaratorDecl::getSourceRange();
597 }
598 
599 SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
600   return hasDefaultArgument()
601     ? getDefaultArgument()->getSourceRange().getBegin()
602     : SourceLocation();
603 }
604 
605 //===----------------------------------------------------------------------===//
606 // TemplateTemplateParmDecl Method Implementations
607 //===----------------------------------------------------------------------===//
608 
609 void TemplateTemplateParmDecl::anchor() {}
610 
611 TemplateTemplateParmDecl::TemplateTemplateParmDecl(
612     DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
613     IdentifierInfo *Id, TemplateParameterList *Params,
614     ArrayRef<TemplateParameterList *> Expansions)
615     : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
616       TemplateParmPosition(D, P), ParameterPack(true),
617       ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {
618   if (!Expansions.empty())
619     std::uninitialized_copy(Expansions.begin(), Expansions.end(),
620                             getTrailingObjects<TemplateParameterList *>());
621 }
622 
623 TemplateTemplateParmDecl *
624 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
625                                  SourceLocation L, unsigned D, unsigned P,
626                                  bool ParameterPack, IdentifierInfo *Id,
627                                  TemplateParameterList *Params) {
628   return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
629                                               Params);
630 }
631 
632 TemplateTemplateParmDecl *
633 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
634                                  SourceLocation L, unsigned D, unsigned P,
635                                  IdentifierInfo *Id,
636                                  TemplateParameterList *Params,
637                                  ArrayRef<TemplateParameterList *> Expansions) {
638   return new (C, DC,
639               additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
640       TemplateTemplateParmDecl(DC, L, D, P, Id, Params, Expansions);
641 }
642 
643 TemplateTemplateParmDecl *
644 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
645   return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
646                                               false, nullptr, nullptr);
647 }
648 
649 TemplateTemplateParmDecl *
650 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
651                                              unsigned NumExpansions) {
652   auto *TTP =
653       new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
654           TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
655                                    nullptr, None);
656   TTP->NumExpandedParams = NumExpansions;
657   return TTP;
658 }
659 
660 SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
661   return hasDefaultArgument() ? getDefaultArgument().getLocation()
662                               : SourceLocation();
663 }
664 
665 void TemplateTemplateParmDecl::setDefaultArgument(
666     const ASTContext &C, const TemplateArgumentLoc &DefArg) {
667   if (DefArg.getArgument().isNull())
668     DefaultArgument.set(nullptr);
669   else
670     DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg));
671 }
672 
673 //===----------------------------------------------------------------------===//
674 // TemplateArgumentList Implementation
675 //===----------------------------------------------------------------------===//
676 TemplateArgumentList::TemplateArgumentList(ArrayRef<TemplateArgument> Args)
677     : Arguments(getTrailingObjects<TemplateArgument>()),
678       NumArguments(Args.size()) {
679   std::uninitialized_copy(Args.begin(), Args.end(),
680                           getTrailingObjects<TemplateArgument>());
681 }
682 
683 TemplateArgumentList *
684 TemplateArgumentList::CreateCopy(ASTContext &Context,
685                                  ArrayRef<TemplateArgument> Args) {
686   void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
687   return new (Mem) TemplateArgumentList(Args);
688 }
689 
690 FunctionTemplateSpecializationInfo *FunctionTemplateSpecializationInfo::Create(
691     ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template,
692     TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs,
693     const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI,
694     MemberSpecializationInfo *MSInfo) {
695   const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
696   if (TemplateArgsAsWritten)
697     ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C,
698                                                         *TemplateArgsAsWritten);
699 
700   void *Mem =
701       C.Allocate(totalSizeToAlloc<MemberSpecializationInfo *>(MSInfo ? 1 : 0));
702   return new (Mem) FunctionTemplateSpecializationInfo(
703       FD, Template, TSK, TemplateArgs, ArgsAsWritten, POI, MSInfo);
704 }
705 
706 //===----------------------------------------------------------------------===//
707 // TemplateDecl Implementation
708 //===----------------------------------------------------------------------===//
709 
710 void TemplateDecl::anchor() {}
711 
712 //===----------------------------------------------------------------------===//
713 // ClassTemplateSpecializationDecl Implementation
714 //===----------------------------------------------------------------------===//
715 
716 ClassTemplateSpecializationDecl::
717 ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
718                                 DeclContext *DC, SourceLocation StartLoc,
719                                 SourceLocation IdLoc,
720                                 ClassTemplateDecl *SpecializedTemplate,
721                                 ArrayRef<TemplateArgument> Args,
722                                 ClassTemplateSpecializationDecl *PrevDecl)
723     : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,
724                     SpecializedTemplate->getIdentifier(), PrevDecl),
725     SpecializedTemplate(SpecializedTemplate),
726     TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
727     SpecializationKind(TSK_Undeclared) {
728 }
729 
730 ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
731                                                                  Kind DK)
732     : CXXRecordDecl(DK, TTK_Struct, C, nullptr, SourceLocation(),
733                     SourceLocation(), nullptr, nullptr),
734       SpecializationKind(TSK_Undeclared) {}
735 
736 ClassTemplateSpecializationDecl *
737 ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
738                                         DeclContext *DC,
739                                         SourceLocation StartLoc,
740                                         SourceLocation IdLoc,
741                                         ClassTemplateDecl *SpecializedTemplate,
742                                         ArrayRef<TemplateArgument> Args,
743                                    ClassTemplateSpecializationDecl *PrevDecl) {
744   auto *Result =
745       new (Context, DC) ClassTemplateSpecializationDecl(
746           Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
747           SpecializedTemplate, Args, PrevDecl);
748   Result->setMayHaveOutOfDateDef(false);
749 
750   Context.getTypeDeclType(Result, PrevDecl);
751   return Result;
752 }
753 
754 ClassTemplateSpecializationDecl *
755 ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
756                                                     unsigned ID) {
757   auto *Result =
758     new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
759   Result->setMayHaveOutOfDateDef(false);
760   return Result;
761 }
762 
763 void ClassTemplateSpecializationDecl::getNameForDiagnostic(
764     raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
765   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
766 
767   const auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
768   if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
769           PS ? PS->getTemplateArgsAsWritten() : nullptr) {
770     printTemplateArgumentList(OS, ArgsAsWritten->arguments(), Policy);
771   } else {
772     const TemplateArgumentList &TemplateArgs = getTemplateArgs();
773     printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
774   }
775 }
776 
777 ClassTemplateDecl *
778 ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
779   if (const auto *PartialSpec =
780           SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
781     return PartialSpec->PartialSpecialization->getSpecializedTemplate();
782   return SpecializedTemplate.get<ClassTemplateDecl*>();
783 }
784 
785 SourceRange
786 ClassTemplateSpecializationDecl::getSourceRange() const {
787   if (ExplicitInfo) {
788     SourceLocation Begin = getTemplateKeywordLoc();
789     if (Begin.isValid()) {
790       // Here we have an explicit (partial) specialization or instantiation.
791       assert(getSpecializationKind() == TSK_ExplicitSpecialization ||
792              getSpecializationKind() == TSK_ExplicitInstantiationDeclaration ||
793              getSpecializationKind() == TSK_ExplicitInstantiationDefinition);
794       if (getExternLoc().isValid())
795         Begin = getExternLoc();
796       SourceLocation End = getBraceRange().getEnd();
797       if (End.isInvalid())
798         End = getTypeAsWritten()->getTypeLoc().getEndLoc();
799       return SourceRange(Begin, End);
800     }
801     // An implicit instantiation of a class template partial specialization
802     // uses ExplicitInfo to record the TypeAsWritten, but the source
803     // locations should be retrieved from the instantiation pattern.
804     using CTPSDecl = ClassTemplatePartialSpecializationDecl;
805     auto *ctpsd = const_cast<CTPSDecl *>(cast<CTPSDecl>(this));
806     CTPSDecl *inst_from = ctpsd->getInstantiatedFromMember();
807     assert(inst_from != nullptr);
808     return inst_from->getSourceRange();
809   }
810   else {
811     // No explicit info available.
812     llvm::PointerUnion<ClassTemplateDecl *,
813                        ClassTemplatePartialSpecializationDecl *>
814       inst_from = getInstantiatedFrom();
815     if (inst_from.isNull())
816       return getSpecializedTemplate()->getSourceRange();
817     if (const auto *ctd = inst_from.dyn_cast<ClassTemplateDecl *>())
818       return ctd->getSourceRange();
819     return inst_from.get<ClassTemplatePartialSpecializationDecl *>()
820       ->getSourceRange();
821   }
822 }
823 
824 //===----------------------------------------------------------------------===//
825 // ClassTemplatePartialSpecializationDecl Implementation
826 //===----------------------------------------------------------------------===//
827 void ClassTemplatePartialSpecializationDecl::anchor() {}
828 
829 ClassTemplatePartialSpecializationDecl::
830 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
831                                        DeclContext *DC,
832                                        SourceLocation StartLoc,
833                                        SourceLocation IdLoc,
834                                        TemplateParameterList *Params,
835                                        ClassTemplateDecl *SpecializedTemplate,
836                                        ArrayRef<TemplateArgument> Args,
837                                const ASTTemplateArgumentListInfo *ArgInfos,
838                                ClassTemplatePartialSpecializationDecl *PrevDecl)
839     : ClassTemplateSpecializationDecl(Context,
840                                       ClassTemplatePartialSpecialization,
841                                       TK, DC, StartLoc, IdLoc,
842                                       SpecializedTemplate, Args, PrevDecl),
843       TemplateParams(Params), ArgsAsWritten(ArgInfos),
844       InstantiatedFromMember(nullptr, false) {
845   AdoptTemplateParameterList(Params, this);
846 }
847 
848 ClassTemplatePartialSpecializationDecl *
849 ClassTemplatePartialSpecializationDecl::
850 Create(ASTContext &Context, TagKind TK,DeclContext *DC,
851        SourceLocation StartLoc, SourceLocation IdLoc,
852        TemplateParameterList *Params,
853        ClassTemplateDecl *SpecializedTemplate,
854        ArrayRef<TemplateArgument> Args,
855        const TemplateArgumentListInfo &ArgInfos,
856        QualType CanonInjectedType,
857        ClassTemplatePartialSpecializationDecl *PrevDecl) {
858   const ASTTemplateArgumentListInfo *ASTArgInfos =
859     ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
860 
861   auto *Result = new (Context, DC)
862       ClassTemplatePartialSpecializationDecl(Context, TK, DC, StartLoc, IdLoc,
863                                              Params, SpecializedTemplate, Args,
864                                              ASTArgInfos, PrevDecl);
865   Result->setSpecializationKind(TSK_ExplicitSpecialization);
866   Result->setMayHaveOutOfDateDef(false);
867 
868   Context.getInjectedClassNameType(Result, CanonInjectedType);
869   return Result;
870 }
871 
872 ClassTemplatePartialSpecializationDecl *
873 ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
874                                                            unsigned ID) {
875   auto *Result = new (C, ID) ClassTemplatePartialSpecializationDecl(C);
876   Result->setMayHaveOutOfDateDef(false);
877   return Result;
878 }
879 
880 //===----------------------------------------------------------------------===//
881 // FriendTemplateDecl Implementation
882 //===----------------------------------------------------------------------===//
883 
884 void FriendTemplateDecl::anchor() {}
885 
886 FriendTemplateDecl *
887 FriendTemplateDecl::Create(ASTContext &Context, DeclContext *DC,
888                            SourceLocation L,
889                            MutableArrayRef<TemplateParameterList *> Params,
890                            FriendUnion Friend, SourceLocation FLoc) {
891   return new (Context, DC) FriendTemplateDecl(DC, L, Params, Friend, FLoc);
892 }
893 
894 FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
895                                                            unsigned ID) {
896   return new (C, ID) FriendTemplateDecl(EmptyShell());
897 }
898 
899 //===----------------------------------------------------------------------===//
900 // TypeAliasTemplateDecl Implementation
901 //===----------------------------------------------------------------------===//
902 
903 TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C,
904                                                      DeclContext *DC,
905                                                      SourceLocation L,
906                                                      DeclarationName Name,
907                                                   TemplateParameterList *Params,
908                                                      NamedDecl *Decl) {
909   AdoptTemplateParameterList(Params, DC);
910   return new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl);
911 }
912 
913 TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C,
914                                                                  unsigned ID) {
915   return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
916                                            DeclarationName(), nullptr, nullptr);
917 }
918 
919 RedeclarableTemplateDecl::CommonBase *
920 TypeAliasTemplateDecl::newCommon(ASTContext &C) const {
921   auto *CommonPtr = new (C) Common;
922   C.addDestruction(CommonPtr);
923   return CommonPtr;
924 }
925 
926 //===----------------------------------------------------------------------===//
927 // ClassScopeFunctionSpecializationDecl Implementation
928 //===----------------------------------------------------------------------===//
929 
930 void ClassScopeFunctionSpecializationDecl::anchor() {}
931 
932 ClassScopeFunctionSpecializationDecl *
933 ClassScopeFunctionSpecializationDecl::CreateDeserialized(ASTContext &C,
934                                                          unsigned ID) {
935   return new (C, ID) ClassScopeFunctionSpecializationDecl(
936       nullptr, SourceLocation(), nullptr, nullptr);
937 }
938 
939 //===----------------------------------------------------------------------===//
940 // VarTemplateDecl Implementation
941 //===----------------------------------------------------------------------===//
942 
943 VarTemplateDecl *VarTemplateDecl::getDefinition() {
944   VarTemplateDecl *CurD = this;
945   while (CurD) {
946     if (CurD->isThisDeclarationADefinition())
947       return CurD;
948     CurD = CurD->getPreviousDecl();
949   }
950   return nullptr;
951 }
952 
953 VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC,
954                                          SourceLocation L, DeclarationName Name,
955                                          TemplateParameterList *Params,
956                                          VarDecl *Decl) {
957   AdoptTemplateParameterList(Params, DC);
958   return new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl);
959 }
960 
961 VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C,
962                                                      unsigned ID) {
963   return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
964                                      DeclarationName(), nullptr, nullptr);
965 }
966 
967 void VarTemplateDecl::LoadLazySpecializations() const {
968   loadLazySpecializationsImpl();
969 }
970 
971 llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
972 VarTemplateDecl::getSpecializations() const {
973   LoadLazySpecializations();
974   return getCommonPtr()->Specializations;
975 }
976 
977 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
978 VarTemplateDecl::getPartialSpecializations() {
979   LoadLazySpecializations();
980   return getCommonPtr()->PartialSpecializations;
981 }
982 
983 RedeclarableTemplateDecl::CommonBase *
984 VarTemplateDecl::newCommon(ASTContext &C) const {
985   auto *CommonPtr = new (C) Common;
986   C.addDestruction(CommonPtr);
987   return CommonPtr;
988 }
989 
990 VarTemplateSpecializationDecl *
991 VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
992                                     void *&InsertPos) {
993   return findSpecializationImpl(getSpecializations(), Args, InsertPos);
994 }
995 
996 void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D,
997                                         void *InsertPos) {
998   addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
999 }
1000 
1001 VarTemplatePartialSpecializationDecl *
1002 VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
1003                                            void *&InsertPos) {
1004   return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
1005 }
1006 
1007 void VarTemplateDecl::AddPartialSpecialization(
1008     VarTemplatePartialSpecializationDecl *D, void *InsertPos) {
1009   if (InsertPos)
1010     getPartialSpecializations().InsertNode(D, InsertPos);
1011   else {
1012     VarTemplatePartialSpecializationDecl *Existing =
1013         getPartialSpecializations().GetOrInsertNode(D);
1014     (void)Existing;
1015     assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
1016   }
1017 
1018   if (ASTMutationListener *L = getASTMutationListener())
1019     L->AddedCXXTemplateSpecialization(this, D);
1020 }
1021 
1022 void VarTemplateDecl::getPartialSpecializations(
1023     SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) {
1024   llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
1025       getPartialSpecializations();
1026   PS.clear();
1027   PS.reserve(PartialSpecs.size());
1028   for (VarTemplatePartialSpecializationDecl &P : PartialSpecs)
1029     PS.push_back(P.getMostRecentDecl());
1030 }
1031 
1032 VarTemplatePartialSpecializationDecl *
1033 VarTemplateDecl::findPartialSpecInstantiatedFromMember(
1034     VarTemplatePartialSpecializationDecl *D) {
1035   Decl *DCanon = D->getCanonicalDecl();
1036   for (VarTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
1037     if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
1038       return P.getMostRecentDecl();
1039   }
1040 
1041   return nullptr;
1042 }
1043 
1044 //===----------------------------------------------------------------------===//
1045 // VarTemplateSpecializationDecl Implementation
1046 //===----------------------------------------------------------------------===//
1047 
1048 VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(
1049     Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1050     SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1051     TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args)
1052     : VarDecl(DK, Context, DC, StartLoc, IdLoc,
1053               SpecializedTemplate->getIdentifier(), T, TInfo, S),
1054       SpecializedTemplate(SpecializedTemplate),
1055       TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
1056       SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1057 
1058 VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(Kind DK,
1059                                                              ASTContext &C)
1060     : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1061               QualType(), nullptr, SC_None),
1062       SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1063 
1064 VarTemplateSpecializationDecl *VarTemplateSpecializationDecl::Create(
1065     ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1066     SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1067     TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) {
1068   return new (Context, DC) VarTemplateSpecializationDecl(
1069       VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,
1070       SpecializedTemplate, T, TInfo, S, Args);
1071 }
1072 
1073 VarTemplateSpecializationDecl *
1074 VarTemplateSpecializationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1075   return new (C, ID)
1076       VarTemplateSpecializationDecl(VarTemplateSpecialization, C);
1077 }
1078 
1079 void VarTemplateSpecializationDecl::getNameForDiagnostic(
1080     raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
1081   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
1082 
1083   const auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
1084   if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
1085           PS ? PS->getTemplateArgsAsWritten() : nullptr) {
1086     printTemplateArgumentList(OS, ArgsAsWritten->arguments(), Policy);
1087   } else {
1088     const TemplateArgumentList &TemplateArgs = getTemplateArgs();
1089     printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
1090   }
1091 }
1092 
1093 VarTemplateDecl *VarTemplateSpecializationDecl::getSpecializedTemplate() const {
1094   if (const auto *PartialSpec =
1095           SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1096     return PartialSpec->PartialSpecialization->getSpecializedTemplate();
1097   return SpecializedTemplate.get<VarTemplateDecl *>();
1098 }
1099 
1100 void VarTemplateSpecializationDecl::setTemplateArgsInfo(
1101     const TemplateArgumentListInfo &ArgsInfo) {
1102   TemplateArgsInfo.setLAngleLoc(ArgsInfo.getLAngleLoc());
1103   TemplateArgsInfo.setRAngleLoc(ArgsInfo.getRAngleLoc());
1104   for (const TemplateArgumentLoc &Loc : ArgsInfo.arguments())
1105     TemplateArgsInfo.addArgument(Loc);
1106 }
1107 
1108 //===----------------------------------------------------------------------===//
1109 // VarTemplatePartialSpecializationDecl Implementation
1110 //===----------------------------------------------------------------------===//
1111 
1112 void VarTemplatePartialSpecializationDecl::anchor() {}
1113 
1114 VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(
1115     ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1116     SourceLocation IdLoc, TemplateParameterList *Params,
1117     VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1118     StorageClass S, ArrayRef<TemplateArgument> Args,
1119     const ASTTemplateArgumentListInfo *ArgInfos)
1120     : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context,
1121                                     DC, StartLoc, IdLoc, SpecializedTemplate, T,
1122                                     TInfo, S, Args),
1123       TemplateParams(Params), ArgsAsWritten(ArgInfos),
1124       InstantiatedFromMember(nullptr, false) {
1125   // TODO: The template parameters should be in DC by now. Verify.
1126   // AdoptTemplateParameterList(Params, DC);
1127 }
1128 
1129 VarTemplatePartialSpecializationDecl *
1130 VarTemplatePartialSpecializationDecl::Create(
1131     ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1132     SourceLocation IdLoc, TemplateParameterList *Params,
1133     VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1134     StorageClass S, ArrayRef<TemplateArgument> Args,
1135     const TemplateArgumentListInfo &ArgInfos) {
1136   const ASTTemplateArgumentListInfo *ASTArgInfos
1137     = ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
1138 
1139   auto *Result =
1140       new (Context, DC) VarTemplatePartialSpecializationDecl(
1141           Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo,
1142           S, Args, ASTArgInfos);
1143   Result->setSpecializationKind(TSK_ExplicitSpecialization);
1144   return Result;
1145 }
1146 
1147 VarTemplatePartialSpecializationDecl *
1148 VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
1149                                                          unsigned ID) {
1150   return new (C, ID) VarTemplatePartialSpecializationDecl(C);
1151 }
1152 
1153 static TemplateParameterList *
1154 createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
1155   // typename T
1156   auto *T = TemplateTypeParmDecl::Create(
1157       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
1158       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false);
1159   T->setImplicit(true);
1160 
1161   // T ...Ints
1162   TypeSourceInfo *TI =
1163       C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));
1164   auto *N = NonTypeTemplateParmDecl::Create(
1165       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1166       /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
1167   N->setImplicit(true);
1168 
1169   // <typename T, T ...Ints>
1170   NamedDecl *P[2] = {T, N};
1171   auto *TPL = TemplateParameterList::Create(
1172       C, SourceLocation(), SourceLocation(), P, SourceLocation(), nullptr);
1173 
1174   // template <typename T, ...Ints> class IntSeq
1175   auto *TemplateTemplateParm = TemplateTemplateParmDecl::Create(
1176       C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
1177       /*ParameterPack=*/false, /*Id=*/nullptr, TPL);
1178   TemplateTemplateParm->setImplicit(true);
1179 
1180   // typename T
1181   auto *TemplateTypeParm = TemplateTypeParmDecl::Create(
1182       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1183       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false);
1184   TemplateTypeParm->setImplicit(true);
1185 
1186   // T N
1187   TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(
1188       QualType(TemplateTypeParm->getTypeForDecl(), 0));
1189   auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
1190       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
1191       /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1192   NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,
1193                          NonTypeTemplateParm};
1194 
1195   // template <template <typename T, T ...Ints> class IntSeq, typename T, T N>
1196   return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1197                                        Params, SourceLocation(), nullptr);
1198 }
1199 
1200 static TemplateParameterList *
1201 createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
1202   // std::size_t Index
1203   TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
1204   auto *Index = NonTypeTemplateParmDecl::Create(
1205       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
1206       /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1207 
1208   // typename ...T
1209   auto *Ts = TemplateTypeParmDecl::Create(
1210       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1211       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/true);
1212   Ts->setImplicit(true);
1213 
1214   // template <std::size_t Index, typename ...T>
1215   NamedDecl *Params[] = {Index, Ts};
1216   return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1217                                        llvm::makeArrayRef(Params),
1218                                        SourceLocation(), nullptr);
1219 }
1220 
1221 static TemplateParameterList *createBuiltinTemplateParameterList(
1222     const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
1223   switch (BTK) {
1224   case BTK__make_integer_seq:
1225     return createMakeIntegerSeqParameterList(C, DC);
1226   case BTK__type_pack_element:
1227     return createTypePackElementParameterList(C, DC);
1228   }
1229 
1230   llvm_unreachable("unhandled BuiltinTemplateKind!");
1231 }
1232 
1233 void BuiltinTemplateDecl::anchor() {}
1234 
1235 BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
1236                                          DeclarationName Name,
1237                                          BuiltinTemplateKind BTK)
1238     : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
1239                    createBuiltinTemplateParameterList(C, DC, BTK)),
1240       BTK(BTK) {}
1241