diff options
Diffstat (limited to 'lib/AST/DeclTemplate.cpp')
| -rw-r--r-- | lib/AST/DeclTemplate.cpp | 363 |
1 files changed, 189 insertions, 174 deletions
diff --git a/lib/AST/DeclTemplate.cpp b/lib/AST/DeclTemplate.cpp index e69338a..a73deea 100644 --- a/lib/AST/DeclTemplate.cpp +++ b/lib/AST/DeclTemplate.cpp @@ -14,10 +14,13 @@ #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" +#include "clang/AST/ExprCXX.h" #include "clang/AST/ASTContext.h" #include "clang/AST/TypeLoc.h" +#include "clang/AST/ASTMutationListener.h" #include "clang/Basic/IdentifierTable.h" #include "llvm/ADT/STLExtras.h" +#include <memory> using namespace clang; //===----------------------------------------------------------------------===// @@ -35,7 +38,7 @@ TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc, } TemplateParameterList * -TemplateParameterList::Create(ASTContext &C, SourceLocation TemplateLoc, +TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, NamedDecl **Params, unsigned NumParams, SourceLocation RAngleLoc) { unsigned Size = sizeof(TemplateParameterList) @@ -47,24 +50,33 @@ TemplateParameterList::Create(ASTContext &C, SourceLocation TemplateLoc, } unsigned TemplateParameterList::getMinRequiredArguments() const { - unsigned NumRequiredArgs = size(); - iterator Param = const_cast<TemplateParameterList *>(this)->end(), - ParamBegin = const_cast<TemplateParameterList *>(this)->begin(); - while (Param != ParamBegin) { - --Param; - - if (!(*Param)->isTemplateParameterPack() && - !(isa<TemplateTypeParmDecl>(*Param) && - cast<TemplateTypeParmDecl>(*Param)->hasDefaultArgument()) && - !(isa<NonTypeTemplateParmDecl>(*Param) && - cast<NonTypeTemplateParmDecl>(*Param)->hasDefaultArgument()) && - !(isa<TemplateTemplateParmDecl>(*Param) && - cast<TemplateTemplateParmDecl>(*Param)->hasDefaultArgument())) + unsigned NumRequiredArgs = 0; + for (iterator P = const_cast<TemplateParameterList *>(this)->begin(), + PEnd = const_cast<TemplateParameterList *>(this)->end(); + P != PEnd; ++P) { + if ((*P)->isTemplateParameterPack()) { + if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) + if (NTTP->isExpandedParameterPack()) { + NumRequiredArgs += NTTP->getNumExpansionTypes(); + continue; + } + break; - - --NumRequiredArgs; + } + + if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { + if (TTP->hasDefaultArgument()) + break; + } else if (NonTypeTemplateParmDecl *NTTP + = dyn_cast<NonTypeTemplateParmDecl>(*P)) { + if (NTTP->hasDefaultArgument()) + break; + } else if (cast<TemplateTemplateParmDecl>(*P)->hasDefaultArgument()) + break; + + ++NumRequiredArgs; } - + return NumRequiredArgs; } @@ -92,7 +104,7 @@ RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() { RedeclarableTemplateDecl *First = getCanonicalDecl(); if (First->CommonOrPrev.isNull()) { - CommonBase *CommonPtr = First->newCommon(); + CommonBase *CommonPtr = First->newCommon(getASTContext()); First->CommonOrPrev = CommonPtr; CommonPtr->Latest = First; } @@ -156,9 +168,10 @@ FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C, return new (C) FunctionTemplateDecl(DC, L, Name, Params, Decl); } -RedeclarableTemplateDecl::CommonBase *FunctionTemplateDecl::newCommon() { - Common *CommonPtr = new (getASTContext()) Common; - getASTContext().AddDeallocation(DeallocateCommon, CommonPtr); +RedeclarableTemplateDecl::CommonBase * +FunctionTemplateDecl::newCommon(ASTContext &C) { + Common *CommonPtr = new (C) Common; + C.AddDeallocation(DeallocateCommon, CommonPtr); return CommonPtr; } @@ -188,9 +201,33 @@ ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C, return New; } -RedeclarableTemplateDecl::CommonBase *ClassTemplateDecl::newCommon() { - Common *CommonPtr = new (getASTContext()) Common; - getASTContext().AddDeallocation(DeallocateCommon, CommonPtr); +void ClassTemplateDecl::LoadLazySpecializations() { + Common *CommonPtr = getCommonPtr(); + if (CommonPtr->LazySpecializations) { + ASTContext &Context = getASTContext(); + uint32_t *Specs = CommonPtr->LazySpecializations; + CommonPtr->LazySpecializations = 0; + for (uint32_t I = 0, N = *Specs++; I != N; ++I) + (void)Context.getExternalSource()->GetExternalDecl(Specs[I]); + } +} + +llvm::FoldingSet<ClassTemplateSpecializationDecl> & +ClassTemplateDecl::getSpecializations() { + LoadLazySpecializations(); + return getCommonPtr()->Specializations; +} + +llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> & +ClassTemplateDecl::getPartialSpecializations() { + LoadLazySpecializations(); + return getCommonPtr()->PartialSpecializations; +} + +RedeclarableTemplateDecl::CommonBase * +ClassTemplateDecl::newCommon(ASTContext &C) { + Common *CommonPtr = new (C) Common; + C.AddDeallocation(DeallocateCommon, CommonPtr); return CommonPtr; } @@ -200,6 +237,13 @@ ClassTemplateDecl::findSpecialization(const TemplateArgument *Args, return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos); } +void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D, + void *InsertPos) { + getSpecializations().InsertNode(D, InsertPos); + if (ASTMutationListener *L = getASTMutationListener()) + L->AddedCXXTemplateSpecialization(this, D); +} + ClassTemplatePartialSpecializationDecl * ClassTemplateDecl::findPartialSpecialization(const TemplateArgument *Args, unsigned NumArgs, @@ -208,6 +252,14 @@ ClassTemplateDecl::findPartialSpecialization(const TemplateArgument *Args, InsertPos); } +void ClassTemplateDecl::AddPartialSpecialization( + ClassTemplatePartialSpecializationDecl *D, + void *InsertPos) { + getPartialSpecializations().InsertNode(D, InsertPos); + if (ASTMutationListener *L = getASTMutationListener()) + L->AddedCXXTemplateSpecialization(this, D); +} + void ClassTemplateDecl::getPartialSpecializations( llvm::SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) { llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> &PartialSpecs @@ -258,10 +310,13 @@ ClassTemplateDecl::getInjectedClassNameSpecialization() { if (!CommonPtr->InjectedClassNameType.isNull()) return CommonPtr->InjectedClassNameType; - // FIXME: n2800 14.6.1p1 should say how the template arguments - // corresponding to template parameter packs should be pack - // expansions. We already say that in 14.6.2.1p2, so it would be - // better to fix that redundancy. + // C++0x [temp.dep.type]p2: + // The template argument list of a primary template is a template argument + // list in which the nth template argument has the value of the nth template + // parameter of the class template. If the nth template parameter is a + // template parameter pack (14.5.3), the nth template argument is a pack + // expansion (14.5.3) whose pattern is the name of the template parameter + // pack. ASTContext &Context = getASTContext(); TemplateParameterList *Params = getTemplateParameters(); llvm::SmallVector<TemplateArgument, 16> TemplateArgs; @@ -269,19 +324,38 @@ ClassTemplateDecl::getInjectedClassNameSpecialization() { for (TemplateParameterList::iterator Param = Params->begin(), ParamEnd = Params->end(); Param != ParamEnd; ++Param) { - if (isa<TemplateTypeParmDecl>(*Param)) { - QualType ParamType = Context.getTypeDeclType(cast<TypeDecl>(*Param)); - TemplateArgs.push_back(TemplateArgument(ParamType)); + TemplateArgument Arg; + if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) { + QualType ArgType = Context.getTypeDeclType(TTP); + if (TTP->isParameterPack()) + ArgType = Context.getPackExpansionType(ArgType, + llvm::Optional<unsigned>()); + + Arg = TemplateArgument(ArgType); } else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { Expr *E = new (Context) DeclRefExpr(NTTP, NTTP->getType().getNonLValueExprType(Context), + Expr::getValueKindForType(NTTP->getType()), NTTP->getLocation()); - TemplateArgs.push_back(TemplateArgument(E)); + + if (NTTP->isParameterPack()) + E = new (Context) PackExpansionExpr(Context.DependentTy, E, + NTTP->getLocation(), + llvm::Optional<unsigned>()); + Arg = TemplateArgument(E); } else { TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param); - TemplateArgs.push_back(TemplateArgument(TemplateName(TTP))); + if (TTP->isParameterPack()) + Arg = TemplateArgument(TemplateName(TTP), llvm::Optional<unsigned>()); + else + Arg = TemplateArgument(TemplateName(TTP)); } + + if ((*Param)->isTemplateParameterPack()) + Arg = TemplateArgument::CreatePackCopy(Context, &Arg, 1); + + TemplateArgs.push_back(Arg); } CommonPtr->InjectedClassNameType @@ -296,7 +370,7 @@ ClassTemplateDecl::getInjectedClassNameSpecialization() { //===----------------------------------------------------------------------===// TemplateTypeParmDecl * -TemplateTypeParmDecl::Create(ASTContext &C, DeclContext *DC, +TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack) { @@ -305,7 +379,7 @@ TemplateTypeParmDecl::Create(ASTContext &C, DeclContext *DC, } TemplateTypeParmDecl * -TemplateTypeParmDecl::Create(ASTContext &C, EmptyShell Empty) { +TemplateTypeParmDecl::Create(const ASTContext &C, EmptyShell Empty) { return new (C) TemplateTypeParmDecl(0, SourceLocation(), 0, false, QualType(), false); } @@ -326,12 +400,62 @@ unsigned TemplateTypeParmDecl::getIndex() const { // NonTypeTemplateParmDecl Method Implementations //===----------------------------------------------------------------------===// +NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(DeclContext *DC, + SourceLocation L, unsigned D, + unsigned P, IdentifierInfo *Id, + QualType T, + TypeSourceInfo *TInfo, + const QualType *ExpandedTypes, + unsigned NumExpandedTypes, + TypeSourceInfo **ExpandedTInfos) + : DeclaratorDecl(NonTypeTemplateParm, DC, L, Id, T, TInfo), + TemplateParmPosition(D, P), DefaultArgumentAndInherited(0, false), + ParameterPack(true), ExpandedParameterPack(true), + NumExpandedTypes(NumExpandedTypes) +{ + if (ExpandedTypes && ExpandedTInfos) { + void **TypesAndInfos = reinterpret_cast<void **>(this + 1); + for (unsigned I = 0; I != NumExpandedTypes; ++I) { + TypesAndInfos[2*I] = ExpandedTypes[I].getAsOpaquePtr(); + TypesAndInfos[2*I + 1] = ExpandedTInfos[I]; + } + } +} + NonTypeTemplateParmDecl * -NonTypeTemplateParmDecl::Create(ASTContext &C, DeclContext *DC, +NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, IdentifierInfo *Id, QualType T, - TypeSourceInfo *TInfo) { - return new (C) NonTypeTemplateParmDecl(DC, L, D, P, Id, T, TInfo); + bool ParameterPack, TypeSourceInfo *TInfo) { + return new (C) NonTypeTemplateParmDecl(DC, L, D, P, Id, T, ParameterPack, + TInfo); +} + +NonTypeTemplateParmDecl * +NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC, + SourceLocation L, unsigned D, unsigned P, + IdentifierInfo *Id, QualType T, + TypeSourceInfo *TInfo, + const QualType *ExpandedTypes, + unsigned NumExpandedTypes, + TypeSourceInfo **ExpandedTInfos) { + unsigned Size = sizeof(NonTypeTemplateParmDecl) + + NumExpandedTypes * 2 * sizeof(void*); + void *Mem = C.Allocate(Size); + return new (Mem) NonTypeTemplateParmDecl(DC, L, D, P, Id, T, TInfo, + ExpandedTypes, NumExpandedTypes, + ExpandedTInfos); +} + +SourceLocation NonTypeTemplateParmDecl::getInnerLocStart() const { + SourceLocation Start = getTypeSpecStartLoc(); + if (Start.isInvalid()) + Start = getLocation(); + return Start; +} + +SourceRange NonTypeTemplateParmDecl::getSourceRange() const { + return SourceRange(getOuterLocStart(), getLocation()); } SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const { @@ -345,128 +469,29 @@ SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const { //===----------------------------------------------------------------------===// TemplateTemplateParmDecl * -TemplateTemplateParmDecl::Create(ASTContext &C, DeclContext *DC, +TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, - IdentifierInfo *Id, + bool ParameterPack, IdentifierInfo *Id, TemplateParameterList *Params) { - return new (C) TemplateTemplateParmDecl(DC, L, D, P, Id, Params); -} - -//===----------------------------------------------------------------------===// -// TemplateArgumentListBuilder Implementation -//===----------------------------------------------------------------------===// - -void TemplateArgumentListBuilder::Append(const TemplateArgument &Arg) { - assert((Arg.getKind() != TemplateArgument::Type || - Arg.getAsType().isCanonical()) && "Type must be canonical!"); - assert(FlatArgs.size() < MaxFlatArgs && "Argument list builder is full!"); - assert(!StructuredArgs && - "Can't append arguments when an argument pack has been added!"); - - FlatArgs.push_back(Arg); -} - -void TemplateArgumentListBuilder::BeginPack() { - assert(!AddingToPack && "Already adding to pack!"); - assert(!StructuredArgs && "Argument list already contains a pack!"); - - AddingToPack = true; - PackBeginIndex = FlatArgs.size(); -} - -void TemplateArgumentListBuilder::EndPack() { - assert(AddingToPack && "Not adding to pack!"); - assert(!StructuredArgs && "Argument list already contains a pack!"); - - AddingToPack = false; - - // FIXME: This is a memory leak! - StructuredArgs = new TemplateArgument[MaxStructuredArgs]; - - // First copy the flat entries over to the list (if any) - for (unsigned I = 0; I != PackBeginIndex; ++I) { - NumStructuredArgs++; - StructuredArgs[I] = FlatArgs[I]; - } - - // Next, set the pack. - TemplateArgument *PackArgs = 0; - unsigned NumPackArgs = NumFlatArgs - PackBeginIndex; - // FIXME: NumPackArgs shouldn't be negative here??? - if (NumPackArgs) - PackArgs = FlatArgs.data()+PackBeginIndex; - - StructuredArgs[NumStructuredArgs++].setArgumentPack(PackArgs, NumPackArgs, - /*CopyArgs=*/false); + return new (C) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id, + Params); } //===----------------------------------------------------------------------===// // TemplateArgumentList Implementation //===----------------------------------------------------------------------===// -TemplateArgumentList::TemplateArgumentList(ASTContext &Context, - TemplateArgumentListBuilder &Builder, - bool TakeArgs) - : FlatArguments(Builder.getFlatArguments(), TakeArgs), - NumFlatArguments(Builder.flatSize()), - StructuredArguments(Builder.getStructuredArguments(), TakeArgs), - NumStructuredArguments(Builder.structuredSize()) { - - if (!TakeArgs) - return; - - // If this does take ownership of the arguments, then we have to new them - // and copy over. - TemplateArgument *NewArgs = - new (Context) TemplateArgument[Builder.flatSize()]; - std::copy(Builder.getFlatArguments(), - Builder.getFlatArguments()+Builder.flatSize(), NewArgs); - FlatArguments.setPointer(NewArgs); - - // Just reuse the structured and flat arguments array if possible. - if (Builder.getStructuredArguments() == Builder.getFlatArguments()) { - StructuredArguments.setPointer(NewArgs); - StructuredArguments.setInt(0); - } else { - TemplateArgument *NewSArgs = - new (Context) TemplateArgument[Builder.flatSize()]; - std::copy(Builder.getFlatArguments(), - Builder.getFlatArguments()+Builder.flatSize(), NewSArgs); - StructuredArguments.setPointer(NewSArgs); - } -} - -TemplateArgumentList::TemplateArgumentList(ASTContext &Context, - const TemplateArgument *Args, - unsigned NumArgs) - : NumFlatArguments(0), NumStructuredArguments(0) { - init(Context, Args, NumArgs); -} - -/// Produces a shallow copy of the given template argument list. This -/// assumes that the input argument list outlives it. This takes the list as -/// a pointer to avoid looking like a copy constructor, since this really -/// really isn't safe to use that way. -TemplateArgumentList::TemplateArgumentList(const TemplateArgumentList *Other) - : FlatArguments(Other->FlatArguments.getPointer(), false), - NumFlatArguments(Other->flat_size()), - StructuredArguments(Other->StructuredArguments.getPointer(), false), - NumStructuredArguments(Other->NumStructuredArguments) { } - -void TemplateArgumentList::init(ASTContext &Context, - const TemplateArgument *Args, - unsigned NumArgs) { -assert(NumFlatArguments == 0 && NumStructuredArguments == 0 && - "Already initialized!"); - -NumFlatArguments = NumStructuredArguments = NumArgs; -TemplateArgument *NewArgs = new (Context) TemplateArgument[NumArgs]; -std::copy(Args, Args+NumArgs, NewArgs); -FlatArguments.setPointer(NewArgs); -FlatArguments.setInt(1); // Owns the pointer. - -// Just reuse the flat arguments array. -StructuredArguments.setPointer(NewArgs); -StructuredArguments.setInt(0); // Doesn't own the pointer. +TemplateArgumentList * +TemplateArgumentList::CreateCopy(ASTContext &Context, + const TemplateArgument *Args, + unsigned NumArgs) { + std::size_t Size = sizeof(TemplateArgumentList) + + NumArgs * sizeof(TemplateArgument); + void *Mem = Context.Allocate(Size); + TemplateArgument *StoredArgs + = reinterpret_cast<TemplateArgument *>( + static_cast<TemplateArgumentList *>(Mem) + 1); + std::uninitialized_copy(Args, Args + NumArgs, StoredArgs); + return new (Mem) TemplateArgumentList(StoredArgs, NumArgs, true); } //===----------------------------------------------------------------------===// @@ -476,14 +501,15 @@ ClassTemplateSpecializationDecl:: ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK, DeclContext *DC, SourceLocation L, ClassTemplateDecl *SpecializedTemplate, - TemplateArgumentListBuilder &Builder, + const TemplateArgument *Args, + unsigned NumArgs, ClassTemplateSpecializationDecl *PrevDecl) : CXXRecordDecl(DK, TK, DC, L, SpecializedTemplate->getIdentifier(), PrevDecl), SpecializedTemplate(SpecializedTemplate), ExplicitInfo(0), - TemplateArgs(Context, Builder, /*TakeArgs=*/true), + TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args, NumArgs)), SpecializationKind(TSK_Undeclared) { } @@ -497,14 +523,15 @@ ClassTemplateSpecializationDecl * ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation L, ClassTemplateDecl *SpecializedTemplate, - TemplateArgumentListBuilder &Builder, + const TemplateArgument *Args, + unsigned NumArgs, ClassTemplateSpecializationDecl *PrevDecl) { ClassTemplateSpecializationDecl *Result = new (Context)ClassTemplateSpecializationDecl(Context, ClassTemplateSpecialization, TK, DC, L, SpecializedTemplate, - Builder, + Args, NumArgs, PrevDecl); Context.getTypeDeclType(Result, PrevDecl); return Result; @@ -524,8 +551,8 @@ ClassTemplateSpecializationDecl::getNameForDiagnostic(std::string &S, const TemplateArgumentList &TemplateArgs = getTemplateArgs(); S += TemplateSpecializationType::PrintTemplateArgumentList( - TemplateArgs.getFlatArgumentList(), - TemplateArgs.flat_size(), + TemplateArgs.data(), + TemplateArgs.size(), Policy); } @@ -545,7 +572,8 @@ ClassTemplatePartialSpecializationDecl:: Create(ASTContext &Context, TagKind TK,DeclContext *DC, SourceLocation L, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, - TemplateArgumentListBuilder &Builder, + const TemplateArgument *Args, + unsigned NumArgs, const TemplateArgumentListInfo &ArgInfos, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl, @@ -559,7 +587,7 @@ Create(ASTContext &Context, TagKind TK,DeclContext *DC, SourceLocation L, = new (Context)ClassTemplatePartialSpecializationDecl(Context, TK, DC, L, Params, SpecializedTemplate, - Builder, + Args, NumArgs, ClonedArgs, N, PrevDecl, SequenceNumber); @@ -575,19 +603,6 @@ ClassTemplatePartialSpecializationDecl::Create(ASTContext &Context, return new (Context)ClassTemplatePartialSpecializationDecl(); } -void ClassTemplatePartialSpecializationDecl:: -initTemplateArgsAsWritten(const TemplateArgumentListInfo &ArgInfos) { - assert(ArgsAsWritten == 0 && "ArgsAsWritten already set"); - unsigned N = ArgInfos.size(); - TemplateArgumentLoc *ClonedArgs - = new (getASTContext()) TemplateArgumentLoc[N]; - for (unsigned I = 0; I != N; ++I) - ClonedArgs[I] = ArgInfos[I]; - - ArgsAsWritten = ClonedArgs; - NumArgsAsWritten = N; -} - //===----------------------------------------------------------------------===// // FriendTemplateDecl Implementation //===----------------------------------------------------------------------===// |
