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