TemplateBase.cpp revision 309124
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" 25234353Sdim#include "llvm/ADT/SmallString.h" 26249423Sdim#include "llvm/Support/raw_ostream.h" 27218893Sdim#include <algorithm> 28198893Srdivacky 29198893Srdivackyusing namespace clang; 30198893Srdivacky 31218893Sdim/// \brief Print a template integral argument value. 32218893Sdim/// 33218893Sdim/// \param TemplArg the TemplateArgument instance to print. 34218893Sdim/// 35218893Sdim/// \param Out the raw_ostream instance to use for printing. 36280031Sdim/// 37280031Sdim/// \param Policy the printing policy for EnumConstantDecl printing. 38218893Sdimstatic void printIntegral(const TemplateArgument &TemplArg, 39280031Sdim raw_ostream &Out, const PrintingPolicy& Policy) { 40218893Sdim const ::clang::Type *T = TemplArg.getIntegralType().getTypePtr(); 41239462Sdim const llvm::APSInt &Val = TemplArg.getAsIntegral(); 42218893Sdim 43280031Sdim if (const EnumType *ET = T->getAs<EnumType>()) { 44280031Sdim for (const EnumConstantDecl* ECD : ET->getDecl()->enumerators()) { 45280031Sdim // In Sema::CheckTemplateArugment, enum template arguments value are 46280031Sdim // extended to the size of the integer underlying the enum type. This 47280031Sdim // may create a size difference between the enum value and template 48280031Sdim // argument value, requiring isSameValue here instead of operator==. 49280031Sdim if (llvm::APSInt::isSameValue(ECD->getInitVal(), Val)) { 50280031Sdim ECD->printQualifiedName(Out, Policy); 51280031Sdim return; 52280031Sdim } 53280031Sdim } 54280031Sdim } 55280031Sdim 56296417Sdim if (T->isBooleanType() && !Policy.MSVCFormatting) { 57239462Sdim Out << (Val.getBoolValue() ? "true" : "false"); 58218893Sdim } else if (T->isCharType()) { 59239462Sdim const char Ch = Val.getZExtValue(); 60219077Sdim Out << ((Ch == '\'') ? "'\\" : "'"); 61234353Sdim Out.write_escaped(StringRef(&Ch, 1), /*UseHexEscapes=*/ true); 62219077Sdim Out << "'"; 63218893Sdim } else { 64239462Sdim Out << Val; 65218893Sdim } 66218893Sdim} 67218893Sdim 68198893Srdivacky//===----------------------------------------------------------------------===// 69198893Srdivacky// TemplateArgument Implementation 70198893Srdivacky//===----------------------------------------------------------------------===// 71198893Srdivacky 72239462SdimTemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value, 73261991Sdim QualType Type) { 74261991Sdim Integer.Kind = Integral; 75239462Sdim // Copy the APSInt value into our decomposed form. 76239462Sdim Integer.BitWidth = Value.getBitWidth(); 77239462Sdim Integer.IsUnsigned = Value.isUnsigned(); 78239462Sdim // If the value is large, we have to get additional memory from the ASTContext 79239462Sdim unsigned NumWords = Value.getNumWords(); 80239462Sdim if (NumWords > 1) { 81239462Sdim void *Mem = Ctx.Allocate(NumWords * sizeof(uint64_t)); 82239462Sdim std::memcpy(Mem, Value.getRawData(), NumWords * sizeof(uint64_t)); 83239462Sdim Integer.pVal = static_cast<uint64_t *>(Mem); 84239462Sdim } else { 85239462Sdim Integer.VAL = Value.getZExtValue(); 86239462Sdim } 87239462Sdim 88239462Sdim Integer.Type = Type.getAsOpaquePtr(); 89239462Sdim} 90239462Sdim 91296417SdimTemplateArgument 92296417SdimTemplateArgument::CreatePackCopy(ASTContext &Context, 93296417Sdim ArrayRef<TemplateArgument> Args) { 94296417Sdim if (Args.empty()) 95243830Sdim return getEmptyPack(); 96296417Sdim 97296417Sdim return TemplateArgument(Args.copy(Context)); 98218893Sdim} 99198893Srdivacky 100218893Sdimbool TemplateArgument::isDependent() const { 101218893Sdim switch (getKind()) { 102218893Sdim case Null: 103226633Sdim llvm_unreachable("Should not have a NULL template argument"); 104218893Sdim 105218893Sdim case Type: 106280031Sdim return getAsType()->isDependentType() || 107280031Sdim isa<PackExpansionType>(getAsType()); 108218893Sdim 109218893Sdim case Template: 110218893Sdim return getAsTemplate().isDependent(); 111218893Sdim 112218893Sdim case TemplateExpansion: 113218893Sdim return true; 114218893Sdim 115218893Sdim case Declaration: 116243830Sdim if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl())) 117243830Sdim return DC->isDependentContext(); 118243830Sdim return getAsDecl()->getDeclContext()->isDependentContext(); 119243830Sdim 120243830Sdim case NullPtr: 121234353Sdim return false; 122218893Sdim 123218893Sdim case Integral: 124218893Sdim // Never dependent 125218893Sdim return false; 126218893Sdim 127218893Sdim case Expression: 128280031Sdim return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent() || 129280031Sdim isa<PackExpansionExpr>(getAsExpr())); 130218893Sdim 131218893Sdim case Pack: 132276479Sdim for (const auto &P : pack_elements()) 133276479Sdim if (P.isDependent()) 134218893Sdim return true; 135218893Sdim return false; 136198893Srdivacky } 137198893Srdivacky 138234353Sdim llvm_unreachable("Invalid TemplateArgument Kind!"); 139198893Srdivacky} 140198893Srdivacky 141224145Sdimbool TemplateArgument::isInstantiationDependent() const { 142224145Sdim switch (getKind()) { 143224145Sdim case Null: 144226633Sdim llvm_unreachable("Should not have a NULL template argument"); 145224145Sdim 146224145Sdim case Type: 147224145Sdim return getAsType()->isInstantiationDependentType(); 148224145Sdim 149224145Sdim case Template: 150224145Sdim return getAsTemplate().isInstantiationDependent(); 151224145Sdim 152224145Sdim case TemplateExpansion: 153224145Sdim return true; 154224145Sdim 155224145Sdim case Declaration: 156243830Sdim if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl())) 157243830Sdim return DC->isDependentContext(); 158243830Sdim return getAsDecl()->getDeclContext()->isDependentContext(); 159243830Sdim 160243830Sdim case NullPtr: 161234353Sdim return false; 162234353Sdim 163224145Sdim case Integral: 164224145Sdim // Never dependent 165224145Sdim return false; 166224145Sdim 167224145Sdim case Expression: 168224145Sdim return getAsExpr()->isInstantiationDependent(); 169224145Sdim 170224145Sdim case Pack: 171276479Sdim for (const auto &P : pack_elements()) 172276479Sdim if (P.isInstantiationDependent()) 173224145Sdim return true; 174224145Sdim return false; 175224145Sdim } 176234353Sdim 177234353Sdim llvm_unreachable("Invalid TemplateArgument Kind!"); 178224145Sdim} 179224145Sdim 180218893Sdimbool TemplateArgument::isPackExpansion() const { 181218893Sdim switch (getKind()) { 182218893Sdim case Null: 183218893Sdim case Declaration: 184218893Sdim case Integral: 185218893Sdim case Pack: 186218893Sdim case Template: 187243830Sdim case NullPtr: 188218893Sdim return false; 189218893Sdim 190218893Sdim case TemplateExpansion: 191218893Sdim return true; 192218893Sdim 193218893Sdim case Type: 194218893Sdim return isa<PackExpansionType>(getAsType()); 195218893Sdim 196218893Sdim case Expression: 197218893Sdim return isa<PackExpansionExpr>(getAsExpr()); 198218893Sdim } 199234353Sdim 200234353Sdim llvm_unreachable("Invalid TemplateArgument Kind!"); 201218893Sdim} 202218893Sdim 203218893Sdimbool TemplateArgument::containsUnexpandedParameterPack() const { 204218893Sdim switch (getKind()) { 205218893Sdim case Null: 206218893Sdim case Declaration: 207218893Sdim case Integral: 208218893Sdim case TemplateExpansion: 209243830Sdim case NullPtr: 210218893Sdim break; 211218893Sdim 212218893Sdim case Type: 213218893Sdim if (getAsType()->containsUnexpandedParameterPack()) 214218893Sdim return true; 215218893Sdim break; 216218893Sdim 217218893Sdim case Template: 218218893Sdim if (getAsTemplate().containsUnexpandedParameterPack()) 219218893Sdim return true; 220218893Sdim break; 221218893Sdim 222218893Sdim case Expression: 223218893Sdim if (getAsExpr()->containsUnexpandedParameterPack()) 224218893Sdim return true; 225218893Sdim break; 226218893Sdim 227218893Sdim case Pack: 228276479Sdim for (const auto &P : pack_elements()) 229276479Sdim if (P.containsUnexpandedParameterPack()) 230218893Sdim return true; 231218893Sdim 232218893Sdim break; 233218893Sdim } 234218893Sdim 235218893Sdim return false; 236218893Sdim} 237218893Sdim 238249423SdimOptional<unsigned> TemplateArgument::getNumTemplateExpansions() const { 239261991Sdim assert(getKind() == TemplateExpansion); 240218893Sdim if (TemplateArg.NumExpansions) 241218893Sdim return TemplateArg.NumExpansions - 1; 242218893Sdim 243249423Sdim return None; 244218893Sdim} 245218893Sdim 246198893Srdivackyvoid TemplateArgument::Profile(llvm::FoldingSetNodeID &ID, 247218893Sdim const ASTContext &Context) const { 248261991Sdim ID.AddInteger(getKind()); 249261991Sdim switch (getKind()) { 250198893Srdivacky case Null: 251198893Srdivacky break; 252198893Srdivacky 253198893Srdivacky case Type: 254198893Srdivacky getAsType().Profile(ID); 255198893Srdivacky break; 256198893Srdivacky 257261991Sdim case NullPtr: 258261991Sdim getNullPtrType().Profile(ID); 259261991Sdim break; 260261991Sdim 261198893Srdivacky case Declaration: 262276479Sdim ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : nullptr); 263198893Srdivacky break; 264198893Srdivacky 265199482Srdivacky case Template: 266218893Sdim case TemplateExpansion: { 267218893Sdim TemplateName Template = getAsTemplateOrTemplatePattern(); 268199990Srdivacky if (TemplateTemplateParmDecl *TTP 269199990Srdivacky = dyn_cast_or_null<TemplateTemplateParmDecl>( 270218893Sdim Template.getAsTemplateDecl())) { 271199990Srdivacky ID.AddBoolean(true); 272199990Srdivacky ID.AddInteger(TTP->getDepth()); 273199990Srdivacky ID.AddInteger(TTP->getPosition()); 274218893Sdim ID.AddBoolean(TTP->isParameterPack()); 275199990Srdivacky } else { 276199990Srdivacky ID.AddBoolean(false); 277218893Sdim ID.AddPointer(Context.getCanonicalTemplateName(Template) 278218893Sdim .getAsVoidPointer()); 279199990Srdivacky } 280199482Srdivacky break; 281218893Sdim } 282199482Srdivacky 283198893Srdivacky case Integral: 284239462Sdim getAsIntegral().Profile(ID); 285198893Srdivacky getIntegralType().Profile(ID); 286198893Srdivacky break; 287198893Srdivacky 288198893Srdivacky case Expression: 289198893Srdivacky getAsExpr()->Profile(ID, Context, true); 290198893Srdivacky break; 291198893Srdivacky 292198893Srdivacky case Pack: 293198893Srdivacky ID.AddInteger(Args.NumArgs); 294198893Srdivacky for (unsigned I = 0; I != Args.NumArgs; ++I) 295198893Srdivacky Args.Args[I].Profile(ID, Context); 296198893Srdivacky } 297198893Srdivacky} 298198893Srdivacky 299210299Sedbool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const { 300210299Sed if (getKind() != Other.getKind()) return false; 301210299Sed 302210299Sed switch (getKind()) { 303210299Sed case Null: 304210299Sed case Type: 305218893Sdim case Expression: 306210299Sed case Template: 307218893Sdim case TemplateExpansion: 308243830Sdim case NullPtr: 309261991Sdim return TypeOrValue.V == Other.TypeOrValue.V; 310210299Sed 311243830Sdim case Declaration: 312280031Sdim return getAsDecl() == Other.getAsDecl(); 313243830Sdim 314210299Sed case Integral: 315210299Sed return getIntegralType() == Other.getIntegralType() && 316239462Sdim getAsIntegral() == Other.getAsIntegral(); 317210299Sed 318210299Sed case Pack: 319210299Sed if (Args.NumArgs != Other.Args.NumArgs) return false; 320210299Sed for (unsigned I = 0, E = Args.NumArgs; I != E; ++I) 321210299Sed if (!Args.Args[I].structurallyEquals(Other.Args.Args[I])) 322210299Sed return false; 323210299Sed return true; 324210299Sed } 325210299Sed 326234353Sdim llvm_unreachable("Invalid TemplateArgument Kind!"); 327210299Sed} 328210299Sed 329218893SdimTemplateArgument TemplateArgument::getPackExpansionPattern() const { 330218893Sdim assert(isPackExpansion()); 331218893Sdim 332218893Sdim switch (getKind()) { 333218893Sdim case Type: 334218893Sdim return getAsType()->getAs<PackExpansionType>()->getPattern(); 335218893Sdim 336218893Sdim case Expression: 337218893Sdim return cast<PackExpansionExpr>(getAsExpr())->getPattern(); 338218893Sdim 339218893Sdim case TemplateExpansion: 340218893Sdim return TemplateArgument(getAsTemplateOrTemplatePattern()); 341243830Sdim 342218893Sdim case Declaration: 343218893Sdim case Integral: 344218893Sdim case Pack: 345218893Sdim case Null: 346218893Sdim case Template: 347243830Sdim case NullPtr: 348218893Sdim return TemplateArgument(); 349218893Sdim } 350234353Sdim 351234353Sdim llvm_unreachable("Invalid TemplateArgument Kind!"); 352218893Sdim} 353218893Sdim 354218893Sdimvoid TemplateArgument::print(const PrintingPolicy &Policy, 355226633Sdim raw_ostream &Out) const { 356218893Sdim switch (getKind()) { 357218893Sdim case Null: 358276479Sdim Out << "(no value)"; 359218893Sdim break; 360218893Sdim 361218893Sdim case Type: { 362224145Sdim PrintingPolicy SubPolicy(Policy); 363224145Sdim SubPolicy.SuppressStrongLifetime = true; 364249423Sdim getAsType().print(Out, SubPolicy); 365218893Sdim break; 366218893Sdim } 367218893Sdim 368218893Sdim case Declaration: { 369243830Sdim NamedDecl *ND = cast<NamedDecl>(getAsDecl()); 370261991Sdim Out << '&'; 371243830Sdim if (ND->getDeclName()) { 372243830Sdim // FIXME: distinguish between pointer and reference args? 373261991Sdim ND->printQualifiedName(Out); 374234353Sdim } else { 375276479Sdim Out << "(anonymous)"; 376218893Sdim } 377218893Sdim break; 378218893Sdim } 379243830Sdim 380243830Sdim case NullPtr: 381243830Sdim Out << "nullptr"; 382243830Sdim break; 383243830Sdim 384218893Sdim case Template: 385218893Sdim getAsTemplate().print(Out, Policy); 386218893Sdim break; 387218893Sdim 388218893Sdim case TemplateExpansion: 389218893Sdim getAsTemplateOrTemplatePattern().print(Out, Policy); 390218893Sdim Out << "..."; 391218893Sdim break; 392218893Sdim 393218893Sdim case Integral: { 394280031Sdim printIntegral(*this, Out, Policy); 395218893Sdim break; 396218893Sdim } 397218893Sdim 398218893Sdim case Expression: 399276479Sdim getAsExpr()->printPretty(Out, nullptr, Policy); 400218893Sdim break; 401218893Sdim 402218893Sdim case Pack: 403218893Sdim Out << "<"; 404218893Sdim bool First = true; 405276479Sdim for (const auto &P : pack_elements()) { 406218893Sdim if (First) 407218893Sdim First = false; 408218893Sdim else 409218893Sdim Out << ", "; 410218893Sdim 411276479Sdim P.print(Policy, Out); 412218893Sdim } 413218893Sdim Out << ">"; 414218893Sdim break; 415218893Sdim } 416218893Sdim} 417218893Sdim 418309124Sdimvoid TemplateArgument::dump(raw_ostream &Out) const { 419309124Sdim LangOptions LO; // FIXME! see also TemplateName::dump(). 420309124Sdim LO.CPlusPlus = true; 421309124Sdim LO.Bool = true; 422309124Sdim print(PrintingPolicy(LO), Out); 423309124Sdim} 424309124Sdim 425309124SdimLLVM_DUMP_METHOD void TemplateArgument::dump() const { dump(llvm::errs()); } 426309124Sdim 427198893Srdivacky//===----------------------------------------------------------------------===// 428198893Srdivacky// TemplateArgumentLoc Implementation 429198893Srdivacky//===----------------------------------------------------------------------===// 430198893Srdivacky 431218893SdimTemplateArgumentLocInfo::TemplateArgumentLocInfo() { 432221345Sdim memset((void*)this, 0, sizeof(TemplateArgumentLocInfo)); 433218893Sdim} 434218893Sdim 435198893SrdivackySourceRange TemplateArgumentLoc::getSourceRange() const { 436198893Srdivacky switch (Argument.getKind()) { 437198893Srdivacky case TemplateArgument::Expression: 438198893Srdivacky return getSourceExpression()->getSourceRange(); 439212904Sdim 440198893Srdivacky case TemplateArgument::Declaration: 441198893Srdivacky return getSourceDeclExpression()->getSourceRange(); 442212904Sdim 443243830Sdim case TemplateArgument::NullPtr: 444243830Sdim return getSourceNullPtrExpression()->getSourceRange(); 445243830Sdim 446198893Srdivacky case TemplateArgument::Type: 447212904Sdim if (TypeSourceInfo *TSI = getTypeSourceInfo()) 448212904Sdim return TSI->getTypeLoc().getSourceRange(); 449212904Sdim else 450212904Sdim return SourceRange(); 451212904Sdim 452199482Srdivacky case TemplateArgument::Template: 453221345Sdim if (getTemplateQualifierLoc()) 454221345Sdim return SourceRange(getTemplateQualifierLoc().getBeginLoc(), 455199482Srdivacky getTemplateNameLoc()); 456199482Srdivacky return SourceRange(getTemplateNameLoc()); 457212904Sdim 458218893Sdim case TemplateArgument::TemplateExpansion: 459221345Sdim if (getTemplateQualifierLoc()) 460221345Sdim return SourceRange(getTemplateQualifierLoc().getBeginLoc(), 461218893Sdim getTemplateEllipsisLoc()); 462218893Sdim return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc()); 463218893Sdim 464198893Srdivacky case TemplateArgument::Integral: 465243830Sdim return getSourceIntegralExpression()->getSourceRange(); 466243830Sdim 467198893Srdivacky case TemplateArgument::Pack: 468198893Srdivacky case TemplateArgument::Null: 469198893Srdivacky return SourceRange(); 470198893Srdivacky } 471198893Srdivacky 472234353Sdim llvm_unreachable("Invalid TemplateArgument Kind!"); 473198893Srdivacky} 474208600Srdivacky 475208600Srdivackyconst DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB, 476208600Srdivacky const TemplateArgument &Arg) { 477208600Srdivacky switch (Arg.getKind()) { 478208600Srdivacky case TemplateArgument::Null: 479212904Sdim // This is bad, but not as bad as crashing because of argument 480212904Sdim // count mismatches. 481212904Sdim return DB << "(null template argument)"; 482208600Srdivacky 483208600Srdivacky case TemplateArgument::Type: 484208600Srdivacky return DB << Arg.getAsType(); 485208600Srdivacky 486208600Srdivacky case TemplateArgument::Declaration: 487243830Sdim return DB << Arg.getAsDecl(); 488243830Sdim 489243830Sdim case TemplateArgument::NullPtr: 490234353Sdim return DB << "nullptr"; 491208600Srdivacky 492208600Srdivacky case TemplateArgument::Integral: 493239462Sdim return DB << Arg.getAsIntegral().toString(10); 494208600Srdivacky 495208600Srdivacky case TemplateArgument::Template: 496208600Srdivacky return DB << Arg.getAsTemplate(); 497218893Sdim 498218893Sdim case TemplateArgument::TemplateExpansion: 499218893Sdim return DB << Arg.getAsTemplateOrTemplatePattern() << "..."; 500218893Sdim 501208600Srdivacky case TemplateArgument::Expression: { 502208600Srdivacky // This shouldn't actually ever happen, so it's okay that we're 503208600Srdivacky // regurgitating an expression here. 504208600Srdivacky // FIXME: We're guessing at LangOptions! 505234353Sdim SmallString<32> Str; 506208600Srdivacky llvm::raw_svector_ostream OS(Str); 507208600Srdivacky LangOptions LangOpts; 508208600Srdivacky LangOpts.CPlusPlus = true; 509208600Srdivacky PrintingPolicy Policy(LangOpts); 510276479Sdim Arg.getAsExpr()->printPretty(OS, nullptr, Policy); 511208600Srdivacky return DB << OS.str(); 512208600Srdivacky } 513208600Srdivacky 514218893Sdim case TemplateArgument::Pack: { 515218893Sdim // FIXME: We're guessing at LangOptions! 516234353Sdim SmallString<32> Str; 517218893Sdim llvm::raw_svector_ostream OS(Str); 518218893Sdim LangOptions LangOpts; 519218893Sdim LangOpts.CPlusPlus = true; 520218893Sdim PrintingPolicy Policy(LangOpts); 521218893Sdim Arg.print(Policy, OS); 522218893Sdim return DB << OS.str(); 523208600Srdivacky } 524218893Sdim } 525234353Sdim 526234353Sdim llvm_unreachable("Invalid TemplateArgument Kind!"); 527208600Srdivacky} 528226633Sdim 529226633Sdimconst ASTTemplateArgumentListInfo * 530226633SdimASTTemplateArgumentListInfo::Create(ASTContext &C, 531226633Sdim const TemplateArgumentListInfo &List) { 532296417Sdim std::size_t size = totalSizeToAlloc<TemplateArgumentLoc>(List.size()); 533226633Sdim void *Mem = C.Allocate(size, llvm::alignOf<ASTTemplateArgumentListInfo>()); 534296417Sdim return new (Mem) ASTTemplateArgumentListInfo(List); 535226633Sdim} 536226633Sdim 537296417SdimASTTemplateArgumentListInfo::ASTTemplateArgumentListInfo( 538296417Sdim const TemplateArgumentListInfo &Info) { 539226633Sdim LAngleLoc = Info.getLAngleLoc(); 540226633Sdim RAngleLoc = Info.getRAngleLoc(); 541226633Sdim NumTemplateArgs = Info.size(); 542226633Sdim 543296417Sdim TemplateArgumentLoc *ArgBuffer = getTrailingObjects<TemplateArgumentLoc>(); 544226633Sdim for (unsigned i = 0; i != NumTemplateArgs; ++i) 545226633Sdim new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]); 546226633Sdim} 547226633Sdim 548296417Sdimvoid ASTTemplateKWAndArgsInfo::initializeFrom( 549296417Sdim SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info, 550296417Sdim TemplateArgumentLoc *OutArgArray) { 551296417Sdim this->TemplateKWLoc = TemplateKWLoc; 552226633Sdim LAngleLoc = Info.getLAngleLoc(); 553226633Sdim RAngleLoc = Info.getRAngleLoc(); 554226633Sdim NumTemplateArgs = Info.size(); 555226633Sdim 556296417Sdim for (unsigned i = 0; i != NumTemplateArgs; ++i) 557296417Sdim new (&OutArgArray[i]) TemplateArgumentLoc(Info[i]); 558296417Sdim} 559296417Sdim 560296417Sdimvoid ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) { 561296417Sdim assert(TemplateKWLoc.isValid()); 562296417Sdim LAngleLoc = SourceLocation(); 563296417Sdim RAngleLoc = SourceLocation(); 564296417Sdim this->TemplateKWLoc = TemplateKWLoc; 565296417Sdim NumTemplateArgs = 0; 566296417Sdim} 567296417Sdim 568296417Sdimvoid ASTTemplateKWAndArgsInfo::initializeFrom( 569296417Sdim SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info, 570296417Sdim TemplateArgumentLoc *OutArgArray, bool &Dependent, 571296417Sdim bool &InstantiationDependent, bool &ContainsUnexpandedParameterPack) { 572296417Sdim this->TemplateKWLoc = TemplateKWLoc; 573296417Sdim LAngleLoc = Info.getLAngleLoc(); 574296417Sdim RAngleLoc = Info.getRAngleLoc(); 575296417Sdim NumTemplateArgs = Info.size(); 576296417Sdim 577226633Sdim for (unsigned i = 0; i != NumTemplateArgs; ++i) { 578226633Sdim Dependent = Dependent || Info[i].getArgument().isDependent(); 579296417Sdim InstantiationDependent = InstantiationDependent || 580226633Sdim Info[i].getArgument().isInstantiationDependent(); 581296417Sdim ContainsUnexpandedParameterPack = 582296417Sdim ContainsUnexpandedParameterPack || 583226633Sdim Info[i].getArgument().containsUnexpandedParameterPack(); 584226633Sdim 585296417Sdim new (&OutArgArray[i]) TemplateArgumentLoc(Info[i]); 586226633Sdim } 587226633Sdim} 588226633Sdim 589296417Sdimvoid ASTTemplateKWAndArgsInfo::copyInto(const TemplateArgumentLoc *ArgArray, 590296417Sdim TemplateArgumentListInfo &Info) const { 591226633Sdim Info.setLAngleLoc(LAngleLoc); 592226633Sdim Info.setRAngleLoc(RAngleLoc); 593226633Sdim for (unsigned I = 0; I != NumTemplateArgs; ++I) 594296417Sdim Info.addArgument(ArgArray[I]); 595226633Sdim} 596