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" 40 using namespace clang;
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) {
59 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
60 if (NTTP->getType()->containsUnexpandedParameterPack())
61 ContainsUnexpandedParameterPack =
true;
63 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
64 if (TTP->getTemplateParameters()->containsUnexpandedParameterPack())
65 ContainsUnexpandedParameterPack =
true;
72 *getTrailingObjects<Expr *>() = RequiresClause;
81 void *Mem = C.
Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
82 Params.size(), RequiresClause ? 1u : 0u),
85 RAngleLoc, RequiresClause);
89 unsigned NumRequiredArgs = 0;
91 if (
P->isTemplateParameterPack()) {
92 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
P))
93 if (NTTP->isExpandedParameterPack()) {
94 NumRequiredArgs += NTTP->getNumExpansionTypes();
101 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(
P)) {
102 if (TTP->hasDefaultArgument())
104 }
else if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
P)) {
105 if (NTTP->hasDefaultArgument())
107 }
else if (cast<TemplateTemplateParmDecl>(
P)->hasDefaultArgument())
113 return NumRequiredArgs;
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();
126 return cast<TemplateTemplateParmDecl>(FirstParm)->
getDepth();
132 P->setDeclContext(Owner);
134 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(
P))
142 return new (
C)
char[
sizeof(
void*) * 2];
151 void RedeclarableTemplateDecl::anchor() {}
163 Common = Prev->Common;
167 PrevDecls.push_back(Prev);
175 Common = newCommon(getASTContext());
180 Prev->Common = Common;
188 CommonBase *CommonBasePtr = getMostRecentDecl()->getCommonPtr();
193 for (uint32_t I = 0, N = *Specs++; I != N; ++I)
198 template<
class EntryType>
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;
211 template<
class Derived,
class EntryType>
213 llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
219 void *CorrectInsertPos;
220 assert(!findSpecializationImpl(Specializations,
221 SETraits::getTemplateArgs(Entry),
223 InsertPos == CorrectInsertPos &&
224 "given incorrect InsertPos for specialization");
226 Specializations.InsertNode(Entry, InsertPos);
228 EntryType *Existing = Specializations.GetOrInsertNode(Entry);
230 assert(SETraits::getDecl(Existing)->isCanonicalDecl() &&
231 "non-canonical specialization?");
235 L->AddedCXXTemplateSpecialization(cast<Derived>(
this),
236 SETraits::getDecl(Entry));
261 auto *CommonPtr =
new (
C)
Common;
267 loadLazySpecializationsImpl();
270 llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
272 LoadLazySpecializations();
273 return getCommonPtr()->Specializations;
279 return findSpecializationImpl(getSpecializations(), Args, InsertPos);
284 addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
290 Common *CommonPtr = getCommonPtr();
292 auto &Context = getASTContext();
297 std::copy(TemplateArgs.begin(), TemplateArgs.end(),
312 Common *ThisCommon =
static_cast<Common *
>(Base::Common);
313 Common *PrevCommon =
nullptr;
316 if (Prev->Base::Common) {
317 PrevCommon =
static_cast<Common *
>(Prev->Base::Common);
320 PreviousDecls.push_back(Prev);
326 for (
auto *D : PreviousDecls)
327 D->Base::Common = ThisCommon;
333 "Can't merge incompatible declarations!");
335 Base::Common = PrevCommon;
348 Expr *AssociatedConstraints) {
351 if (!AssociatedConstraints) {
369 loadLazySpecializationsImpl();
372 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
374 LoadLazySpecializations();
375 return getCommonPtr()->Specializations;
378 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
380 LoadLazySpecializations();
381 return getCommonPtr()->PartialSpecializations;
386 auto *CommonPtr =
new (
C)
Common;
394 return findSpecializationImpl(getSpecializations(), Args, InsertPos);
399 addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
405 return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
412 getPartialSpecializations().InsertNode(D, InsertPos);
415 = getPartialSpecializations().GetOrInsertNode(D);
417 assert(Existing->
isCanonicalDecl() &&
"Non-canonical specialization?");
421 L->AddedCXXTemplateSpecialization(
this, D);
426 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
427 = getPartialSpecializations();
429 PS.reserve(PartialSpecs.size());
431 PS.push_back(
P.getMostRecentDecl());
438 getPartialSpecializations()) {
439 if (Context.
hasSameType(
P.getInjectedSpecializationType(), T))
440 return P.getMostRecentDecl();
451 if (
P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
452 return P.getMostRecentDecl();
460 Common *CommonPtr = getCommonPtr();
489 bool Typename,
bool ParameterPack) {
493 TTPDecl->setTypeForDecl(TTPType.
getTypePtr());
504 return hasDefaultArgument()
505 ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc()
510 if (hasDefaultArgument() && !defaultArgumentWasInherited())
512 getDefaultArgumentInfo()->getTypeLoc().getEndLoc());
533 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
537 :
DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
539 ExpandedParameterPack(
true), NumExpandedTypes(ExpandedTypes.size()) {
540 if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {
542 getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
543 for (
unsigned I = 0; I != NumExpandedTypes; ++I) {
544 new (&TypesAndInfos[I].first)
QualType(ExpandedTypes[I]);
545 TypesAndInfos[I].second = ExpandedTInfos[I];
557 T, ParameterPack, TInfo);
566 additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
567 ExpandedTypes.size()))
569 ExpandedTypes, ExpandedTInfos);
581 unsigned NumExpandedTypes) {
583 new (
C,
ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
588 NTTP->NumExpandedTypes = NumExpandedTypes;
593 if (hasDefaultArgument() && !defaultArgumentWasInherited())
600 return hasDefaultArgument()
601 ? getDefaultArgument()->getSourceRange().getBegin()
609 void TemplateTemplateParmDecl::anchor() {}
611 TemplateTemplateParmDecl::TemplateTemplateParmDecl(
615 :
TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
617 ExpandedParameterPack(
true), NumExpandedParams(Expansions.size()) {
618 if (!Expansions.empty())
619 std::uninitialized_copy(Expansions.begin(), Expansions.end(),
620 getTrailingObjects<TemplateParameterList *>());
639 additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
646 false,
nullptr,
nullptr);
651 unsigned NumExpansions) {
653 new (
C,
ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
656 TTP->NumExpandedParams = NumExpansions;
661 return hasDefaultArgument() ? getDefaultArgument().getLocation()
668 DefaultArgument.set(
nullptr);
677 : Arguments(getTrailingObjects<TemplateArgument>()),
678 NumArguments(Args.size()) {
679 std::uninitialized_copy(Args.begin(), Args.end(),
680 getTrailingObjects<TemplateArgument>());
686 void *Mem = Context.
Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
696 if (TemplateArgsAsWritten)
698 *TemplateArgsAsWritten);
701 C.
Allocate(totalSizeToAlloc<MemberSpecializationInfo *>(MSInfo ? 1 : 0));
703 FD, Template, TSK, TemplateArgs, ArgsAsWritten, POI, MSInfo);
710 void TemplateDecl::anchor() {}
725 SpecializedTemplate(SpecializedTemplate),
746 Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
747 SpecializedTemplate, Args, PrevDecl);
748 Result->setMayHaveOutOfDateDef(
false);
759 Result->setMayHaveOutOfDateDef(
false);
764 raw_ostream &OS,
const PrintingPolicy &Policy,
bool Qualified)
const {
769 PS ? PS->getTemplateArgsAsWritten() :
nullptr) {
779 if (
const auto *PartialSpec =
780 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
781 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
805 auto *ctpsd =
const_cast<CTPSDecl *
>(cast<CTPSDecl>(
this));
807 assert(inst_from !=
nullptr);
808 return inst_from->getSourceRange();
815 if (inst_from.isNull())
817 if (
const auto *ctd = inst_from.dyn_cast<ClassTemplateDecl *>())
818 return ctd->getSourceRange();
830 Expr *ConstraintExpr) {
832 return new (
C, DC)
ConceptDecl(DC, L, Name, Params, ConstraintExpr);
847 void ClassTemplatePartialSpecializationDecl::anchor() {}
849 ClassTemplatePartialSpecializationDecl::
860 ClassTemplatePartialSpecialization,
861 TK, DC, StartLoc, IdLoc,
862 SpecializedTemplate, Args, PrevDecl),
863 TemplateParams(Params), ArgsAsWritten(ArgInfos),
864 InstantiatedFromMember(
nullptr,
false) {
881 auto *
Result =
new (Context, DC)
883 Params, SpecializedTemplate, Args,
884 ASTArgInfos, PrevDecl);
886 Result->setMayHaveOutOfDateDef(
false);
896 Result->setMayHaveOutOfDateDef(
false);
904 void FriendTemplateDecl::anchor() {}
941 auto *CommonPtr =
new (
C)
Common;
950 void ClassScopeFunctionSpecializationDecl::anchor() {}
988 loadLazySpecializationsImpl();
991 llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
993 LoadLazySpecializations();
994 return getCommonPtr()->Specializations;
997 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
999 LoadLazySpecializations();
1000 return getCommonPtr()->PartialSpecializations;
1005 auto *CommonPtr =
new (
C)
Common;
1013 return findSpecializationImpl(getSpecializations(), Args, InsertPos);
1018 addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
1024 return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
1030 getPartialSpecializations().InsertNode(D, InsertPos);
1033 getPartialSpecializations().GetOrInsertNode(D);
1035 assert(Existing->
isCanonicalDecl() &&
"Non-canonical specialization?");
1039 L->AddedCXXTemplateSpecialization(
this, D);
1044 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
1045 getPartialSpecializations();
1047 PS.reserve(PartialSpecs.size());
1049 PS.push_back(
P.getMostRecentDecl());
1057 if (
P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
1058 return P.getMostRecentDecl();
1072 :
VarDecl(DK, Context, DC, StartLoc, IdLoc,
1074 SpecializedTemplate(SpecializedTemplate),
1089 VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,
1090 SpecializedTemplate, T, TInfo, S, Args);
1100 raw_ostream &OS,
const PrintingPolicy &Policy,
bool Qualified)
const {
1105 PS ? PS->getTemplateArgsAsWritten() :
nullptr) {
1114 if (
const auto *PartialSpec =
1115 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1116 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
1132 void VarTemplatePartialSpecializationDecl::anchor() {}
1134 VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(
1141 DC, StartLoc, IdLoc, SpecializedTemplate, T,
1143 TemplateParams(Params), ArgsAsWritten(ArgInfos),
1144 InstantiatedFromMember(
nullptr,
false) {
1161 Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo,
1162 S, Args, ASTArgInfos);
1178 nullptr,
true,
false);
1179 T->setImplicit(
true);
1186 nullptr, TI->
getType(),
true, TI);
1197 false,
nullptr, TPL);
1198 TemplateTemplateParm->setImplicit(
true);
1203 nullptr,
true,
false);
1204 TemplateTypeParm->setImplicit(
true);
1208 QualType(TemplateTypeParm->getTypeForDecl(), 0));
1211 nullptr, TInfo->
getType(),
false, TInfo);
1212 NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,
1213 NonTypeTemplateParm};
1226 nullptr, TInfo->
getType(),
false, TInfo);
1231 nullptr,
true,
true);
1232 Ts->setImplicit(
true);
1237 llvm::makeArrayRef(Params),
1250 llvm_unreachable(
"unhandled BuiltinTemplateKind!");
1253 void BuiltinTemplateDecl::anchor() {}
Defines the clang::ASTContext interface.
void setImplicit(bool I=true)
Represents a function declaration or definition.
A (possibly-)qualified type.
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
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.
ArrayRef< NamedDecl * > asArray()
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.
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)
A container of type source information.
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
void mergePrevDecl(FunctionTemplateDecl *Prev)
Merge Prev with our RedeclarableTemplateDecl::Common.
SourceLocation getEndLoc() const
Get the end source location.
void setRAngleLoc(SourceLocation Loc)
Represents a variable declaration or definition.
ASTMutationListener * getASTMutationListener() const
void LoadLazySpecializations() const
Load any lazily-loaded specializations from the external source.
Declaration of a redeclarable template.
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>".
Stores a list of template parameters for a TemplateDecl and its derived classes.
Describes how types, statements, expressions, and declarations should be printed. ...
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.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
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 ...
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...
Declaration of a function specialization at template class scope.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization. ...
A convenient class for passing around template argument information.
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.
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.
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
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...
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.
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.
This represents one expression.
CommonBase * getCommonPtr() const
Retrieves the "common" pointer shared by all (re-)declarations of the same template.
void setAssociatedConstraints(Expr *AC)
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)
Declaration of a template type parameter.
llvm::PointerUnion< NamedDecl *, TypeSourceInfo * > FriendUnion
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Data that is common to all of the declarations of a given variable template.
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.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack...
Represents a C++ template name within the type system.
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
Defines the clang::TypeLoc interface and its subclasses.
StorageClass
Storage classes.
void addDestruction(T *Ptr) const
If T isn't trivially destructible, calls AddDeallocation to register it for destruction.
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.
The result type of a method or function.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
static StringRef getIdentifier(const Token &Tok)
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
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.
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.
uint32_t * LazySpecializations
If non-null, points to an array of specializations (including partial specializations) known only by ...
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.
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.
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...
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
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)
void addArgument(const TemplateArgumentLoc &Loc)
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
Represents a template argument.
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.
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.
bool isValid() const
Return true if this is a valid SourceLocation object.
static ClassScopeFunctionSpecializationDecl * CreateDeserialized(ASTContext &Context, unsigned ID)
const TemplateArgument & getArgument() const
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...
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.).
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...
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.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
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.
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.
static ClassTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
This template specialization was declared or defined by an explicit specialization (C++ [temp...
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.
static FunctionTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty function template node.
static VarTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
A template argument list.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
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.
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...
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.
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
void loadLazySpecializationsImpl() const
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.
SourceLocation getLAngleLoc() const
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.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Declaration of a friend template.
SourceLocation getRAngleLoc() const
VarTemplateDecl * getDefinition()
SourceRange getSourceRange() const LLVM_READONLY
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.
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>.