clang  10.0.0svn
DeclTemplate.cpp
Go to the documentation of this file.
1 //===- DeclTemplate.cpp - Template Declaration AST Node Implementation ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the C++ related Decl classes for templates.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/DeclTemplate.h"
14 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/Expr.h"
20 #include "clang/AST/TemplateBase.h"
21 #include "clang/AST/TemplateName.h"
22 #include "clang/AST/Type.h"
23 #include "clang/AST/TypeLoc.h"
24 #include "clang/Basic/Builtins.h"
25 #include "clang/Basic/LLVM.h"
27 #include "llvm/ADT/ArrayRef.h"
28 #include "llvm/ADT/FoldingSet.h"
29 #include "llvm/ADT/None.h"
30 #include "llvm/ADT/PointerUnion.h"
31 #include "llvm/ADT/SmallVector.h"
32 #include "llvm/Support/Casting.h"
33 #include "llvm/Support/ErrorHandling.h"
34 #include <algorithm>
35 #include <cassert>
36 #include <cstdint>
37 #include <memory>
38 #include <utility>
39 
40 using namespace clang;
41 
42 //===----------------------------------------------------------------------===//
43 // TemplateParameterList Implementation
44 //===----------------------------------------------------------------------===//
45 
47  SourceLocation LAngleLoc,
48  ArrayRef<NamedDecl *> Params,
49  SourceLocation RAngleLoc,
50  Expr *RequiresClause)
51  : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
52  NumParams(Params.size()), ContainsUnexpandedParameterPack(false),
53  HasRequiresClause(static_cast<bool>(RequiresClause)) {
54  for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
55  NamedDecl *P = Params[Idx];
56  begin()[Idx] = P;
57 
58  if (!P->isTemplateParameterPack()) {
59  if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
60  if (NTTP->getType()->containsUnexpandedParameterPack())
61  ContainsUnexpandedParameterPack = true;
62 
63  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
64  if (TTP->getTemplateParameters()->containsUnexpandedParameterPack())
65  ContainsUnexpandedParameterPack = true;
66 
67  // FIXME: If a default argument contains an unexpanded parameter pack, the
68  // template parameter list does too.
69  }
70  }
71  if (RequiresClause) {
72  *getTrailingObjects<Expr *>() = RequiresClause;
73  }
74 }
75 
78  SourceLocation LAngleLoc,
79  ArrayRef<NamedDecl *> Params,
80  SourceLocation RAngleLoc, Expr *RequiresClause) {
81  void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
82  Params.size(), RequiresClause ? 1u : 0u),
83  alignof(TemplateParameterList));
84  return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params,
85  RAngleLoc, RequiresClause);
86 }
87 
89  unsigned NumRequiredArgs = 0;
90  for (const NamedDecl *P : asArray()) {
91  if (P->isTemplateParameterPack()) {
92  if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
93  if (NTTP->isExpandedParameterPack()) {
94  NumRequiredArgs += NTTP->getNumExpansionTypes();
95  continue;
96  }
97 
98  break;
99  }
100 
101  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
102  if (TTP->hasDefaultArgument())
103  break;
104  } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
105  if (NTTP->hasDefaultArgument())
106  break;
107  } else if (cast<TemplateTemplateParmDecl>(P)->hasDefaultArgument())
108  break;
109 
110  ++NumRequiredArgs;
111  }
112 
113  return NumRequiredArgs;
114 }
115 
117  if (size() == 0)
118  return 0;
119 
120  const NamedDecl *FirstParm = getParam(0);
121  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(FirstParm))
122  return TTP->getDepth();
123  else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
124  return NTTP->getDepth();
125  else
126  return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
127 }
128 
130  DeclContext *Owner) {
131  for (NamedDecl *P : *Params) {
132  P->setDeclContext(Owner);
133 
134  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
135  AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner);
136  }
137 }
138 
139 namespace clang {
140 
142  return new (C) char[sizeof(void*) * 2];
143 }
144 
145 } // namespace clang
146 
147 //===----------------------------------------------------------------------===//
148 // RedeclarableTemplateDecl Implementation
149 //===----------------------------------------------------------------------===//
150 
151 void RedeclarableTemplateDecl::anchor() {}
152 
154  if (Common)
155  return Common;
156 
157  // Walk the previous-declaration chain until we either find a declaration
158  // with a common pointer or we run out of previous declarations.
160  for (const RedeclarableTemplateDecl *Prev = getPreviousDecl(); Prev;
161  Prev = Prev->getPreviousDecl()) {
162  if (Prev->Common) {
163  Common = Prev->Common;
164  break;
165  }
166 
167  PrevDecls.push_back(Prev);
168  }
169 
170  // If we never found a common pointer, allocate one now.
171  if (!Common) {
172  // FIXME: If any of the declarations is from an AST file, we probably
173  // need an update record to add the common data.
174 
175  Common = newCommon(getASTContext());
176  }
177 
178  // Update any previous declarations we saw with the common pointer.
179  for (const RedeclarableTemplateDecl *Prev : PrevDecls)
180  Prev->Common = Common;
181 
182  return Common;
183 }
184 
186  // Grab the most recent declaration to ensure we've loaded any lazy
187  // redeclarations of this template.
188  CommonBase *CommonBasePtr = getMostRecentDecl()->getCommonPtr();
189  if (CommonBasePtr->LazySpecializations) {
190  ASTContext &Context = getASTContext();
191  uint32_t *Specs = CommonBasePtr->LazySpecializations;
192  CommonBasePtr->LazySpecializations = nullptr;
193  for (uint32_t I = 0, N = *Specs++; I != N; ++I)
194  (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
195  }
196 }
197 
198 template<class EntryType>
201  llvm::FoldingSetVector<EntryType> &Specs, ArrayRef<TemplateArgument> Args,
202  void *&InsertPos) {
203  using SETraits = SpecEntryTraits<EntryType>;
204 
205  llvm::FoldingSetNodeID ID;
206  EntryType::Profile(ID, Args, getASTContext());
207  EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);
208  return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr;
209 }
210 
211 template<class Derived, class EntryType>
213  llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
214  void *InsertPos) {
215  using SETraits = SpecEntryTraits<EntryType>;
216 
217  if (InsertPos) {
218 #ifndef NDEBUG
219  void *CorrectInsertPos;
220  assert(!findSpecializationImpl(Specializations,
221  SETraits::getTemplateArgs(Entry),
222  CorrectInsertPos) &&
223  InsertPos == CorrectInsertPos &&
224  "given incorrect InsertPos for specialization");
225 #endif
226  Specializations.InsertNode(Entry, InsertPos);
227  } else {
228  EntryType *Existing = Specializations.GetOrInsertNode(Entry);
229  (void)Existing;
230  assert(SETraits::getDecl(Existing)->isCanonicalDecl() &&
231  "non-canonical specialization?");
232  }
233 
234  if (ASTMutationListener *L = getASTMutationListener())
235  L->AddedCXXTemplateSpecialization(cast<Derived>(this),
236  SETraits::getDecl(Entry));
237 }
238 
239 //===----------------------------------------------------------------------===//
240 // FunctionTemplateDecl Implementation
241 //===----------------------------------------------------------------------===//
242 
244  DeclContext *DC,
245  SourceLocation L,
246  DeclarationName Name,
247  TemplateParameterList *Params,
248  NamedDecl *Decl) {
249  AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
250  return new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl);
251 }
252 
254  unsigned ID) {
255  return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(),
256  DeclarationName(), nullptr, nullptr);
257 }
258 
261  auto *CommonPtr = new (C) Common;
262  C.addDestruction(CommonPtr);
263  return CommonPtr;
264 }
265 
267  loadLazySpecializationsImpl();
268 }
269 
270 llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
272  LoadLazySpecializations();
273  return getCommonPtr()->Specializations;
274 }
275 
276 FunctionDecl *
278  void *&InsertPos) {
279  return findSpecializationImpl(getSpecializations(), Args, InsertPos);
280 }
281 
283  FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
284  addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
285  InsertPos);
286 }
287 
289  TemplateParameterList *Params = getTemplateParameters();
290  Common *CommonPtr = getCommonPtr();
291  if (!CommonPtr->InjectedArgs) {
292  auto &Context = getASTContext();
294  Context.getInjectedTemplateArgs(Params, TemplateArgs);
295  CommonPtr->InjectedArgs =
296  new (Context) TemplateArgument[TemplateArgs.size()];
297  std::copy(TemplateArgs.begin(), TemplateArgs.end(),
298  CommonPtr->InjectedArgs);
299  }
300 
301  return llvm::makeArrayRef(CommonPtr->InjectedArgs, Params->size());
302 }
303 
306 
307  // If we haven't created a common pointer yet, then it can just be created
308  // with the usual method.
309  if (!Base::Common)
310  return;
311 
312  Common *ThisCommon = static_cast<Common *>(Base::Common);
313  Common *PrevCommon = nullptr;
315  for (; Prev; Prev = Prev->getPreviousDecl()) {
316  if (Prev->Base::Common) {
317  PrevCommon = static_cast<Common *>(Prev->Base::Common);
318  break;
319  }
320  PreviousDecls.push_back(Prev);
321  }
322 
323  // If the previous redecl chain hasn't created a common pointer yet, then just
324  // use this common pointer.
325  if (!PrevCommon) {
326  for (auto *D : PreviousDecls)
327  D->Base::Common = ThisCommon;
328  return;
329  }
330 
331  // Ensure we don't leak any important state.
332  assert(ThisCommon->Specializations.size() == 0 &&
333  "Can't merge incompatible declarations!");
334 
335  Base::Common = PrevCommon;
336 }
337 
338 //===----------------------------------------------------------------------===//
339 // ClassTemplateDecl Implementation
340 //===----------------------------------------------------------------------===//
341 
343  DeclContext *DC,
344  SourceLocation L,
345  DeclarationName Name,
346  TemplateParameterList *Params,
347  NamedDecl *Decl,
348  Expr *AssociatedConstraints) {
349  AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
350 
351  if (!AssociatedConstraints) {
352  return new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl);
353  }
354 
355  auto *const CTDI = new (C) ConstrainedTemplateDeclInfo;
356  auto *const New =
357  new (C, DC) ClassTemplateDecl(CTDI, C, DC, L, Name, Params, Decl);
358  New->setAssociatedConstraints(AssociatedConstraints);
359  return New;
360 }
361 
363  unsigned ID) {
364  return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
365  DeclarationName(), nullptr, nullptr);
366 }
367 
369  loadLazySpecializationsImpl();
370 }
371 
372 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
374  LoadLazySpecializations();
375  return getCommonPtr()->Specializations;
376 }
377 
378 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
380  LoadLazySpecializations();
381  return getCommonPtr()->PartialSpecializations;
382 }
383 
386  auto *CommonPtr = new (C) Common;
387  C.addDestruction(CommonPtr);
388  return CommonPtr;
389 }
390 
393  void *&InsertPos) {
394  return findSpecializationImpl(getSpecializations(), Args, InsertPos);
395 }
396 
398  void *InsertPos) {
399  addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
400 }
401 
404  void *&InsertPos) {
405  return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
406 }
407 
410  void *InsertPos) {
411  if (InsertPos)
412  getPartialSpecializations().InsertNode(D, InsertPos);
413  else {
415  = getPartialSpecializations().GetOrInsertNode(D);
416  (void)Existing;
417  assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
418  }
419 
420  if (ASTMutationListener *L = getASTMutationListener())
421  L->AddedCXXTemplateSpecialization(this, D);
422 }
423 
426  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
427  = getPartialSpecializations();
428  PS.clear();
429  PS.reserve(PartialSpecs.size());
430  for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs)
431  PS.push_back(P.getMostRecentDecl());
432 }
433 
436  ASTContext &Context = getASTContext();
438  getPartialSpecializations()) {
439  if (Context.hasSameType(P.getInjectedSpecializationType(), T))
440  return P.getMostRecentDecl();
441  }
442 
443  return nullptr;
444 }
445 
449  Decl *DCanon = D->getCanonicalDecl();
450  for (ClassTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
451  if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
452  return P.getMostRecentDecl();
453  }
454 
455  return nullptr;
456 }
457 
458 QualType
460  Common *CommonPtr = getCommonPtr();
461  if (!CommonPtr->InjectedClassNameType.isNull())
462  return CommonPtr->InjectedClassNameType;
463 
464  // C++0x [temp.dep.type]p2:
465  // The template argument list of a primary template is a template argument
466  // list in which the nth template argument has the value of the nth template
467  // parameter of the class template. If the nth template parameter is a
468  // template parameter pack (14.5.3), the nth template argument is a pack
469  // expansion (14.5.3) whose pattern is the name of the template parameter
470  // pack.
471  ASTContext &Context = getASTContext();
472  TemplateParameterList *Params = getTemplateParameters();
474  Context.getInjectedTemplateArgs(Params, TemplateArgs);
475  CommonPtr->InjectedClassNameType
477  TemplateArgs);
478  return CommonPtr->InjectedClassNameType;
479 }
480 
481 //===----------------------------------------------------------------------===//
482 // TemplateTypeParm Allocation/Deallocation Method Implementations
483 //===----------------------------------------------------------------------===//
484 
487  SourceLocation KeyLoc, SourceLocation NameLoc,
488  unsigned D, unsigned P, IdentifierInfo *Id,
489  bool Typename, bool ParameterPack) {
490  auto *TTPDecl =
491  new (C, DC) TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename);
492  QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
493  TTPDecl->setTypeForDecl(TTPType.getTypePtr());
494  return TTPDecl;
495 }
496 
499  return new (C, ID) TemplateTypeParmDecl(nullptr, SourceLocation(),
500  SourceLocation(), nullptr, false);
501 }
502 
504  return hasDefaultArgument()
505  ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc()
506  : SourceLocation();
507 }
508 
510  if (hasDefaultArgument() && !defaultArgumentWasInherited())
511  return SourceRange(getBeginLoc(),
512  getDefaultArgumentInfo()->getTypeLoc().getEndLoc());
513  // TypeDecl::getSourceRange returns a range containing name location, which is
514  // wrong for unnamed template parameters. e.g:
515  // it will return <[[typename>]] instead of <[[typename]]>
516  else if (getDeclName().isEmpty())
517  return SourceRange(getBeginLoc());
518  return TypeDecl::getSourceRange();
519 }
520 
522  return getTypeForDecl()->castAs<TemplateTypeParmType>()->getDepth();
523 }
524 
526  return getTypeForDecl()->castAs<TemplateTypeParmType>()->getIndex();
527 }
528 
530  return getTypeForDecl()->castAs<TemplateTypeParmType>()->isParameterPack();
531 }
532 
533 //===----------------------------------------------------------------------===//
534 // NonTypeTemplateParmDecl Method Implementations
535 //===----------------------------------------------------------------------===//
536 
537 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
538  DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D,
539  unsigned P, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
540  ArrayRef<QualType> ExpandedTypes, ArrayRef<TypeSourceInfo *> ExpandedTInfos)
541  : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
542  TemplateParmPosition(D, P), ParameterPack(true),
543  ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {
544  if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {
545  auto TypesAndInfos =
546  getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
547  for (unsigned I = 0; I != NumExpandedTypes; ++I) {
548  new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]);
549  TypesAndInfos[I].second = ExpandedTInfos[I];
550  }
551  }
552 }
553 
556  SourceLocation StartLoc, SourceLocation IdLoc,
557  unsigned D, unsigned P, IdentifierInfo *Id,
558  QualType T, bool ParameterPack,
559  TypeSourceInfo *TInfo) {
560  return new (C, DC) NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id,
561  T, ParameterPack, TInfo);
562 }
563 
565  const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
566  SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
567  QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
568  ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
569  return new (C, DC,
570  additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
571  ExpandedTypes.size()))
572  NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
573  ExpandedTypes, ExpandedTInfos);
574 }
575 
578  return new (C, ID) NonTypeTemplateParmDecl(nullptr, SourceLocation(),
579  SourceLocation(), 0, 0, nullptr,
580  QualType(), false, nullptr);
581 }
582 
585  unsigned NumExpandedTypes) {
586  auto *NTTP =
587  new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
588  NumExpandedTypes))
590  0, 0, nullptr, QualType(), nullptr, None,
591  None);
592  NTTP->NumExpandedTypes = NumExpandedTypes;
593  return NTTP;
594 }
595 
597  if (hasDefaultArgument() && !defaultArgumentWasInherited())
598  return SourceRange(getOuterLocStart(),
599  getDefaultArgument()->getSourceRange().getEnd());
601 }
602 
604  return hasDefaultArgument()
605  ? getDefaultArgument()->getSourceRange().getBegin()
606  : SourceLocation();
607 }
608 
609 //===----------------------------------------------------------------------===//
610 // TemplateTemplateParmDecl Method Implementations
611 //===----------------------------------------------------------------------===//
612 
613 void TemplateTemplateParmDecl::anchor() {}
614 
615 TemplateTemplateParmDecl::TemplateTemplateParmDecl(
616  DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
619  : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
620  TemplateParmPosition(D, P), ParameterPack(true),
621  ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {
622  if (!Expansions.empty())
623  std::uninitialized_copy(Expansions.begin(), Expansions.end(),
624  getTrailingObjects<TemplateParameterList *>());
625 }
626 
629  SourceLocation L, unsigned D, unsigned P,
630  bool ParameterPack, IdentifierInfo *Id,
631  TemplateParameterList *Params) {
632  return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
633  Params);
634 }
635 
638  SourceLocation L, unsigned D, unsigned P,
639  IdentifierInfo *Id,
640  TemplateParameterList *Params,
642  return new (C, DC,
643  additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
644  TemplateTemplateParmDecl(DC, L, D, P, Id, Params, Expansions);
645 }
646 
649  return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
650  false, nullptr, nullptr);
651 }
652 
655  unsigned NumExpansions) {
656  auto *TTP =
657  new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
658  TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
659  nullptr, None);
660  TTP->NumExpandedParams = NumExpansions;
661  return TTP;
662 }
663 
665  return hasDefaultArgument() ? getDefaultArgument().getLocation()
666  : SourceLocation();
667 }
668 
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::TemplateArgumentList(ArrayRef<TemplateArgument> Args)
681  : Arguments(getTrailingObjects<TemplateArgument>()),
682  NumArguments(Args.size()) {
683  std::uninitialized_copy(Args.begin(), Args.end(),
684  getTrailingObjects<TemplateArgument>());
685 }
686 
690  void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
691  return new (Mem) TemplateArgumentList(Args);
692 }
693 
696  TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs,
697  const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI,
698  MemberSpecializationInfo *MSInfo) {
699  const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
700  if (TemplateArgsAsWritten)
701  ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C,
702  *TemplateArgsAsWritten);
703 
704  void *Mem =
705  C.Allocate(totalSizeToAlloc<MemberSpecializationInfo *>(MSInfo ? 1 : 0));
706  return new (Mem) FunctionTemplateSpecializationInfo(
707  FD, Template, TSK, TemplateArgs, ArgsAsWritten, POI, MSInfo);
708 }
709 
710 //===----------------------------------------------------------------------===//
711 // TemplateDecl Implementation
712 //===----------------------------------------------------------------------===//
713 
714 void TemplateDecl::anchor() {}
715 
716 //===----------------------------------------------------------------------===//
717 // ClassTemplateSpecializationDecl Implementation
718 //===----------------------------------------------------------------------===//
719 
722  DeclContext *DC, SourceLocation StartLoc,
723  SourceLocation IdLoc,
724  ClassTemplateDecl *SpecializedTemplate,
727  : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,
728  SpecializedTemplate->getIdentifier(), PrevDecl),
729  SpecializedTemplate(SpecializedTemplate),
730  TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
731  SpecializationKind(TSK_Undeclared) {
732 }
733 
735  Kind DK)
736  : CXXRecordDecl(DK, TTK_Struct, C, nullptr, SourceLocation(),
737  SourceLocation(), nullptr, nullptr),
738  SpecializationKind(TSK_Undeclared) {}
739 
742  DeclContext *DC,
743  SourceLocation StartLoc,
744  SourceLocation IdLoc,
745  ClassTemplateDecl *SpecializedTemplate,
748  auto *Result =
749  new (Context, DC) ClassTemplateSpecializationDecl(
750  Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
751  SpecializedTemplate, Args, PrevDecl);
752  Result->setMayHaveOutOfDateDef(false);
753 
754  Context.getTypeDeclType(Result, PrevDecl);
755  return Result;
756 }
757 
760  unsigned ID) {
761  auto *Result =
762  new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
763  Result->setMayHaveOutOfDateDef(false);
764  return Result;
765 }
766 
768  raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
769  NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
770 
771  const auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
772  if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
773  PS ? PS->getTemplateArgsAsWritten() : nullptr) {
774  printTemplateArgumentList(OS, ArgsAsWritten->arguments(), Policy);
775  } else {
776  const TemplateArgumentList &TemplateArgs = getTemplateArgs();
777  printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
778  }
779 }
780 
783  if (const auto *PartialSpec =
784  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
785  return PartialSpec->PartialSpecialization->getSpecializedTemplate();
786  return SpecializedTemplate.get<ClassTemplateDecl*>();
787 }
788 
791  if (ExplicitInfo) {
793  if (Begin.isValid()) {
794  // Here we have an explicit (partial) specialization or instantiation.
798  if (getExternLoc().isValid())
799  Begin = getExternLoc();
801  if (End.isInvalid())
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.
809  auto *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 *,
818  inst_from = getInstantiatedFrom();
819  if (inst_from.isNull())
821  if (const auto *ctd = inst_from.dyn_cast<ClassTemplateDecl *>())
822  return ctd->getSourceRange();
823  return inst_from.get<ClassTemplatePartialSpecializationDecl *>()
824  ->getSourceRange();
825  }
826 }
827 
828 //===----------------------------------------------------------------------===//
829 // ConceptDecl Implementation
830 //===----------------------------------------------------------------------===//
833  TemplateParameterList *Params,
834  Expr *ConstraintExpr) {
835  AdoptTemplateParameterList(Params, DC);
836  return new (C, DC) ConceptDecl(DC, L, Name, Params, ConstraintExpr);
837 }
838 
840  unsigned ID) {
841  ConceptDecl *Result = new (C, ID) ConceptDecl(nullptr, SourceLocation(),
842  DeclarationName(),
843  nullptr, nullptr);
844 
845  return Result;
846 }
847 
848 //===----------------------------------------------------------------------===//
849 // ClassTemplatePartialSpecializationDecl Implementation
850 //===----------------------------------------------------------------------===//
851 void ClassTemplatePartialSpecializationDecl::anchor() {}
852 
853 ClassTemplatePartialSpecializationDecl::
854 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
855  DeclContext *DC,
856  SourceLocation StartLoc,
857  SourceLocation IdLoc,
858  TemplateParameterList *Params,
859  ClassTemplateDecl *SpecializedTemplate,
861  const ASTTemplateArgumentListInfo *ArgInfos,
864  ClassTemplatePartialSpecialization,
865  TK, DC, StartLoc, IdLoc,
866  SpecializedTemplate, Args, PrevDecl),
867  TemplateParams(Params), ArgsAsWritten(ArgInfos),
868  InstantiatedFromMember(nullptr, false) {
869  AdoptTemplateParameterList(Params, this);
870 }
871 
875  SourceLocation StartLoc, SourceLocation IdLoc,
876  TemplateParameterList *Params,
877  ClassTemplateDecl *SpecializedTemplate,
879  const TemplateArgumentListInfo &ArgInfos,
880  QualType CanonInjectedType,
882  const ASTTemplateArgumentListInfo *ASTArgInfos =
883  ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
884 
885  auto *Result = new (Context, DC)
886  ClassTemplatePartialSpecializationDecl(Context, TK, DC, StartLoc, IdLoc,
887  Params, SpecializedTemplate, Args,
888  ASTArgInfos, PrevDecl);
889  Result->setSpecializationKind(TSK_ExplicitSpecialization);
890  Result->setMayHaveOutOfDateDef(false);
891 
892  Context.getInjectedClassNameType(Result, CanonInjectedType);
893  return Result;
894 }
895 
898  unsigned ID) {
900  Result->setMayHaveOutOfDateDef(false);
901  return Result;
902 }
903 
904 //===----------------------------------------------------------------------===//
905 // FriendTemplateDecl Implementation
906 //===----------------------------------------------------------------------===//
907 
908 void FriendTemplateDecl::anchor() {}
909 
912  SourceLocation L,
914  FriendUnion Friend, SourceLocation FLoc) {
915  return new (Context, DC) FriendTemplateDecl(DC, L, Params, Friend, FLoc);
916 }
917 
919  unsigned ID) {
920  return new (C, ID) FriendTemplateDecl(EmptyShell());
921 }
922 
923 //===----------------------------------------------------------------------===//
924 // TypeAliasTemplateDecl Implementation
925 //===----------------------------------------------------------------------===//
926 
928  DeclContext *DC,
929  SourceLocation L,
930  DeclarationName Name,
931  TemplateParameterList *Params,
932  NamedDecl *Decl) {
933  AdoptTemplateParameterList(Params, DC);
934  return new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl);
935 }
936 
938  unsigned ID) {
939  return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
940  DeclarationName(), nullptr, nullptr);
941 }
942 
945  auto *CommonPtr = new (C) Common;
946  C.addDestruction(CommonPtr);
947  return CommonPtr;
948 }
949 
950 //===----------------------------------------------------------------------===//
951 // ClassScopeFunctionSpecializationDecl Implementation
952 //===----------------------------------------------------------------------===//
953 
954 void ClassScopeFunctionSpecializationDecl::anchor() {}
955 
958  unsigned ID) {
960  nullptr, SourceLocation(), nullptr, nullptr);
961 }
962 
963 //===----------------------------------------------------------------------===//
964 // VarTemplateDecl Implementation
965 //===----------------------------------------------------------------------===//
966 
968  VarTemplateDecl *CurD = this;
969  while (CurD) {
970  if (CurD->isThisDeclarationADefinition())
971  return CurD;
972  CurD = CurD->getPreviousDecl();
973  }
974  return nullptr;
975 }
976 
979  TemplateParameterList *Params,
980  VarDecl *Decl) {
981  AdoptTemplateParameterList(Params, DC);
982  return new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl);
983 }
984 
986  unsigned ID) {
987  return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
988  DeclarationName(), nullptr, nullptr);
989 }
990 
992  loadLazySpecializationsImpl();
993 }
994 
995 llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
997  LoadLazySpecializations();
998  return getCommonPtr()->Specializations;
999 }
1000 
1001 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
1003  LoadLazySpecializations();
1004  return getCommonPtr()->PartialSpecializations;
1005 }
1006 
1009  auto *CommonPtr = new (C) Common;
1010  C.addDestruction(CommonPtr);
1011  return CommonPtr;
1012 }
1013 
1016  void *&InsertPos) {
1017  return findSpecializationImpl(getSpecializations(), Args, InsertPos);
1018 }
1019 
1021  void *InsertPos) {
1022  addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
1023 }
1024 
1027  void *&InsertPos) {
1028  return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
1029 }
1030 
1032  VarTemplatePartialSpecializationDecl *D, void *InsertPos) {
1033  if (InsertPos)
1034  getPartialSpecializations().InsertNode(D, InsertPos);
1035  else {
1037  getPartialSpecializations().GetOrInsertNode(D);
1038  (void)Existing;
1039  assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
1040  }
1041 
1043  L->AddedCXXTemplateSpecialization(this, D);
1044 }
1045 
1048  llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
1049  getPartialSpecializations();
1050  PS.clear();
1051  PS.reserve(PartialSpecs.size());
1052  for (VarTemplatePartialSpecializationDecl &P : PartialSpecs)
1053  PS.push_back(P.getMostRecentDecl());
1054 }
1055 
1059  Decl *DCanon = D->getCanonicalDecl();
1060  for (VarTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
1061  if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
1062  return P.getMostRecentDecl();
1063  }
1064 
1065  return nullptr;
1066 }
1067 
1068 //===----------------------------------------------------------------------===//
1069 // VarTemplateSpecializationDecl Implementation
1070 //===----------------------------------------------------------------------===//
1071 
1073  Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1074  SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1076  : VarDecl(DK, Context, DC, StartLoc, IdLoc,
1077  SpecializedTemplate->getIdentifier(), T, TInfo, S),
1078  SpecializedTemplate(SpecializedTemplate),
1079  TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
1080  SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1081 
1083  ASTContext &C)
1084  : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1085  QualType(), nullptr, SC_None),
1086  SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1087 
1089  ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1090  SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1092  return new (Context, DC) VarTemplateSpecializationDecl(
1093  VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,
1094  SpecializedTemplate, T, TInfo, S, Args);
1095 }
1096 
1099  return new (C, ID)
1100  VarTemplateSpecializationDecl(VarTemplateSpecialization, C);
1101 }
1102 
1104  raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
1105  NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
1106 
1107  const auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
1108  if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
1109  PS ? PS->getTemplateArgsAsWritten() : nullptr) {
1110  printTemplateArgumentList(OS, ArgsAsWritten->arguments(), Policy);
1111  } else {
1112  const TemplateArgumentList &TemplateArgs = getTemplateArgs();
1113  printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
1114  }
1115 }
1116 
1118  if (const auto *PartialSpec =
1119  SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1120  return PartialSpec->PartialSpecialization->getSpecializedTemplate();
1121  return SpecializedTemplate.get<VarTemplateDecl *>();
1122 }
1123 
1125  const TemplateArgumentListInfo &ArgsInfo) {
1126  TemplateArgsInfo.setLAngleLoc(ArgsInfo.getLAngleLoc());
1127  TemplateArgsInfo.setRAngleLoc(ArgsInfo.getRAngleLoc());
1128  for (const TemplateArgumentLoc &Loc : ArgsInfo.arguments())
1129  TemplateArgsInfo.addArgument(Loc);
1130 }
1131 
1132 //===----------------------------------------------------------------------===//
1133 // VarTemplatePartialSpecializationDecl Implementation
1134 //===----------------------------------------------------------------------===//
1135 
1136 void VarTemplatePartialSpecializationDecl::anchor() {}
1137 
1138 VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(
1139  ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1140  SourceLocation IdLoc, TemplateParameterList *Params,
1141  VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1143  const ASTTemplateArgumentListInfo *ArgInfos)
1144  : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context,
1145  DC, StartLoc, IdLoc, SpecializedTemplate, T,
1146  TInfo, S, Args),
1147  TemplateParams(Params), ArgsAsWritten(ArgInfos),
1148  InstantiatedFromMember(nullptr, false) {
1149  // TODO: The template parameters should be in DC by now. Verify.
1150  // AdoptTemplateParameterList(Params, DC);
1151 }
1152 
1155  ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1156  SourceLocation IdLoc, TemplateParameterList *Params,
1157  VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1159  const TemplateArgumentListInfo &ArgInfos) {
1160  const ASTTemplateArgumentListInfo *ASTArgInfos
1161  = ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
1162 
1163  auto *Result =
1164  new (Context, DC) VarTemplatePartialSpecializationDecl(
1165  Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo,
1166  S, Args, ASTArgInfos);
1167  Result->setSpecializationKind(TSK_ExplicitSpecialization);
1168  return Result;
1169 }
1170 
1173  unsigned ID) {
1174  return new (C, ID) VarTemplatePartialSpecializationDecl(C);
1175 }
1176 
1177 static TemplateParameterList *
1179  // typename T
1180  auto *T = TemplateTypeParmDecl::Create(
1181  C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
1182  /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false);
1183  T->setImplicit(true);
1184 
1185  // T ...Ints
1186  TypeSourceInfo *TI =
1187  C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));
1189  C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1190  /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
1191  N->setImplicit(true);
1192 
1193  // <typename T, T ...Ints>
1194  NamedDecl *P[2] = {T, N};
1195  auto *TPL = TemplateParameterList::Create(
1196  C, SourceLocation(), SourceLocation(), P, SourceLocation(), nullptr);
1197 
1198  // template <typename T, ...Ints> class IntSeq
1199  auto *TemplateTemplateParm = TemplateTemplateParmDecl::Create(
1200  C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
1201  /*ParameterPack=*/false, /*Id=*/nullptr, TPL);
1202  TemplateTemplateParm->setImplicit(true);
1203 
1204  // typename T
1205  auto *TemplateTypeParm = TemplateTypeParmDecl::Create(
1206  C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1207  /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false);
1208  TemplateTypeParm->setImplicit(true);
1209 
1210  // T N
1212  QualType(TemplateTypeParm->getTypeForDecl(), 0));
1213  auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
1214  C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
1215  /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1216  NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,
1217  NonTypeTemplateParm};
1218 
1219  // template <template <typename T, T ...Ints> class IntSeq, typename T, T N>
1221  Params, SourceLocation(), nullptr);
1222 }
1223 
1224 static TemplateParameterList *
1226  // std::size_t Index
1228  auto *Index = NonTypeTemplateParmDecl::Create(
1229  C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
1230  /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1231 
1232  // typename ...T
1233  auto *Ts = TemplateTypeParmDecl::Create(
1234  C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1235  /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/true);
1236  Ts->setImplicit(true);
1237 
1238  // template <std::size_t Index, typename ...T>
1239  NamedDecl *Params[] = {Index, Ts};
1241  llvm::makeArrayRef(Params),
1242  SourceLocation(), nullptr);
1243 }
1244 
1246  const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
1247  switch (BTK) {
1248  case BTK__make_integer_seq:
1249  return createMakeIntegerSeqParameterList(C, DC);
1251  return createTypePackElementParameterList(C, DC);
1252  }
1253 
1254  llvm_unreachable("unhandled BuiltinTemplateKind!");
1255 }
1256 
1257 void BuiltinTemplateDecl::anchor() {}
1258 
1259 BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
1260  DeclarationName Name,
1261  BuiltinTemplateKind BTK)
1262  : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
1264  BTK(BTK) {}
Defines the clang::ASTContext interface.
void setImplicit(bool I=true)
Definition: DeclBase.h:559
Represents a function declaration or definition.
Definition: Decl.h:1784
A (possibly-)qualified type.
Definition: Type.h:643
virtual Decl * GetExternalDecl(uint32_t ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
llvm::FoldingSetVector< VarTemplateSpecializationDecl > & getSpecializations() const
Retrieve the set of specializations of this variable template.
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
SourceRange getBraceRange() const
Definition: Decl.h:3214
ArrayRef< TemplateArgument > getInjectedTemplateArgs()
Retrieve the "injected" template arguments that correspond to the template parameters of this functio...
ClassTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
C Language Family Type Representation.
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, TemplateParameterList *Params)
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
ArrayRef< NamedDecl * > asArray()
Definition: DeclTemplate.h:125
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
Defines the C++ template declaration subclasses.
StringRef P
Declaration of a variable template.
static FunctionTemplateSpecializationInfo * Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template, TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI, MemberSpecializationInfo *MSInfo)
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:132
A container of type source information.
Definition: Decl.h:86
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
void mergePrevDecl(FunctionTemplateDecl *Prev)
Merge Prev with our RedeclarableTemplateDecl::Common.
SourceLocation getEndLoc() const
Get the end source location.
Definition: TypeLoc.cpp:226
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:574
Represents a variable declaration or definition.
Definition: Decl.h:827
ASTMutationListener * getASTMutationListener() const
Definition: DeclBase.cpp:381
void LoadLazySpecializations() const
Load any lazily-loaded specializations from the external source.
Declaration of a redeclarable template.
Definition: DeclTemplate.h:793
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
Represents a variable template specialization, which refers to a variable template with a given set o...
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:603
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:67
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:37
void LoadLazySpecializations() const
Load any lazily-loaded specializations from the external source.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: DeclTemplate.h:466
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
SourceLocation getDefaultArgumentLoc() const
Retrieve the location of the default argument, if any.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
One of these records is kept for each identifier that is lexed.
Represents a class template specialization, which refers to a class template with a given set of temp...
unsigned getDepth() const
Retrieve the depth of the template parameter.
VarTemplateSpecializationDecl(Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:160
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
Defines the position of a template parameter within a template parameter list.
VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
void * allocateDefaultArgStorageChain(const ASTContext &C)
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
Stores the template parameter list and associated constraints for TemplateDecl objects that track ass...
Definition: DeclTemplate.h:374
Declaration of a function specialization at template class scope.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:512
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization. ...
A convenient class for passing around template argument information.
Definition: TemplateBase.h:554
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
static TemplateParameterList * createTypePackElementParameterList(const ASTContext &C, DeclContext *DC)
static ClassTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:1902
SourceLocation getDefaultArgumentLoc() const
Retrieves the location of the default argument declaration.
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6148
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:491
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D, void *InsertPos)
Insert the specified partial specialization knowing that it is not already in.
llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > Specializations
The function template specializations for this function template, including explicit specializations ...
SpecEntryTraits< EntryType >::DeclType * findSpecializationImpl(llvm::FoldingSetVector< EntryType > &Specs, ArrayRef< TemplateArgument > Args, void *&InsertPos)
static TemplateTypeParmDecl * CreateDeserialized(const ASTContext &C, unsigned ID)
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
Definition: DeclBase.h:104
void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:696
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D, void *InsertPos)
Insert the specified partial specialization knowing that it is not already in.
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:883
This represents one expression.
Definition: Expr.h:108
CommonBase * getCommonPtr() const
Retrieves the "common" pointer shared by all (re-)declarations of the same template.
void setAssociatedConstraints(Expr *AC)
Definition: DeclTemplate.h:491
SourceLocation End
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, const TemplateArgumentListInfo &ArgInfos, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)
int Id
Definition: ASTDiff.cpp:190
Declaration of a template type parameter.
llvm::PointerUnion< NamedDecl *, TypeSourceInfo * > FriendUnion
#define bool
Definition: stdbool.h:15
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Data that is common to all of the declarations of a given variable template.
SourceLocation Begin
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:268
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack...
Definition: DeclBase.cpp:201
Represents a C++ template name within the type system.
Definition: TemplateName.h:187
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy)
Print a template argument list, including the &#39;<&#39; and &#39;>&#39; enclosing the template arguments.
Defines the clang::TypeLoc interface and its subclasses.
StorageClass
Storage classes.
Definition: Specifiers.h:235
void addDestruction(T *Ptr) const
If T isn&#39;t trivially destructible, calls AddDeallocation to register it for destruction.
Definition: ASTContext.h:2769
Declaration of an alias template.
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
SourceLocation getEnd() const
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
static TemplateParameterList * createBuiltinTemplateParameterList(const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK)
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
Data that is common to all of the declarations of a given class template.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1403
The result type of a method or function.
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:708
static StringRef getIdentifier(const Token &Tok)
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2071
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
static TypeAliasTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty alias template node.
#define false
Definition: stdbool.h:17
The "struct" keyword.
Definition: Type.h:5109
llvm::FoldingSetVector< ClassTemplateSpecializationDecl > & getSpecializations() const
Retrieve the set of specializations of this class template.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:203
uint32_t * LazySpecializations
If non-null, points to an array of specializations (including partial specializations) known only by ...
Definition: DeclTemplate.h:877
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
CommonBase * newCommon(ASTContext &C) const override
ClassTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *D)
Find a class template partial specialization which was instantiated from the given member partial spe...
QualType InjectedClassNameType
The injected-class-name type for this class template.
bool isParameterPack() const
Returns whether this is a parameter pack.
Encodes a location in the source.
static TemplateTemplateParmDecl * CreateDeserialized(ASTContext &C, unsigned ID)
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getInstantiatedFrom() const
If this class template specialization is an instantiation of a template (rather than an explicit spec...
This names the __make_integer_seq BuiltinTemplateDecl.
Definition: Builtins.h:250
CommonBase * newCommon(ASTContext &C) const override
Data that is common to all of the declarations of a given function template.
static void AdoptTemplateParameterList(TemplateParameterList *Params, DeclContext *Owner)
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template...
static ConceptDecl * CreateDeserialized(ASTContext &C, unsigned ID)
BuiltinTemplateKind
Kinds of BuiltinTemplateDecl.
Definition: Builtins.h:248
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
static FriendTemplateDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc, MutableArrayRef< TemplateParameterList *> Params, FriendUnion Friend, SourceLocation FriendLoc)
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:193
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:178
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
static VarTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty variable template node.
static TemplateParameterList * createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC)
void addSpecialization(FunctionTemplateSpecializationInfo *Info, void *InsertPos)
Add a specialization of this function template.
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:573
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:594
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl, Expr *AssociatedConstraints=nullptr)
Create a class template node.
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:685
Represents a template argument.
Definition: TemplateBase.h:50
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
TagTypeKind
The kind of a tag type.
Definition: Type.h:5107
TagTypeKind TagKind
Definition: Decl.h:3140
Dataflow Directional Tag Classes.
void getInjectedTemplateArgs(const TemplateParameterList *Params, SmallVectorImpl< TemplateArgument > &Args)
Get a template argument list with one argument per template parameter in a template parameter list...
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
Definition: Decl.cpp:1665
bool isValid() const
Return true if this is a valid SourceLocation object.
static ClassScopeFunctionSpecializationDecl * CreateDeserialized(ASTContext &Context, unsigned ID)
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:498
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
static ClassTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty class template node.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:403
void LoadLazySpecializations() const
Load any lazily-loaded specializations from the external source.
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:189
unsigned getIndex() const
Retrieve the index of the template parameter.
static VarTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
The name of a declaration.
static NonTypeTemplateParmDecl * CreateDeserialized(ASTContext &C, unsigned ID)
This names the __type_pack_element BuiltinTemplateDecl.
Definition: Builtins.h:253
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:175
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:582
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1085
static FriendTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
bool isThisDeclarationADefinition() const
Returns whether this template declaration defines the primary variable pattern.
bool isNull() const
Determine whether this template argument has no value.
Definition: TemplateBase.h:237
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:449
static ClassTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:185
static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args, const TemplateArgumentListInfo &ArgInfos)
VarTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this variable template, or nullptr if no such declaration exists...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2305
static FunctionTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty function template node.
static VarTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
A template argument list.
Definition: DeclTemplate.h:214
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:240
SourceLocation getDefaultArgumentLoc() const
Retrieve the location of the default argument, if any.
TemplateArgument * InjectedArgs
The set of "injected" template arguments used within this function template.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
QualType getTemplateTypeParmType(unsigned Depth, unsigned Index, bool ParameterPack, TemplateTypeParmDecl *ParmDecl=nullptr) const
Retrieve the template type parameter type for a template parameter or parameter pack with the given d...
void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
Defines the clang::SourceLocation class and associated facilities.
Represents a C++ struct/union/class.
Definition: DeclCXX.h:255
static const ASTTemplateArgumentListInfo * Create(ASTContext &C, const TemplateArgumentListInfo &List)
TemplateParameterList(SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
CommonBase * newCommon(ASTContext &C) const override
void addSpecializationImpl(llvm::FoldingSetVector< EntryType > &Specs, EntryType *Entry, void *InsertPos)
CommonBase * newCommon(ASTContext &C) const override
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:664
ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
Declaration of a class template.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.h:2972
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
VarTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(VarTemplatePartialSpecializationDecl *D)
Find a variable template partial specialization which was instantiated from the given member partial ...
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:91
SourceLocation getLAngleLoc() const
Definition: TemplateBase.h:570
llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > & getSpecializations() const
Retrieve the set of function template specializations of this function template.
static ConceptDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, Expr *ConstraintExpr)
A trivial tuple used to represent a source range.
static VarTemplateSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
This represents a decl that may have a name.
Definition: Decl.h:248
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Declaration of a friend template.
SourceLocation getRAngleLoc() const
Definition: TemplateBase.h:571
VarTemplateDecl * getDefinition()
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:175
Defines enum values for all the target-independent builtin functions.
Declaration of a template function.
ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.