TemplateBase.cpp revision 226633
1198893Srdivacky//===--- TemplateBase.cpp - Common template AST class implementation ------===// 2198893Srdivacky// 3198893Srdivacky// The LLVM Compiler Infrastructure 4198893Srdivacky// 5198893Srdivacky// This file is distributed under the University of Illinois Open Source 6198893Srdivacky// License. See LICENSE.TXT for details. 7198893Srdivacky// 8198893Srdivacky//===----------------------------------------------------------------------===// 9198893Srdivacky// 10198893Srdivacky// This file implements common classes used throughout C++ template 11198893Srdivacky// representations. 12198893Srdivacky// 13198893Srdivacky//===----------------------------------------------------------------------===// 14198893Srdivacky 15198893Srdivacky#include "clang/AST/TemplateBase.h" 16218893Sdim#include "clang/AST/ASTContext.h" 17198893Srdivacky#include "clang/AST/DeclBase.h" 18199990Srdivacky#include "clang/AST/DeclTemplate.h" 19198893Srdivacky#include "clang/AST/Expr.h" 20218893Sdim#include "clang/AST/ExprCXX.h" 21218893Sdim#include "clang/AST/Type.h" 22198893Srdivacky#include "clang/AST/TypeLoc.h" 23208600Srdivacky#include "clang/Basic/Diagnostic.h" 24218893Sdim#include "llvm/ADT/FoldingSet.h" 25218893Sdim#include <algorithm> 26218893Sdim#include <cctype> 27198893Srdivacky 28198893Srdivackyusing namespace clang; 29198893Srdivacky 30218893Sdim/// \brief Print a template integral argument value. 31218893Sdim/// 32218893Sdim/// \param TemplArg the TemplateArgument instance to print. 33218893Sdim/// 34218893Sdim/// \param Out the raw_ostream instance to use for printing. 35218893Sdimstatic void printIntegral(const TemplateArgument &TemplArg, 36226633Sdim raw_ostream &Out) { 37218893Sdim const ::clang::Type *T = TemplArg.getIntegralType().getTypePtr(); 38218893Sdim const llvm::APSInt *Val = TemplArg.getAsIntegral(); 39218893Sdim 40218893Sdim if (T->isBooleanType()) { 41218893Sdim Out << (Val->getBoolValue() ? "true" : "false"); 42218893Sdim } else if (T->isCharType()) { 43219077Sdim const unsigned char Ch = Val->getZExtValue(); 44219077Sdim const std::string Str(1, Ch); 45219077Sdim Out << ((Ch == '\'') ? "'\\" : "'"); 46219077Sdim Out.write_escaped(Str, /*UseHexEscapes=*/ true); 47219077Sdim Out << "'"; 48218893Sdim } else { 49218893Sdim Out << Val->toString(10); 50218893Sdim } 51218893Sdim} 52218893Sdim 53198893Srdivacky//===----------------------------------------------------------------------===// 54198893Srdivacky// TemplateArgument Implementation 55198893Srdivacky//===----------------------------------------------------------------------===// 56198893Srdivacky 57218893SdimTemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context, 58218893Sdim const TemplateArgument *Args, 59218893Sdim unsigned NumArgs) { 60218893Sdim if (NumArgs == 0) 61218893Sdim return TemplateArgument(0, 0); 62218893Sdim 63218893Sdim TemplateArgument *Storage = new (Context) TemplateArgument [NumArgs]; 64218893Sdim std::copy(Args, Args + NumArgs, Storage); 65218893Sdim return TemplateArgument(Storage, NumArgs); 66218893Sdim} 67198893Srdivacky 68218893Sdimbool TemplateArgument::isDependent() const { 69218893Sdim switch (getKind()) { 70218893Sdim case Null: 71226633Sdim llvm_unreachable("Should not have a NULL template argument"); 72218893Sdim 73218893Sdim case Type: 74218893Sdim return getAsType()->isDependentType(); 75218893Sdim 76218893Sdim case Template: 77218893Sdim return getAsTemplate().isDependent(); 78218893Sdim 79218893Sdim case TemplateExpansion: 80218893Sdim return true; 81218893Sdim 82218893Sdim case Declaration: 83218893Sdim if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl())) 84218893Sdim return DC->isDependentContext(); 85218893Sdim return getAsDecl()->getDeclContext()->isDependentContext(); 86218893Sdim 87218893Sdim case Integral: 88218893Sdim // Never dependent 89218893Sdim return false; 90218893Sdim 91218893Sdim case Expression: 92218893Sdim return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent()); 93218893Sdim 94218893Sdim case Pack: 95218893Sdim for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) { 96218893Sdim if (P->isDependent()) 97218893Sdim return true; 98218893Sdim } 99218893Sdim 100218893Sdim return false; 101198893Srdivacky } 102198893Srdivacky 103218893Sdim return false; 104198893Srdivacky} 105198893Srdivacky 106224145Sdimbool TemplateArgument::isInstantiationDependent() const { 107224145Sdim switch (getKind()) { 108224145Sdim case Null: 109226633Sdim llvm_unreachable("Should not have a NULL template argument"); 110224145Sdim 111224145Sdim case Type: 112224145Sdim return getAsType()->isInstantiationDependentType(); 113224145Sdim 114224145Sdim case Template: 115224145Sdim return getAsTemplate().isInstantiationDependent(); 116224145Sdim 117224145Sdim case TemplateExpansion: 118224145Sdim return true; 119224145Sdim 120224145Sdim case Declaration: 121224145Sdim if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl())) 122224145Sdim return DC->isDependentContext(); 123224145Sdim return getAsDecl()->getDeclContext()->isDependentContext(); 124224145Sdim 125224145Sdim case Integral: 126224145Sdim // Never dependent 127224145Sdim return false; 128224145Sdim 129224145Sdim case Expression: 130224145Sdim return getAsExpr()->isInstantiationDependent(); 131224145Sdim 132224145Sdim case Pack: 133224145Sdim for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) { 134224145Sdim if (P->isInstantiationDependent()) 135224145Sdim return true; 136224145Sdim } 137224145Sdim 138224145Sdim return false; 139224145Sdim } 140224145Sdim 141224145Sdim return false; 142224145Sdim} 143224145Sdim 144218893Sdimbool TemplateArgument::isPackExpansion() const { 145218893Sdim switch (getKind()) { 146218893Sdim case Null: 147218893Sdim case Declaration: 148218893Sdim case Integral: 149218893Sdim case Pack: 150218893Sdim case Template: 151218893Sdim return false; 152218893Sdim 153218893Sdim case TemplateExpansion: 154218893Sdim return true; 155218893Sdim 156218893Sdim case Type: 157218893Sdim return isa<PackExpansionType>(getAsType()); 158218893Sdim 159218893Sdim case Expression: 160218893Sdim return isa<PackExpansionExpr>(getAsExpr()); 161218893Sdim } 162218893Sdim 163218893Sdim return false; 164218893Sdim} 165218893Sdim 166218893Sdimbool TemplateArgument::containsUnexpandedParameterPack() const { 167218893Sdim switch (getKind()) { 168218893Sdim case Null: 169218893Sdim case Declaration: 170218893Sdim case Integral: 171218893Sdim case TemplateExpansion: 172218893Sdim break; 173218893Sdim 174218893Sdim case Type: 175218893Sdim if (getAsType()->containsUnexpandedParameterPack()) 176218893Sdim return true; 177218893Sdim break; 178218893Sdim 179218893Sdim case Template: 180218893Sdim if (getAsTemplate().containsUnexpandedParameterPack()) 181218893Sdim return true; 182218893Sdim break; 183218893Sdim 184218893Sdim case Expression: 185218893Sdim if (getAsExpr()->containsUnexpandedParameterPack()) 186218893Sdim return true; 187218893Sdim break; 188218893Sdim 189218893Sdim case Pack: 190218893Sdim for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) 191218893Sdim if (P->containsUnexpandedParameterPack()) 192218893Sdim return true; 193218893Sdim 194218893Sdim break; 195218893Sdim } 196218893Sdim 197218893Sdim return false; 198218893Sdim} 199218893Sdim 200218893Sdimllvm::Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const { 201218893Sdim assert(Kind == TemplateExpansion); 202218893Sdim if (TemplateArg.NumExpansions) 203218893Sdim return TemplateArg.NumExpansions - 1; 204218893Sdim 205218893Sdim return llvm::Optional<unsigned>(); 206218893Sdim} 207218893Sdim 208198893Srdivackyvoid TemplateArgument::Profile(llvm::FoldingSetNodeID &ID, 209218893Sdim const ASTContext &Context) const { 210198893Srdivacky ID.AddInteger(Kind); 211198893Srdivacky switch (Kind) { 212198893Srdivacky case Null: 213198893Srdivacky break; 214198893Srdivacky 215198893Srdivacky case Type: 216198893Srdivacky getAsType().Profile(ID); 217198893Srdivacky break; 218198893Srdivacky 219198893Srdivacky case Declaration: 220198893Srdivacky ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : 0); 221198893Srdivacky break; 222198893Srdivacky 223199482Srdivacky case Template: 224218893Sdim case TemplateExpansion: { 225218893Sdim TemplateName Template = getAsTemplateOrTemplatePattern(); 226199990Srdivacky if (TemplateTemplateParmDecl *TTP 227199990Srdivacky = dyn_cast_or_null<TemplateTemplateParmDecl>( 228218893Sdim Template.getAsTemplateDecl())) { 229199990Srdivacky ID.AddBoolean(true); 230199990Srdivacky ID.AddInteger(TTP->getDepth()); 231199990Srdivacky ID.AddInteger(TTP->getPosition()); 232218893Sdim ID.AddBoolean(TTP->isParameterPack()); 233199990Srdivacky } else { 234199990Srdivacky ID.AddBoolean(false); 235218893Sdim ID.AddPointer(Context.getCanonicalTemplateName(Template) 236218893Sdim .getAsVoidPointer()); 237199990Srdivacky } 238199482Srdivacky break; 239218893Sdim } 240199482Srdivacky 241198893Srdivacky case Integral: 242198893Srdivacky getAsIntegral()->Profile(ID); 243198893Srdivacky getIntegralType().Profile(ID); 244198893Srdivacky break; 245198893Srdivacky 246198893Srdivacky case Expression: 247198893Srdivacky getAsExpr()->Profile(ID, Context, true); 248198893Srdivacky break; 249198893Srdivacky 250198893Srdivacky case Pack: 251198893Srdivacky ID.AddInteger(Args.NumArgs); 252198893Srdivacky for (unsigned I = 0; I != Args.NumArgs; ++I) 253198893Srdivacky Args.Args[I].Profile(ID, Context); 254198893Srdivacky } 255198893Srdivacky} 256198893Srdivacky 257210299Sedbool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const { 258210299Sed if (getKind() != Other.getKind()) return false; 259210299Sed 260210299Sed switch (getKind()) { 261210299Sed case Null: 262210299Sed case Type: 263210299Sed case Declaration: 264218893Sdim case Expression: 265210299Sed case Template: 266218893Sdim case TemplateExpansion: 267210299Sed return TypeOrValue == Other.TypeOrValue; 268210299Sed 269210299Sed case Integral: 270210299Sed return getIntegralType() == Other.getIntegralType() && 271210299Sed *getAsIntegral() == *Other.getAsIntegral(); 272210299Sed 273210299Sed case Pack: 274210299Sed if (Args.NumArgs != Other.Args.NumArgs) return false; 275210299Sed for (unsigned I = 0, E = Args.NumArgs; I != E; ++I) 276210299Sed if (!Args.Args[I].structurallyEquals(Other.Args.Args[I])) 277210299Sed return false; 278210299Sed return true; 279210299Sed } 280210299Sed 281210299Sed // Suppress warnings. 282210299Sed return false; 283210299Sed} 284210299Sed 285218893SdimTemplateArgument TemplateArgument::getPackExpansionPattern() const { 286218893Sdim assert(isPackExpansion()); 287218893Sdim 288218893Sdim switch (getKind()) { 289218893Sdim case Type: 290218893Sdim return getAsType()->getAs<PackExpansionType>()->getPattern(); 291218893Sdim 292218893Sdim case Expression: 293218893Sdim return cast<PackExpansionExpr>(getAsExpr())->getPattern(); 294218893Sdim 295218893Sdim case TemplateExpansion: 296218893Sdim return TemplateArgument(getAsTemplateOrTemplatePattern()); 297218893Sdim 298218893Sdim case Declaration: 299218893Sdim case Integral: 300218893Sdim case Pack: 301218893Sdim case Null: 302218893Sdim case Template: 303218893Sdim return TemplateArgument(); 304218893Sdim } 305218893Sdim 306218893Sdim return TemplateArgument(); 307218893Sdim} 308218893Sdim 309218893Sdimvoid TemplateArgument::print(const PrintingPolicy &Policy, 310226633Sdim raw_ostream &Out) const { 311218893Sdim switch (getKind()) { 312218893Sdim case Null: 313218893Sdim Out << "<no value>"; 314218893Sdim break; 315218893Sdim 316218893Sdim case Type: { 317224145Sdim PrintingPolicy SubPolicy(Policy); 318224145Sdim SubPolicy.SuppressStrongLifetime = true; 319218893Sdim std::string TypeStr; 320224145Sdim getAsType().getAsStringInternal(TypeStr, SubPolicy); 321218893Sdim Out << TypeStr; 322218893Sdim break; 323218893Sdim } 324218893Sdim 325218893Sdim case Declaration: { 326218893Sdim bool Unnamed = true; 327218893Sdim if (NamedDecl *ND = dyn_cast_or_null<NamedDecl>(getAsDecl())) { 328218893Sdim if (ND->getDeclName()) { 329218893Sdim Unnamed = false; 330218893Sdim Out << ND->getNameAsString(); 331218893Sdim } 332218893Sdim } 333218893Sdim 334218893Sdim if (Unnamed) { 335218893Sdim Out << "<anonymous>"; 336218893Sdim } 337218893Sdim break; 338218893Sdim } 339218893Sdim 340218893Sdim case Template: 341218893Sdim getAsTemplate().print(Out, Policy); 342218893Sdim break; 343218893Sdim 344218893Sdim case TemplateExpansion: 345218893Sdim getAsTemplateOrTemplatePattern().print(Out, Policy); 346218893Sdim Out << "..."; 347218893Sdim break; 348218893Sdim 349218893Sdim case Integral: { 350218893Sdim printIntegral(*this, Out); 351218893Sdim break; 352218893Sdim } 353218893Sdim 354218893Sdim case Expression: 355218893Sdim getAsExpr()->printPretty(Out, 0, Policy); 356218893Sdim break; 357218893Sdim 358218893Sdim case Pack: 359218893Sdim Out << "<"; 360218893Sdim bool First = true; 361218893Sdim for (TemplateArgument::pack_iterator P = pack_begin(), PEnd = pack_end(); 362218893Sdim P != PEnd; ++P) { 363218893Sdim if (First) 364218893Sdim First = false; 365218893Sdim else 366218893Sdim Out << ", "; 367218893Sdim 368218893Sdim P->print(Policy, Out); 369218893Sdim } 370218893Sdim Out << ">"; 371218893Sdim break; 372218893Sdim } 373218893Sdim} 374218893Sdim 375198893Srdivacky//===----------------------------------------------------------------------===// 376198893Srdivacky// TemplateArgumentLoc Implementation 377198893Srdivacky//===----------------------------------------------------------------------===// 378198893Srdivacky 379218893SdimTemplateArgumentLocInfo::TemplateArgumentLocInfo() { 380221345Sdim memset((void*)this, 0, sizeof(TemplateArgumentLocInfo)); 381218893Sdim} 382218893Sdim 383198893SrdivackySourceRange TemplateArgumentLoc::getSourceRange() const { 384198893Srdivacky switch (Argument.getKind()) { 385198893Srdivacky case TemplateArgument::Expression: 386198893Srdivacky return getSourceExpression()->getSourceRange(); 387212904Sdim 388198893Srdivacky case TemplateArgument::Declaration: 389198893Srdivacky return getSourceDeclExpression()->getSourceRange(); 390212904Sdim 391198893Srdivacky case TemplateArgument::Type: 392212904Sdim if (TypeSourceInfo *TSI = getTypeSourceInfo()) 393212904Sdim return TSI->getTypeLoc().getSourceRange(); 394212904Sdim else 395212904Sdim return SourceRange(); 396212904Sdim 397199482Srdivacky case TemplateArgument::Template: 398221345Sdim if (getTemplateQualifierLoc()) 399221345Sdim return SourceRange(getTemplateQualifierLoc().getBeginLoc(), 400199482Srdivacky getTemplateNameLoc()); 401199482Srdivacky return SourceRange(getTemplateNameLoc()); 402212904Sdim 403218893Sdim case TemplateArgument::TemplateExpansion: 404221345Sdim if (getTemplateQualifierLoc()) 405221345Sdim return SourceRange(getTemplateQualifierLoc().getBeginLoc(), 406218893Sdim getTemplateEllipsisLoc()); 407218893Sdim return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc()); 408218893Sdim 409198893Srdivacky case TemplateArgument::Integral: 410198893Srdivacky case TemplateArgument::Pack: 411198893Srdivacky case TemplateArgument::Null: 412198893Srdivacky return SourceRange(); 413198893Srdivacky } 414198893Srdivacky 415198893Srdivacky // Silence bonus gcc warning. 416198893Srdivacky return SourceRange(); 417198893Srdivacky} 418208600Srdivacky 419218893SdimTemplateArgumentLoc 420218893SdimTemplateArgumentLoc::getPackExpansionPattern(SourceLocation &Ellipsis, 421218893Sdim llvm::Optional<unsigned> &NumExpansions, 422218893Sdim ASTContext &Context) const { 423218893Sdim assert(Argument.isPackExpansion()); 424218893Sdim 425218893Sdim switch (Argument.getKind()) { 426218893Sdim case TemplateArgument::Type: { 427218893Sdim // FIXME: We shouldn't ever have to worry about missing 428218893Sdim // type-source info! 429218893Sdim TypeSourceInfo *ExpansionTSInfo = getTypeSourceInfo(); 430218893Sdim if (!ExpansionTSInfo) 431218893Sdim ExpansionTSInfo = Context.getTrivialTypeSourceInfo( 432218893Sdim getArgument().getAsType(), 433218893Sdim Ellipsis); 434218893Sdim PackExpansionTypeLoc Expansion 435218893Sdim = cast<PackExpansionTypeLoc>(ExpansionTSInfo->getTypeLoc()); 436218893Sdim Ellipsis = Expansion.getEllipsisLoc(); 437218893Sdim 438218893Sdim TypeLoc Pattern = Expansion.getPatternLoc(); 439218893Sdim NumExpansions = Expansion.getTypePtr()->getNumExpansions(); 440218893Sdim 441218893Sdim // FIXME: This is horrible. We know where the source location data is for 442218893Sdim // the pattern, and we have the pattern's type, but we are forced to copy 443218893Sdim // them into an ASTContext because TypeSourceInfo bundles them together 444218893Sdim // and TemplateArgumentLoc traffics in TypeSourceInfo pointers. 445218893Sdim TypeSourceInfo *PatternTSInfo 446218893Sdim = Context.CreateTypeSourceInfo(Pattern.getType(), 447218893Sdim Pattern.getFullDataSize()); 448218893Sdim memcpy(PatternTSInfo->getTypeLoc().getOpaqueData(), 449218893Sdim Pattern.getOpaqueData(), Pattern.getFullDataSize()); 450218893Sdim return TemplateArgumentLoc(TemplateArgument(Pattern.getType()), 451218893Sdim PatternTSInfo); 452218893Sdim } 453218893Sdim 454218893Sdim case TemplateArgument::Expression: { 455218893Sdim PackExpansionExpr *Expansion 456218893Sdim = cast<PackExpansionExpr>(Argument.getAsExpr()); 457218893Sdim Expr *Pattern = Expansion->getPattern(); 458218893Sdim Ellipsis = Expansion->getEllipsisLoc(); 459218893Sdim NumExpansions = Expansion->getNumExpansions(); 460218893Sdim return TemplateArgumentLoc(Pattern, Pattern); 461218893Sdim } 462218893Sdim 463218893Sdim case TemplateArgument::TemplateExpansion: 464218893Sdim Ellipsis = getTemplateEllipsisLoc(); 465218893Sdim NumExpansions = Argument.getNumTemplateExpansions(); 466218893Sdim return TemplateArgumentLoc(Argument.getPackExpansionPattern(), 467221345Sdim getTemplateQualifierLoc(), 468218893Sdim getTemplateNameLoc()); 469218893Sdim 470218893Sdim case TemplateArgument::Declaration: 471218893Sdim case TemplateArgument::Template: 472218893Sdim case TemplateArgument::Integral: 473218893Sdim case TemplateArgument::Pack: 474218893Sdim case TemplateArgument::Null: 475218893Sdim return TemplateArgumentLoc(); 476218893Sdim } 477218893Sdim 478218893Sdim return TemplateArgumentLoc(); 479218893Sdim} 480218893Sdim 481208600Srdivackyconst DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB, 482208600Srdivacky const TemplateArgument &Arg) { 483208600Srdivacky switch (Arg.getKind()) { 484208600Srdivacky case TemplateArgument::Null: 485212904Sdim // This is bad, but not as bad as crashing because of argument 486212904Sdim // count mismatches. 487212904Sdim return DB << "(null template argument)"; 488208600Srdivacky 489208600Srdivacky case TemplateArgument::Type: 490208600Srdivacky return DB << Arg.getAsType(); 491208600Srdivacky 492208600Srdivacky case TemplateArgument::Declaration: 493208600Srdivacky return DB << Arg.getAsDecl(); 494208600Srdivacky 495208600Srdivacky case TemplateArgument::Integral: 496208600Srdivacky return DB << Arg.getAsIntegral()->toString(10); 497208600Srdivacky 498208600Srdivacky case TemplateArgument::Template: 499208600Srdivacky return DB << Arg.getAsTemplate(); 500218893Sdim 501218893Sdim case TemplateArgument::TemplateExpansion: 502218893Sdim return DB << Arg.getAsTemplateOrTemplatePattern() << "..."; 503218893Sdim 504208600Srdivacky case TemplateArgument::Expression: { 505208600Srdivacky // This shouldn't actually ever happen, so it's okay that we're 506208600Srdivacky // regurgitating an expression here. 507208600Srdivacky // FIXME: We're guessing at LangOptions! 508208600Srdivacky llvm::SmallString<32> Str; 509208600Srdivacky llvm::raw_svector_ostream OS(Str); 510208600Srdivacky LangOptions LangOpts; 511208600Srdivacky LangOpts.CPlusPlus = true; 512208600Srdivacky PrintingPolicy Policy(LangOpts); 513208600Srdivacky Arg.getAsExpr()->printPretty(OS, 0, Policy); 514208600Srdivacky return DB << OS.str(); 515208600Srdivacky } 516208600Srdivacky 517218893Sdim case TemplateArgument::Pack: { 518218893Sdim // FIXME: We're guessing at LangOptions! 519218893Sdim llvm::SmallString<32> Str; 520218893Sdim llvm::raw_svector_ostream OS(Str); 521218893Sdim LangOptions LangOpts; 522218893Sdim LangOpts.CPlusPlus = true; 523218893Sdim PrintingPolicy Policy(LangOpts); 524218893Sdim Arg.print(Policy, OS); 525218893Sdim return DB << OS.str(); 526208600Srdivacky } 527218893Sdim } 528208600Srdivacky 529208600Srdivacky return DB; 530208600Srdivacky} 531226633Sdim 532226633Sdimconst ASTTemplateArgumentListInfo * 533226633SdimASTTemplateArgumentListInfo::Create(ASTContext &C, 534226633Sdim const TemplateArgumentListInfo &List) { 535226633Sdim std::size_t size = sizeof(CXXDependentScopeMemberExpr) + 536226633Sdim ASTTemplateArgumentListInfo::sizeFor(List); 537226633Sdim void *Mem = C.Allocate(size, llvm::alignOf<ASTTemplateArgumentListInfo>()); 538226633Sdim ASTTemplateArgumentListInfo *TAI = new (Mem) ASTTemplateArgumentListInfo(); 539226633Sdim TAI->initializeFrom(List); 540226633Sdim return TAI; 541226633Sdim} 542226633Sdim 543226633Sdimvoid ASTTemplateArgumentListInfo::initializeFrom( 544226633Sdim const TemplateArgumentListInfo &Info) { 545226633Sdim LAngleLoc = Info.getLAngleLoc(); 546226633Sdim RAngleLoc = Info.getRAngleLoc(); 547226633Sdim NumTemplateArgs = Info.size(); 548226633Sdim 549226633Sdim TemplateArgumentLoc *ArgBuffer = getTemplateArgs(); 550226633Sdim for (unsigned i = 0; i != NumTemplateArgs; ++i) 551226633Sdim new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]); 552226633Sdim} 553226633Sdim 554226633Sdimvoid ASTTemplateArgumentListInfo::initializeFrom( 555226633Sdim const TemplateArgumentListInfo &Info, 556226633Sdim bool &Dependent, 557226633Sdim bool &InstantiationDependent, 558226633Sdim bool &ContainsUnexpandedParameterPack) { 559226633Sdim LAngleLoc = Info.getLAngleLoc(); 560226633Sdim RAngleLoc = Info.getRAngleLoc(); 561226633Sdim NumTemplateArgs = Info.size(); 562226633Sdim 563226633Sdim TemplateArgumentLoc *ArgBuffer = getTemplateArgs(); 564226633Sdim for (unsigned i = 0; i != NumTemplateArgs; ++i) { 565226633Sdim Dependent = Dependent || Info[i].getArgument().isDependent(); 566226633Sdim InstantiationDependent = InstantiationDependent || 567226633Sdim Info[i].getArgument().isInstantiationDependent(); 568226633Sdim ContainsUnexpandedParameterPack 569226633Sdim = ContainsUnexpandedParameterPack || 570226633Sdim Info[i].getArgument().containsUnexpandedParameterPack(); 571226633Sdim 572226633Sdim new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]); 573226633Sdim } 574226633Sdim} 575226633Sdim 576226633Sdimvoid ASTTemplateArgumentListInfo::copyInto( 577226633Sdim TemplateArgumentListInfo &Info) const { 578226633Sdim Info.setLAngleLoc(LAngleLoc); 579226633Sdim Info.setRAngleLoc(RAngleLoc); 580226633Sdim for (unsigned I = 0; I != NumTemplateArgs; ++I) 581226633Sdim Info.addArgument(getTemplateArgs()[I]); 582226633Sdim} 583226633Sdim 584226633Sdimstd::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) { 585226633Sdim return sizeof(ASTTemplateArgumentListInfo) + 586226633Sdim sizeof(TemplateArgumentLoc) * NumTemplateArgs; 587226633Sdim} 588226633Sdim 589226633Sdimstd::size_t ASTTemplateArgumentListInfo::sizeFor( 590226633Sdim const TemplateArgumentListInfo &Info) { 591226633Sdim return sizeFor(Info.size()); 592226633Sdim} 593