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