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