1193326Sed//===--- ExprCXX.cpp - (C++) Expression AST Node Implementation -----------===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This file implements the subclesses of Expr class declared in ExprCXX.h 11193326Sed// 12193326Sed//===----------------------------------------------------------------------===// 13193326Sed 14239462Sdim#include "clang/AST/ASTContext.h" 15249423Sdim#include "clang/AST/Attr.h" 16193326Sed#include "clang/AST/DeclCXX.h" 17195341Sed#include "clang/AST/DeclTemplate.h" 18193326Sed#include "clang/AST/ExprCXX.h" 19204643Srdivacky#include "clang/AST/TypeLoc.h" 20249423Sdim#include "clang/Basic/IdentifierTable.h" 21193326Sedusing namespace clang; 22193326Sed 23207619Srdivacky 24193326Sed//===----------------------------------------------------------------------===// 25193326Sed// Child Iterators for iterating over subexpressions/substatements 26193326Sed//===----------------------------------------------------------------------===// 27193326Sed 28239462Sdimbool CXXTypeidExpr::isPotentiallyEvaluated() const { 29239462Sdim if (isTypeOperand()) 30239462Sdim return false; 31239462Sdim 32239462Sdim // C++11 [expr.typeid]p3: 33239462Sdim // When typeid is applied to an expression other than a glvalue of 34239462Sdim // polymorphic class type, [...] the expression is an unevaluated operand. 35239462Sdim const Expr *E = getExprOperand(); 36239462Sdim if (const CXXRecordDecl *RD = E->getType()->getAsCXXRecordDecl()) 37239462Sdim if (RD->isPolymorphic() && E->isGLValue()) 38239462Sdim return true; 39239462Sdim 40239462Sdim return false; 41239462Sdim} 42239462Sdim 43263508SdimQualType CXXTypeidExpr::getTypeOperand(ASTContext &Context) const { 44207619Srdivacky assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)"); 45263508Sdim Qualifiers Quals; 46263508Sdim return Context.getUnqualifiedArrayType( 47263508Sdim Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType(), Quals); 48207619Srdivacky} 49207619Srdivacky 50263508SdimQualType CXXUuidofExpr::getTypeOperand(ASTContext &Context) const { 51218893Sdim assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)"); 52263508Sdim Qualifiers Quals; 53263508Sdim return Context.getUnqualifiedArrayType( 54263508Sdim Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType(), Quals); 55193326Sed} 56193326Sed 57243830Sdim// static 58263508SdimUuidAttr *CXXUuidofExpr::GetUuidAttrOfType(QualType QT, 59263508Sdim bool *RDHasMultipleGUIDsPtr) { 60243830Sdim // Optionally remove one level of pointer, reference or array indirection. 61243830Sdim const Type *Ty = QT.getTypePtr(); 62243830Sdim if (QT->isPointerType() || QT->isReferenceType()) 63243830Sdim Ty = QT->getPointeeType().getTypePtr(); 64243830Sdim else if (QT->isArrayType()) 65263508Sdim Ty = Ty->getBaseElementTypeUnsafe(); 66243830Sdim 67243830Sdim // Loop all record redeclaration looking for an uuid attribute. 68243830Sdim CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); 69263508Sdim if (!RD) 70263508Sdim return 0; 71263508Sdim 72263508Sdim // __uuidof can grab UUIDs from template arguments. 73263508Sdim if (ClassTemplateSpecializationDecl *CTSD = 74263508Sdim dyn_cast<ClassTemplateSpecializationDecl>(RD)) { 75263508Sdim const TemplateArgumentList &TAL = CTSD->getTemplateArgs(); 76263508Sdim UuidAttr *UuidForRD = 0; 77263508Sdim 78263508Sdim for (unsigned I = 0, N = TAL.size(); I != N; ++I) { 79263508Sdim const TemplateArgument &TA = TAL[I]; 80263508Sdim bool SeenMultipleGUIDs = false; 81263508Sdim 82263508Sdim UuidAttr *UuidForTA = 0; 83263508Sdim if (TA.getKind() == TemplateArgument::Type) 84263508Sdim UuidForTA = GetUuidAttrOfType(TA.getAsType(), &SeenMultipleGUIDs); 85263508Sdim else if (TA.getKind() == TemplateArgument::Declaration) 86263508Sdim UuidForTA = 87263508Sdim GetUuidAttrOfType(TA.getAsDecl()->getType(), &SeenMultipleGUIDs); 88263508Sdim 89263508Sdim // If the template argument has a UUID, there are three cases: 90263508Sdim // - This is the first UUID seen for this RecordDecl. 91263508Sdim // - This is a different UUID than previously seen for this RecordDecl. 92263508Sdim // - This is the same UUID than previously seen for this RecordDecl. 93263508Sdim if (UuidForTA) { 94263508Sdim if (!UuidForRD) 95263508Sdim UuidForRD = UuidForTA; 96263508Sdim else if (UuidForRD != UuidForTA) 97263508Sdim SeenMultipleGUIDs = true; 98263508Sdim } 99263508Sdim 100263508Sdim // Seeing multiple UUIDs means that we couldn't find a UUID 101263508Sdim if (SeenMultipleGUIDs) { 102263508Sdim if (RDHasMultipleGUIDsPtr) 103263508Sdim *RDHasMultipleGUIDsPtr = true; 104263508Sdim return 0; 105263508Sdim } 106263508Sdim } 107263508Sdim 108263508Sdim return UuidForRD; 109263508Sdim } 110263508Sdim 111243830Sdim for (CXXRecordDecl::redecl_iterator I = RD->redecls_begin(), 112263508Sdim E = RD->redecls_end(); 113263508Sdim I != E; ++I) 114243830Sdim if (UuidAttr *Uuid = I->getAttr<UuidAttr>()) 115243830Sdim return Uuid; 116243830Sdim 117243830Sdim return 0; 118243830Sdim} 119243830Sdim 120263508SdimStringRef CXXUuidofExpr::getUuidAsStringRef(ASTContext &Context) const { 121263508Sdim StringRef Uuid; 122263508Sdim if (isTypeOperand()) 123263508Sdim Uuid = CXXUuidofExpr::GetUuidAttrOfType(getTypeOperand(Context))->getGuid(); 124263508Sdim else { 125263508Sdim // Special case: __uuidof(0) means an all-zero GUID. 126263508Sdim Expr *Op = getExprOperand(); 127263508Sdim if (!Op->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) 128263508Sdim Uuid = CXXUuidofExpr::GetUuidAttrOfType(Op->getType())->getGuid(); 129263508Sdim else 130263508Sdim Uuid = "00000000-0000-0000-0000-000000000000"; 131263508Sdim } 132263508Sdim return Uuid; 133263508Sdim} 134263508Sdim 135210299Sed// CXXScalarValueInitExpr 136249423SdimSourceLocation CXXScalarValueInitExpr::getLocStart() const { 137249423Sdim return TypeInfo ? TypeInfo->getTypeLoc().getBeginLoc() : RParenLoc; 138193326Sed} 139193326Sed 140193326Sed// CXXNewExpr 141263508SdimCXXNewExpr::CXXNewExpr(const ASTContext &C, bool globalNew, 142263508Sdim FunctionDecl *operatorNew, FunctionDecl *operatorDelete, 143234353Sdim bool usualArrayDeleteWantsSize, 144243830Sdim ArrayRef<Expr*> placementArgs, 145234353Sdim SourceRange typeIdParens, Expr *arraySize, 146234353Sdim InitializationStyle initializationStyle, 147234353Sdim Expr *initializer, QualType ty, 148234353Sdim TypeSourceInfo *allocatedTypeInfo, 149243830Sdim SourceRange Range, SourceRange directInitRange) 150218893Sdim : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary, 151218893Sdim ty->isDependentType(), ty->isDependentType(), 152224145Sdim ty->isInstantiationDependentType(), 153218893Sdim ty->containsUnexpandedParameterPack()), 154234353Sdim SubExprs(0), OperatorNew(operatorNew), OperatorDelete(operatorDelete), 155234353Sdim AllocatedTypeInfo(allocatedTypeInfo), TypeIdParens(typeIdParens), 156243830Sdim Range(Range), DirectInitRange(directInitRange), 157234353Sdim GlobalNew(globalNew), UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) { 158234353Sdim assert((initializer != 0 || initializationStyle == NoInit) && 159234353Sdim "Only NoInit can have no initializer."); 160234353Sdim StoredInitializationStyle = initializer ? initializationStyle + 1 : 0; 161243830Sdim AllocateArgsArray(C, arraySize != 0, placementArgs.size(), initializer != 0); 162193326Sed unsigned i = 0; 163218893Sdim if (Array) { 164224145Sdim if (arraySize->isInstantiationDependent()) 165224145Sdim ExprBits.InstantiationDependent = true; 166224145Sdim 167218893Sdim if (arraySize->containsUnexpandedParameterPack()) 168218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 169218893Sdim 170193326Sed SubExprs[i++] = arraySize; 171218893Sdim } 172218893Sdim 173234353Sdim if (initializer) { 174234353Sdim if (initializer->isInstantiationDependent()) 175224145Sdim ExprBits.InstantiationDependent = true; 176234353Sdim 177234353Sdim if (initializer->containsUnexpandedParameterPack()) 178218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 179218893Sdim 180234353Sdim SubExprs[i++] = initializer; 181218893Sdim } 182218893Sdim 183243830Sdim for (unsigned j = 0; j != placementArgs.size(); ++j) { 184234353Sdim if (placementArgs[j]->isInstantiationDependent()) 185224145Sdim ExprBits.InstantiationDependent = true; 186234353Sdim if (placementArgs[j]->containsUnexpandedParameterPack()) 187218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 188218893Sdim 189234353Sdim SubExprs[i++] = placementArgs[j]; 190218893Sdim } 191243830Sdim 192243830Sdim switch (getInitializationStyle()) { 193243830Sdim case CallInit: 194243830Sdim this->Range.setEnd(DirectInitRange.getEnd()); break; 195243830Sdim case ListInit: 196243830Sdim this->Range.setEnd(getInitializer()->getSourceRange().getEnd()); break; 197263508Sdim default: 198263508Sdim if (TypeIdParens.isValid()) 199263508Sdim this->Range.setEnd(TypeIdParens.getEnd()); 200263508Sdim break; 201243830Sdim } 202193326Sed} 203193326Sed 204263508Sdimvoid CXXNewExpr::AllocateArgsArray(const ASTContext &C, bool isArray, 205234353Sdim unsigned numPlaceArgs, bool hasInitializer){ 206208600Srdivacky assert(SubExprs == 0 && "SubExprs already allocated"); 207208600Srdivacky Array = isArray; 208208600Srdivacky NumPlacementArgs = numPlaceArgs; 209234353Sdim 210234353Sdim unsigned TotalSize = Array + hasInitializer + NumPlacementArgs; 211208600Srdivacky SubExprs = new (C) Stmt*[TotalSize]; 212208600Srdivacky} 213208600Srdivacky 214263508Sdimbool CXXNewExpr::shouldNullCheckAllocation(const ASTContext &Ctx) const { 215221345Sdim return getOperatorNew()->getType()-> 216221345Sdim castAs<FunctionProtoType>()->isNothrow(Ctx); 217221345Sdim} 218208600Srdivacky 219193326Sed// CXXDeleteExpr 220218893SdimQualType CXXDeleteExpr::getDestroyedType() const { 221218893Sdim const Expr *Arg = getArgument(); 222218893Sdim // The type-to-delete may not be a pointer if it's a dependent type. 223218893Sdim const QualType ArgType = Arg->getType(); 224193326Sed 225218893Sdim if (ArgType->isDependentType() && !ArgType->isPointerType()) 226218893Sdim return QualType(); 227218893Sdim 228218893Sdim return ArgType->getAs<PointerType>()->getPointeeType(); 229198092Srdivacky} 230198092Srdivacky 231218893Sdim// CXXPseudoDestructorExpr 232204643SrdivackyPseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info) 233204643Srdivacky : Type(Info) 234204643Srdivacky{ 235208600Srdivacky Location = Info->getTypeLoc().getLocalSourceRange().getBegin(); 236204643Srdivacky} 237204643Srdivacky 238263508SdimCXXPseudoDestructorExpr::CXXPseudoDestructorExpr(const ASTContext &Context, 239219077Sdim Expr *Base, bool isArrow, SourceLocation OperatorLoc, 240219077Sdim NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType, 241219077Sdim SourceLocation ColonColonLoc, SourceLocation TildeLoc, 242219077Sdim PseudoDestructorTypeStorage DestroyedType) 243218893Sdim : Expr(CXXPseudoDestructorExprClass, 244263508Sdim Context.getPointerType(Context.getFunctionType( 245263508Sdim Context.VoidTy, None, 246263508Sdim FunctionProtoType::ExtProtoInfo( 247263508Sdim Context.getDefaultCallingConvention(false, true)))), 248218893Sdim VK_RValue, OK_Ordinary, 249218893Sdim /*isTypeDependent=*/(Base->isTypeDependent() || 250218893Sdim (DestroyedType.getTypeSourceInfo() && 251218893Sdim DestroyedType.getTypeSourceInfo()->getType()->isDependentType())), 252218893Sdim /*isValueDependent=*/Base->isValueDependent(), 253224145Sdim (Base->isInstantiationDependent() || 254224145Sdim (QualifierLoc && 255224145Sdim QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) || 256224145Sdim (ScopeType && 257224145Sdim ScopeType->getType()->isInstantiationDependentType()) || 258224145Sdim (DestroyedType.getTypeSourceInfo() && 259224145Sdim DestroyedType.getTypeSourceInfo()->getType() 260224145Sdim ->isInstantiationDependentType())), 261218893Sdim // ContainsUnexpandedParameterPack 262218893Sdim (Base->containsUnexpandedParameterPack() || 263219077Sdim (QualifierLoc && 264219077Sdim QualifierLoc.getNestedNameSpecifier() 265219077Sdim ->containsUnexpandedParameterPack()) || 266218893Sdim (ScopeType && 267218893Sdim ScopeType->getType()->containsUnexpandedParameterPack()) || 268218893Sdim (DestroyedType.getTypeSourceInfo() && 269218893Sdim DestroyedType.getTypeSourceInfo()->getType() 270218893Sdim ->containsUnexpandedParameterPack()))), 271218893Sdim Base(static_cast<Stmt *>(Base)), IsArrow(isArrow), 272219077Sdim OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 273218893Sdim ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc), 274218893Sdim DestroyedType(DestroyedType) { } 275218893Sdim 276204643SrdivackyQualType CXXPseudoDestructorExpr::getDestroyedType() const { 277204643Srdivacky if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) 278204643Srdivacky return TInfo->getType(); 279204643Srdivacky 280204643Srdivacky return QualType(); 281204643Srdivacky} 282204643Srdivacky 283249423SdimSourceLocation CXXPseudoDestructorExpr::getLocEnd() const { 284204643Srdivacky SourceLocation End = DestroyedType.getLocation(); 285204643Srdivacky if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) 286208600Srdivacky End = TInfo->getTypeLoc().getLocalSourceRange().getEnd(); 287249423Sdim return End; 288204643Srdivacky} 289204643Srdivacky 290199990Srdivacky// UnresolvedLookupExpr 291199990SrdivackyUnresolvedLookupExpr * 292263508SdimUnresolvedLookupExpr::Create(const ASTContext &C, 293203955Srdivacky CXXRecordDecl *NamingClass, 294221345Sdim NestedNameSpecifierLoc QualifierLoc, 295234353Sdim SourceLocation TemplateKWLoc, 296212904Sdim const DeclarationNameInfo &NameInfo, 297212904Sdim bool ADL, 298234353Sdim const TemplateArgumentListInfo *Args, 299234353Sdim UnresolvedSetIterator Begin, 300234353Sdim UnresolvedSetIterator End) 301199990Srdivacky{ 302234353Sdim assert(Args || TemplateKWLoc.isValid()); 303234353Sdim unsigned num_args = Args ? Args->size() : 0; 304234353Sdim void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) + 305234353Sdim ASTTemplateKWAndArgsInfo::sizeFor(num_args)); 306234353Sdim return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc, 307234353Sdim TemplateKWLoc, NameInfo, 308234353Sdim ADL, /*Overload*/ true, Args, 309243830Sdim Begin, End); 310199990Srdivacky} 311199990Srdivacky 312210299SedUnresolvedLookupExpr * 313263508SdimUnresolvedLookupExpr::CreateEmpty(const ASTContext &C, 314234353Sdim bool HasTemplateKWAndArgsInfo, 315218893Sdim unsigned NumTemplateArgs) { 316210299Sed std::size_t size = sizeof(UnresolvedLookupExpr); 317234353Sdim if (HasTemplateKWAndArgsInfo) 318234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 319210299Sed 320218893Sdim void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>()); 321210299Sed UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell()); 322234353Sdim E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 323210299Sed return E; 324210299Sed} 325210299Sed 326263508SdimOverloadExpr::OverloadExpr(StmtClass K, const ASTContext &C, 327221345Sdim NestedNameSpecifierLoc QualifierLoc, 328234353Sdim SourceLocation TemplateKWLoc, 329212904Sdim const DeclarationNameInfo &NameInfo, 330218893Sdim const TemplateArgumentListInfo *TemplateArgs, 331208600Srdivacky UnresolvedSetIterator Begin, 332218893Sdim UnresolvedSetIterator End, 333218893Sdim bool KnownDependent, 334224145Sdim bool KnownInstantiationDependent, 335218893Sdim bool KnownContainsUnexpandedParameterPack) 336218893Sdim : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent, 337218893Sdim KnownDependent, 338224145Sdim (KnownInstantiationDependent || 339224145Sdim NameInfo.isInstantiationDependent() || 340224145Sdim (QualifierLoc && 341224145Sdim QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), 342218893Sdim (KnownContainsUnexpandedParameterPack || 343218893Sdim NameInfo.containsUnexpandedParameterPack() || 344221345Sdim (QualifierLoc && 345221345Sdim QualifierLoc.getNestedNameSpecifier() 346221345Sdim ->containsUnexpandedParameterPack()))), 347234353Sdim NameInfo(NameInfo), QualifierLoc(QualifierLoc), 348234353Sdim Results(0), NumResults(End - Begin), 349234353Sdim HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid()) 350208600Srdivacky{ 351210299Sed NumResults = End - Begin; 352208600Srdivacky if (NumResults) { 353218893Sdim // Determine whether this expression is type-dependent. 354218893Sdim for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) { 355218893Sdim if ((*I)->getDeclContext()->isDependentContext() || 356218893Sdim isa<UnresolvedUsingValueDecl>(*I)) { 357218893Sdim ExprBits.TypeDependent = true; 358218893Sdim ExprBits.ValueDependent = true; 359239462Sdim ExprBits.InstantiationDependent = true; 360218893Sdim } 361218893Sdim } 362218893Sdim 363208600Srdivacky Results = static_cast<DeclAccessPair *>( 364208600Srdivacky C.Allocate(sizeof(DeclAccessPair) * NumResults, 365218893Sdim llvm::alignOf<DeclAccessPair>())); 366208600Srdivacky memcpy(Results, &*Begin.getIterator(), 367210299Sed NumResults * sizeof(DeclAccessPair)); 368208600Srdivacky } 369208600Srdivacky 370218893Sdim // If we have explicit template arguments, check for dependent 371218893Sdim // template arguments and whether they contain any unexpanded pack 372218893Sdim // expansions. 373218893Sdim if (TemplateArgs) { 374218893Sdim bool Dependent = false; 375224145Sdim bool InstantiationDependent = false; 376218893Sdim bool ContainsUnexpandedParameterPack = false; 377234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, 378234353Sdim Dependent, 379234353Sdim InstantiationDependent, 380234353Sdim ContainsUnexpandedParameterPack); 381210299Sed 382218893Sdim if (Dependent) { 383224145Sdim ExprBits.TypeDependent = true; 384224145Sdim ExprBits.ValueDependent = true; 385224145Sdim } 386224145Sdim if (InstantiationDependent) 387224145Sdim ExprBits.InstantiationDependent = true; 388218893Sdim if (ContainsUnexpandedParameterPack) 389218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 390234353Sdim } else if (TemplateKWLoc.isValid()) { 391234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 392218893Sdim } 393199990Srdivacky 394218893Sdim if (isTypeDependent()) 395218893Sdim setType(C.DependentTy); 396218893Sdim} 397199990Srdivacky 398263508Sdimvoid OverloadExpr::initializeResults(const ASTContext &C, 399218893Sdim UnresolvedSetIterator Begin, 400218893Sdim UnresolvedSetIterator End) { 401218893Sdim assert(Results == 0 && "Results already initialized!"); 402218893Sdim NumResults = End - Begin; 403218893Sdim if (NumResults) { 404218893Sdim Results = static_cast<DeclAccessPair *>( 405218893Sdim C.Allocate(sizeof(DeclAccessPair) * NumResults, 406218893Sdim 407218893Sdim llvm::alignOf<DeclAccessPair>())); 408218893Sdim memcpy(Results, &*Begin.getIterator(), 409218893Sdim NumResults * sizeof(DeclAccessPair)); 410218893Sdim } 411199990Srdivacky} 412199990Srdivacky 413207619SrdivackyCXXRecordDecl *OverloadExpr::getNamingClass() const { 414207619Srdivacky if (isa<UnresolvedLookupExpr>(this)) 415207619Srdivacky return cast<UnresolvedLookupExpr>(this)->getNamingClass(); 416207619Srdivacky else 417207619Srdivacky return cast<UnresolvedMemberExpr>(this)->getNamingClass(); 418207619Srdivacky} 419207619Srdivacky 420218893Sdim// DependentScopeDeclRefExpr 421218893SdimDependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T, 422219077Sdim NestedNameSpecifierLoc QualifierLoc, 423234353Sdim SourceLocation TemplateKWLoc, 424218893Sdim const DeclarationNameInfo &NameInfo, 425218893Sdim const TemplateArgumentListInfo *Args) 426218893Sdim : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary, 427218893Sdim true, true, 428224145Sdim (NameInfo.isInstantiationDependent() || 429224145Sdim (QualifierLoc && 430224145Sdim QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), 431218893Sdim (NameInfo.containsUnexpandedParameterPack() || 432219077Sdim (QualifierLoc && 433219077Sdim QualifierLoc.getNestedNameSpecifier() 434219077Sdim ->containsUnexpandedParameterPack()))), 435219077Sdim QualifierLoc(QualifierLoc), NameInfo(NameInfo), 436234353Sdim HasTemplateKWAndArgsInfo(Args != 0 || TemplateKWLoc.isValid()) 437218893Sdim{ 438218893Sdim if (Args) { 439218893Sdim bool Dependent = true; 440224145Sdim bool InstantiationDependent = true; 441218893Sdim bool ContainsUnexpandedParameterPack 442218893Sdim = ExprBits.ContainsUnexpandedParameterPack; 443234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *Args, 444234353Sdim Dependent, 445234353Sdim InstantiationDependent, 446234353Sdim ContainsUnexpandedParameterPack); 447218893Sdim ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; 448234353Sdim } else if (TemplateKWLoc.isValid()) { 449234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 450218893Sdim } 451193326Sed} 452193326Sed 453199990SrdivackyDependentScopeDeclRefExpr * 454263508SdimDependentScopeDeclRefExpr::Create(const ASTContext &C, 455219077Sdim NestedNameSpecifierLoc QualifierLoc, 456234353Sdim SourceLocation TemplateKWLoc, 457212904Sdim const DeclarationNameInfo &NameInfo, 458199990Srdivacky const TemplateArgumentListInfo *Args) { 459263508Sdim assert(QualifierLoc && "should be created for dependent qualifiers"); 460199990Srdivacky std::size_t size = sizeof(DependentScopeDeclRefExpr); 461218893Sdim if (Args) 462234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(Args->size()); 463234353Sdim else if (TemplateKWLoc.isValid()) 464234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(0); 465199990Srdivacky void *Mem = C.Allocate(size); 466234353Sdim return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc, 467234353Sdim TemplateKWLoc, NameInfo, Args); 468195341Sed} 469195341Sed 470210299SedDependentScopeDeclRefExpr * 471263508SdimDependentScopeDeclRefExpr::CreateEmpty(const ASTContext &C, 472234353Sdim bool HasTemplateKWAndArgsInfo, 473210299Sed unsigned NumTemplateArgs) { 474210299Sed std::size_t size = sizeof(DependentScopeDeclRefExpr); 475234353Sdim if (HasTemplateKWAndArgsInfo) 476234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 477210299Sed void *Mem = C.Allocate(size); 478234353Sdim DependentScopeDeclRefExpr *E 479219077Sdim = new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(), 480234353Sdim SourceLocation(), 481218893Sdim DeclarationNameInfo(), 0); 482234353Sdim E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 483218893Sdim return E; 484210299Sed} 485210299Sed 486249423SdimSourceLocation CXXConstructExpr::getLocStart() const { 487219077Sdim if (isa<CXXTemporaryObjectExpr>(this)) 488249423Sdim return cast<CXXTemporaryObjectExpr>(this)->getLocStart(); 489249423Sdim return Loc; 490249423Sdim} 491219077Sdim 492249423SdimSourceLocation CXXConstructExpr::getLocEnd() const { 493249423Sdim if (isa<CXXTemporaryObjectExpr>(this)) 494249423Sdim return cast<CXXTemporaryObjectExpr>(this)->getLocEnd(); 495249423Sdim 496263508Sdim if (ParenOrBraceRange.isValid()) 497263508Sdim return ParenOrBraceRange.getEnd(); 498195341Sed 499218893Sdim SourceLocation End = Loc; 500218893Sdim for (unsigned I = getNumArgs(); I > 0; --I) { 501218893Sdim const Expr *Arg = getArg(I-1); 502218893Sdim if (!Arg->isDefaultArgument()) { 503218893Sdim SourceLocation NewEnd = Arg->getLocEnd(); 504218893Sdim if (NewEnd.isValid()) { 505218893Sdim End = NewEnd; 506218893Sdim break; 507212904Sdim } 508212904Sdim } 509193326Sed } 510193326Sed 511249423Sdim return End; 512201361Srdivacky} 513201361Srdivacky 514239462SdimSourceRange CXXOperatorCallExpr::getSourceRangeImpl() const { 515193326Sed OverloadedOperatorKind Kind = getOperator(); 516193326Sed if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) { 517193326Sed if (getNumArgs() == 1) 518193326Sed // Prefix operator 519239462Sdim return SourceRange(getOperatorLoc(), getArg(0)->getLocEnd()); 520193326Sed else 521193326Sed // Postfix operator 522239462Sdim return SourceRange(getArg(0)->getLocStart(), getOperatorLoc()); 523221345Sdim } else if (Kind == OO_Arrow) { 524221345Sdim return getArg(0)->getSourceRange(); 525193326Sed } else if (Kind == OO_Call) { 526239462Sdim return SourceRange(getArg(0)->getLocStart(), getRParenLoc()); 527193326Sed } else if (Kind == OO_Subscript) { 528239462Sdim return SourceRange(getArg(0)->getLocStart(), getRParenLoc()); 529193326Sed } else if (getNumArgs() == 1) { 530239462Sdim return SourceRange(getOperatorLoc(), getArg(0)->getLocEnd()); 531193326Sed } else if (getNumArgs() == 2) { 532239462Sdim return SourceRange(getArg(0)->getLocStart(), getArg(1)->getLocEnd()); 533193326Sed } else { 534239462Sdim return getOperatorLoc(); 535193326Sed } 536193326Sed} 537193326Sed 538221345SdimExpr *CXXMemberCallExpr::getImplicitObjectArgument() const { 539239462Sdim const Expr *Callee = getCallee()->IgnoreParens(); 540239462Sdim if (const MemberExpr *MemExpr = dyn_cast<MemberExpr>(Callee)) 541193326Sed return MemExpr->getBase(); 542239462Sdim if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(Callee)) 543239462Sdim if (BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI) 544239462Sdim return BO->getLHS(); 545193326Sed 546193326Sed // FIXME: Will eventually need to cope with member pointers. 547193326Sed return 0; 548193326Sed} 549193326Sed 550221345SdimCXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const { 551221345Sdim if (const MemberExpr *MemExpr = 552221345Sdim dyn_cast<MemberExpr>(getCallee()->IgnoreParens())) 553221345Sdim return cast<CXXMethodDecl>(MemExpr->getMemberDecl()); 554221345Sdim 555221345Sdim // FIXME: Will eventually need to cope with member pointers. 556221345Sdim return 0; 557221345Sdim} 558221345Sdim 559221345Sdim 560239462SdimCXXRecordDecl *CXXMemberCallExpr::getRecordDecl() const { 561218893Sdim Expr* ThisArg = getImplicitObjectArgument(); 562218893Sdim if (!ThisArg) 563218893Sdim return 0; 564218893Sdim 565218893Sdim if (ThisArg->getType()->isAnyPointerType()) 566218893Sdim return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl(); 567218893Sdim 568218893Sdim return ThisArg->getType()->getAsCXXRecordDecl(); 569218893Sdim} 570218893Sdim 571199482Srdivacky 572193326Sed//===----------------------------------------------------------------------===// 573193326Sed// Named casts 574193326Sed//===----------------------------------------------------------------------===// 575193326Sed 576193326Sed/// getCastName - Get the name of the C++ cast being used, e.g., 577193326Sed/// "static_cast", "dynamic_cast", "reinterpret_cast", or 578193326Sed/// "const_cast". The returned pointer must not be freed. 579193326Sedconst char *CXXNamedCastExpr::getCastName() const { 580193326Sed switch (getStmtClass()) { 581193326Sed case CXXStaticCastExprClass: return "static_cast"; 582193326Sed case CXXDynamicCastExprClass: return "dynamic_cast"; 583193326Sed case CXXReinterpretCastExprClass: return "reinterpret_cast"; 584193326Sed case CXXConstCastExprClass: return "const_cast"; 585193326Sed default: return "<invalid cast>"; 586193326Sed } 587193326Sed} 588193326Sed 589263508SdimCXXStaticCastExpr *CXXStaticCastExpr::Create(const ASTContext &C, QualType T, 590218893Sdim ExprValueKind VK, 591212904Sdim CastKind K, Expr *Op, 592212904Sdim const CXXCastPath *BasePath, 593212904Sdim TypeSourceInfo *WrittenTy, 594218893Sdim SourceLocation L, 595249423Sdim SourceLocation RParenLoc, 596249423Sdim SourceRange AngleBrackets) { 597212904Sdim unsigned PathSize = (BasePath ? BasePath->size() : 0); 598212904Sdim void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr) 599212904Sdim + PathSize * sizeof(CXXBaseSpecifier*)); 600212904Sdim CXXStaticCastExpr *E = 601218893Sdim new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 602249423Sdim RParenLoc, AngleBrackets); 603212904Sdim if (PathSize) E->setCastPath(*BasePath); 604212904Sdim return E; 605212904Sdim} 606212904Sdim 607263508SdimCXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(const ASTContext &C, 608212904Sdim unsigned PathSize) { 609212904Sdim void *Buffer = 610212904Sdim C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 611212904Sdim return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize); 612212904Sdim} 613212904Sdim 614263508SdimCXXDynamicCastExpr *CXXDynamicCastExpr::Create(const ASTContext &C, QualType T, 615218893Sdim ExprValueKind VK, 616212904Sdim CastKind K, Expr *Op, 617212904Sdim const CXXCastPath *BasePath, 618212904Sdim TypeSourceInfo *WrittenTy, 619218893Sdim SourceLocation L, 620249423Sdim SourceLocation RParenLoc, 621249423Sdim SourceRange AngleBrackets) { 622212904Sdim unsigned PathSize = (BasePath ? BasePath->size() : 0); 623212904Sdim void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr) 624212904Sdim + PathSize * sizeof(CXXBaseSpecifier*)); 625212904Sdim CXXDynamicCastExpr *E = 626218893Sdim new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 627249423Sdim RParenLoc, AngleBrackets); 628212904Sdim if (PathSize) E->setCastPath(*BasePath); 629212904Sdim return E; 630212904Sdim} 631212904Sdim 632263508SdimCXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(const ASTContext &C, 633212904Sdim unsigned PathSize) { 634212904Sdim void *Buffer = 635212904Sdim C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 636212904Sdim return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize); 637212904Sdim} 638212904Sdim 639221345Sdim/// isAlwaysNull - Return whether the result of the dynamic_cast is proven 640221345Sdim/// to always be null. For example: 641221345Sdim/// 642221345Sdim/// struct A { }; 643221345Sdim/// struct B final : A { }; 644221345Sdim/// struct C { }; 645221345Sdim/// 646221345Sdim/// C *f(B* b) { return dynamic_cast<C*>(b); } 647221345Sdimbool CXXDynamicCastExpr::isAlwaysNull() const 648221345Sdim{ 649221345Sdim QualType SrcType = getSubExpr()->getType(); 650221345Sdim QualType DestType = getType(); 651221345Sdim 652221345Sdim if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) { 653221345Sdim SrcType = SrcPTy->getPointeeType(); 654221345Sdim DestType = DestType->castAs<PointerType>()->getPointeeType(); 655221345Sdim } 656221345Sdim 657239462Sdim if (DestType->isVoidType()) 658239462Sdim return false; 659239462Sdim 660221345Sdim const CXXRecordDecl *SrcRD = 661221345Sdim cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl()); 662221345Sdim 663221345Sdim if (!SrcRD->hasAttr<FinalAttr>()) 664221345Sdim return false; 665221345Sdim 666221345Sdim const CXXRecordDecl *DestRD = 667221345Sdim cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl()); 668221345Sdim 669221345Sdim return !DestRD->isDerivedFrom(SrcRD); 670221345Sdim} 671221345Sdim 672212904SdimCXXReinterpretCastExpr * 673263508SdimCXXReinterpretCastExpr::Create(const ASTContext &C, QualType T, 674263508Sdim ExprValueKind VK, CastKind K, Expr *Op, 675212904Sdim const CXXCastPath *BasePath, 676218893Sdim TypeSourceInfo *WrittenTy, SourceLocation L, 677249423Sdim SourceLocation RParenLoc, 678249423Sdim SourceRange AngleBrackets) { 679212904Sdim unsigned PathSize = (BasePath ? BasePath->size() : 0); 680212904Sdim void *Buffer = 681212904Sdim C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 682212904Sdim CXXReinterpretCastExpr *E = 683218893Sdim new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 684249423Sdim RParenLoc, AngleBrackets); 685212904Sdim if (PathSize) E->setCastPath(*BasePath); 686212904Sdim return E; 687212904Sdim} 688212904Sdim 689212904SdimCXXReinterpretCastExpr * 690263508SdimCXXReinterpretCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) { 691212904Sdim void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr) 692212904Sdim + PathSize * sizeof(CXXBaseSpecifier*)); 693212904Sdim return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize); 694212904Sdim} 695212904Sdim 696263508SdimCXXConstCastExpr *CXXConstCastExpr::Create(const ASTContext &C, QualType T, 697218893Sdim ExprValueKind VK, Expr *Op, 698212904Sdim TypeSourceInfo *WrittenTy, 699218893Sdim SourceLocation L, 700249423Sdim SourceLocation RParenLoc, 701249423Sdim SourceRange AngleBrackets) { 702249423Sdim return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets); 703212904Sdim} 704212904Sdim 705263508SdimCXXConstCastExpr *CXXConstCastExpr::CreateEmpty(const ASTContext &C) { 706212904Sdim return new (C) CXXConstCastExpr(EmptyShell()); 707212904Sdim} 708212904Sdim 709212904SdimCXXFunctionalCastExpr * 710263508SdimCXXFunctionalCastExpr::Create(const ASTContext &C, QualType T, ExprValueKind VK, 711263508Sdim TypeSourceInfo *Written, CastKind K, Expr *Op, 712263508Sdim const CXXCastPath *BasePath, 713263508Sdim SourceLocation L, SourceLocation R) { 714212904Sdim unsigned PathSize = (BasePath ? BasePath->size() : 0); 715212904Sdim void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr) 716212904Sdim + PathSize * sizeof(CXXBaseSpecifier*)); 717212904Sdim CXXFunctionalCastExpr *E = 718263508Sdim new (Buffer) CXXFunctionalCastExpr(T, VK, Written, K, Op, PathSize, L, R); 719212904Sdim if (PathSize) E->setCastPath(*BasePath); 720212904Sdim return E; 721212904Sdim} 722212904Sdim 723212904SdimCXXFunctionalCastExpr * 724263508SdimCXXFunctionalCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) { 725212904Sdim void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr) 726212904Sdim + PathSize * sizeof(CXXBaseSpecifier*)); 727212904Sdim return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize); 728212904Sdim} 729212904Sdim 730263508SdimSourceLocation CXXFunctionalCastExpr::getLocStart() const { 731263508Sdim return getTypeInfoAsWritten()->getTypeLoc().getLocStart(); 732263508Sdim} 733263508Sdim 734263508SdimSourceLocation CXXFunctionalCastExpr::getLocEnd() const { 735263508Sdim return RParenLoc.isValid() ? RParenLoc : getSubExpr()->getLocEnd(); 736263508Sdim} 737263508Sdim 738234353SdimUserDefinedLiteral::LiteralOperatorKind 739234353SdimUserDefinedLiteral::getLiteralOperatorKind() const { 740234353Sdim if (getNumArgs() == 0) 741234353Sdim return LOK_Template; 742234353Sdim if (getNumArgs() == 2) 743234353Sdim return LOK_String; 744212904Sdim 745234353Sdim assert(getNumArgs() == 1 && "unexpected #args in literal operator call"); 746234353Sdim QualType ParamTy = 747234353Sdim cast<FunctionDecl>(getCalleeDecl())->getParamDecl(0)->getType(); 748234353Sdim if (ParamTy->isPointerType()) 749234353Sdim return LOK_Raw; 750234353Sdim if (ParamTy->isAnyCharacterType()) 751234353Sdim return LOK_Character; 752234353Sdim if (ParamTy->isIntegerType()) 753234353Sdim return LOK_Integer; 754234353Sdim if (ParamTy->isFloatingType()) 755234353Sdim return LOK_Floating; 756234353Sdim 757234353Sdim llvm_unreachable("unknown kind of literal operator"); 758234353Sdim} 759234353Sdim 760234353SdimExpr *UserDefinedLiteral::getCookedLiteral() { 761234353Sdim#ifndef NDEBUG 762234353Sdim LiteralOperatorKind LOK = getLiteralOperatorKind(); 763234353Sdim assert(LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal"); 764234353Sdim#endif 765234353Sdim return getArg(0); 766234353Sdim} 767234353Sdim 768234353Sdimconst IdentifierInfo *UserDefinedLiteral::getUDSuffix() const { 769234353Sdim return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier(); 770234353Sdim} 771234353Sdim 772201361SrdivackyCXXDefaultArgExpr * 773263508SdimCXXDefaultArgExpr::Create(const ASTContext &C, SourceLocation Loc, 774201361Srdivacky ParmVarDecl *Param, Expr *SubExpr) { 775201361Srdivacky void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *)); 776201361Srdivacky return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, 777201361Srdivacky SubExpr); 778201361Srdivacky} 779201361Srdivacky 780263508SdimCXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &C, SourceLocation Loc, 781251662Sdim FieldDecl *Field, QualType T) 782251662Sdim : Expr(CXXDefaultInitExprClass, T.getNonLValueExprType(C), 783251662Sdim T->isLValueReferenceType() ? VK_LValue : T->isRValueReferenceType() 784251662Sdim ? VK_XValue 785251662Sdim : VK_RValue, 786251662Sdim /*FIXME*/ OK_Ordinary, false, false, false, false), 787251662Sdim Field(Field), Loc(Loc) { 788251662Sdim assert(Field->hasInClassInitializer()); 789251662Sdim} 790251662Sdim 791263508SdimCXXTemporary *CXXTemporary::Create(const ASTContext &C, 792193326Sed const CXXDestructorDecl *Destructor) { 793193326Sed return new (C) CXXTemporary(Destructor); 794193326Sed} 795193326Sed 796263508SdimCXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(const ASTContext &C, 797193326Sed CXXTemporary *Temp, 798193326Sed Expr* SubExpr) { 799234353Sdim assert((SubExpr->getType()->isRecordType() || 800234353Sdim SubExpr->getType()->isArrayType()) && 801234353Sdim "Expression bound to a temporary must have record or array type!"); 802193326Sed 803193326Sed return new (C) CXXBindTemporaryExpr(Temp, SubExpr); 804193326Sed} 805193326Sed 806263508SdimCXXTemporaryObjectExpr::CXXTemporaryObjectExpr(const ASTContext &C, 807193326Sed CXXConstructorDecl *Cons, 808218893Sdim TypeSourceInfo *Type, 809243830Sdim ArrayRef<Expr*> Args, 810263508Sdim SourceRange ParenOrBraceRange, 811226633Sdim bool HadMultipleCandidates, 812249423Sdim bool ListInitialization, 813207619Srdivacky bool ZeroInitialization) 814218893Sdim : CXXConstructExpr(C, CXXTemporaryObjectExprClass, 815218893Sdim Type->getType().getNonReferenceType(), 816218893Sdim Type->getTypeLoc().getBeginLoc(), 817243830Sdim Cons, false, Args, 818249423Sdim HadMultipleCandidates, 819249423Sdim ListInitialization, ZeroInitialization, 820263508Sdim CXXConstructExpr::CK_Complete, ParenOrBraceRange), 821218893Sdim Type(Type) { 822193326Sed} 823193326Sed 824249423SdimSourceLocation CXXTemporaryObjectExpr::getLocStart() const { 825249423Sdim return Type->getTypeLoc().getBeginLoc(); 826218893Sdim} 827218893Sdim 828249423SdimSourceLocation CXXTemporaryObjectExpr::getLocEnd() const { 829263508Sdim SourceLocation Loc = getParenOrBraceRange().getEnd(); 830263508Sdim if (Loc.isInvalid() && getNumArgs()) 831263508Sdim Loc = getArg(getNumArgs()-1)->getLocEnd(); 832263508Sdim return Loc; 833249423Sdim} 834249423Sdim 835263508SdimCXXConstructExpr *CXXConstructExpr::Create(const ASTContext &C, QualType T, 836201361Srdivacky SourceLocation Loc, 837193326Sed CXXConstructorDecl *D, bool Elidable, 838243830Sdim ArrayRef<Expr*> Args, 839226633Sdim bool HadMultipleCandidates, 840234353Sdim bool ListInitialization, 841203955Srdivacky bool ZeroInitialization, 842218893Sdim ConstructionKind ConstructKind, 843263508Sdim SourceRange ParenOrBraceRange) { 844201361Srdivacky return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D, 845243830Sdim Elidable, Args, 846234353Sdim HadMultipleCandidates, ListInitialization, 847234353Sdim ZeroInitialization, ConstructKind, 848263508Sdim ParenOrBraceRange); 849193326Sed} 850193326Sed 851263508SdimCXXConstructExpr::CXXConstructExpr(const ASTContext &C, StmtClass SC, 852263508Sdim QualType T, SourceLocation Loc, 853193326Sed CXXConstructorDecl *D, bool elidable, 854243830Sdim ArrayRef<Expr*> args, 855226633Sdim bool HadMultipleCandidates, 856234353Sdim bool ListInitialization, 857226633Sdim bool ZeroInitialization, 858218893Sdim ConstructionKind ConstructKind, 859263508Sdim SourceRange ParenOrBraceRange) 860218893Sdim : Expr(SC, T, VK_RValue, OK_Ordinary, 861218893Sdim T->isDependentType(), T->isDependentType(), 862224145Sdim T->isInstantiationDependentType(), 863218893Sdim T->containsUnexpandedParameterPack()), 864263508Sdim Constructor(D), Loc(Loc), ParenOrBraceRange(ParenOrBraceRange), 865263508Sdim NumArgs(args.size()), 866226633Sdim Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates), 867234353Sdim ListInitialization(ListInitialization), 868226633Sdim ZeroInitialization(ZeroInitialization), 869226633Sdim ConstructKind(ConstructKind), Args(0) 870201361Srdivacky{ 871201361Srdivacky if (NumArgs) { 872243830Sdim Args = new (C) Stmt*[args.size()]; 873201361Srdivacky 874243830Sdim for (unsigned i = 0; i != args.size(); ++i) { 875201361Srdivacky assert(args[i] && "NULL argument in CXXConstructExpr"); 876218893Sdim 877218893Sdim if (args[i]->isValueDependent()) 878218893Sdim ExprBits.ValueDependent = true; 879224145Sdim if (args[i]->isInstantiationDependent()) 880224145Sdim ExprBits.InstantiationDependent = true; 881218893Sdim if (args[i]->containsUnexpandedParameterPack()) 882218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 883218893Sdim 884201361Srdivacky Args[i] = args[i]; 885193326Sed } 886201361Srdivacky } 887193326Sed} 888193326Sed 889234353SdimLambdaExpr::Capture::Capture(SourceLocation Loc, bool Implicit, 890234353Sdim LambdaCaptureKind Kind, VarDecl *Var, 891234353Sdim SourceLocation EllipsisLoc) 892263508Sdim : DeclAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc) 893234353Sdim{ 894234353Sdim unsigned Bits = 0; 895234353Sdim if (Implicit) 896234353Sdim Bits |= Capture_Implicit; 897234353Sdim 898234353Sdim switch (Kind) { 899234353Sdim case LCK_This: 900234353Sdim assert(Var == 0 && "'this' capture cannot have a variable!"); 901234353Sdim break; 902234353Sdim 903234353Sdim case LCK_ByCopy: 904234353Sdim Bits |= Capture_ByCopy; 905234353Sdim // Fall through 906234353Sdim case LCK_ByRef: 907234353Sdim assert(Var && "capture must have a variable!"); 908234353Sdim break; 909234353Sdim } 910263508Sdim DeclAndBits.setInt(Bits); 911234353Sdim} 912234353Sdim 913234353SdimLambdaCaptureKind LambdaExpr::Capture::getCaptureKind() const { 914263508Sdim Decl *D = DeclAndBits.getPointer(); 915263508Sdim if (!D) 916234353Sdim return LCK_This; 917234353Sdim 918263508Sdim return (DeclAndBits.getInt() & Capture_ByCopy) ? LCK_ByCopy : LCK_ByRef; 919234353Sdim} 920234353Sdim 921263508SdimLambdaExpr::LambdaExpr(QualType T, 922234353Sdim SourceRange IntroducerRange, 923234353Sdim LambdaCaptureDefault CaptureDefault, 924263508Sdim SourceLocation CaptureDefaultLoc, 925263508Sdim ArrayRef<Capture> Captures, 926234353Sdim bool ExplicitParams, 927234353Sdim bool ExplicitResultType, 928234353Sdim ArrayRef<Expr *> CaptureInits, 929234353Sdim ArrayRef<VarDecl *> ArrayIndexVars, 930234353Sdim ArrayRef<unsigned> ArrayIndexStarts, 931239462Sdim SourceLocation ClosingBrace, 932239462Sdim bool ContainsUnexpandedParameterPack) 933234353Sdim : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary, 934234353Sdim T->isDependentType(), T->isDependentType(), T->isDependentType(), 935239462Sdim ContainsUnexpandedParameterPack), 936234353Sdim IntroducerRange(IntroducerRange), 937263508Sdim CaptureDefaultLoc(CaptureDefaultLoc), 938234353Sdim NumCaptures(Captures.size()), 939234353Sdim CaptureDefault(CaptureDefault), 940234353Sdim ExplicitParams(ExplicitParams), 941234353Sdim ExplicitResultType(ExplicitResultType), 942234353Sdim ClosingBrace(ClosingBrace) 943234353Sdim{ 944234353Sdim assert(CaptureInits.size() == Captures.size() && "Wrong number of arguments"); 945234353Sdim CXXRecordDecl *Class = getLambdaClass(); 946234353Sdim CXXRecordDecl::LambdaDefinitionData &Data = Class->getLambdaData(); 947234353Sdim 948234353Sdim // FIXME: Propagate "has unexpanded parameter pack" bit. 949234353Sdim 950234353Sdim // Copy captures. 951263508Sdim const ASTContext &Context = Class->getASTContext(); 952234353Sdim Data.NumCaptures = NumCaptures; 953234353Sdim Data.NumExplicitCaptures = 0; 954234353Sdim Data.Captures = (Capture *)Context.Allocate(sizeof(Capture) * NumCaptures); 955234353Sdim Capture *ToCapture = Data.Captures; 956234353Sdim for (unsigned I = 0, N = Captures.size(); I != N; ++I) { 957234353Sdim if (Captures[I].isExplicit()) 958234353Sdim ++Data.NumExplicitCaptures; 959234353Sdim 960234353Sdim *ToCapture++ = Captures[I]; 961234353Sdim } 962234353Sdim 963234353Sdim // Copy initialization expressions for the non-static data members. 964234353Sdim Stmt **Stored = getStoredStmts(); 965234353Sdim for (unsigned I = 0, N = CaptureInits.size(); I != N; ++I) 966234353Sdim *Stored++ = CaptureInits[I]; 967234353Sdim 968234353Sdim // Copy the body of the lambda. 969234353Sdim *Stored++ = getCallOperator()->getBody(); 970234353Sdim 971234353Sdim // Copy the array index variables, if any. 972234353Sdim HasArrayIndexVars = !ArrayIndexVars.empty(); 973234353Sdim if (HasArrayIndexVars) { 974234353Sdim assert(ArrayIndexStarts.size() == NumCaptures); 975234353Sdim memcpy(getArrayIndexVars(), ArrayIndexVars.data(), 976234353Sdim sizeof(VarDecl *) * ArrayIndexVars.size()); 977234353Sdim memcpy(getArrayIndexStarts(), ArrayIndexStarts.data(), 978234353Sdim sizeof(unsigned) * Captures.size()); 979234353Sdim getArrayIndexStarts()[Captures.size()] = ArrayIndexVars.size(); 980234353Sdim } 981234353Sdim} 982234353Sdim 983263508SdimLambdaExpr *LambdaExpr::Create(const ASTContext &Context, 984234353Sdim CXXRecordDecl *Class, 985234353Sdim SourceRange IntroducerRange, 986234353Sdim LambdaCaptureDefault CaptureDefault, 987263508Sdim SourceLocation CaptureDefaultLoc, 988263508Sdim ArrayRef<Capture> Captures, 989234353Sdim bool ExplicitParams, 990234353Sdim bool ExplicitResultType, 991234353Sdim ArrayRef<Expr *> CaptureInits, 992234353Sdim ArrayRef<VarDecl *> ArrayIndexVars, 993234353Sdim ArrayRef<unsigned> ArrayIndexStarts, 994239462Sdim SourceLocation ClosingBrace, 995239462Sdim bool ContainsUnexpandedParameterPack) { 996234353Sdim // Determine the type of the expression (i.e., the type of the 997234353Sdim // function object we're creating). 998234353Sdim QualType T = Context.getTypeDeclType(Class); 999234353Sdim 1000234353Sdim unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (Captures.size() + 1); 1001243830Sdim if (!ArrayIndexVars.empty()) { 1002243830Sdim Size += sizeof(unsigned) * (Captures.size() + 1); 1003243830Sdim // Realign for following VarDecl array. 1004243830Sdim Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<VarDecl*>()); 1005243830Sdim Size += sizeof(VarDecl *) * ArrayIndexVars.size(); 1006243830Sdim } 1007234353Sdim void *Mem = Context.Allocate(Size); 1008263508Sdim return new (Mem) LambdaExpr(T, IntroducerRange, 1009263508Sdim CaptureDefault, CaptureDefaultLoc, Captures, 1010263508Sdim ExplicitParams, ExplicitResultType, 1011234353Sdim CaptureInits, ArrayIndexVars, ArrayIndexStarts, 1012239462Sdim ClosingBrace, ContainsUnexpandedParameterPack); 1013234353Sdim} 1014234353Sdim 1015263508SdimLambdaExpr *LambdaExpr::CreateDeserialized(const ASTContext &C, 1016263508Sdim unsigned NumCaptures, 1017234353Sdim unsigned NumArrayIndexVars) { 1018234353Sdim unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (NumCaptures + 1); 1019234353Sdim if (NumArrayIndexVars) 1020234353Sdim Size += sizeof(VarDecl) * NumArrayIndexVars 1021234353Sdim + sizeof(unsigned) * (NumCaptures + 1); 1022234353Sdim void *Mem = C.Allocate(Size); 1023234353Sdim return new (Mem) LambdaExpr(EmptyShell(), NumCaptures, NumArrayIndexVars > 0); 1024234353Sdim} 1025234353Sdim 1026234353SdimLambdaExpr::capture_iterator LambdaExpr::capture_begin() const { 1027234353Sdim return getLambdaClass()->getLambdaData().Captures; 1028234353Sdim} 1029234353Sdim 1030234353SdimLambdaExpr::capture_iterator LambdaExpr::capture_end() const { 1031234353Sdim return capture_begin() + NumCaptures; 1032234353Sdim} 1033234353Sdim 1034234353SdimLambdaExpr::capture_iterator LambdaExpr::explicit_capture_begin() const { 1035234353Sdim return capture_begin(); 1036234353Sdim} 1037234353Sdim 1038234353SdimLambdaExpr::capture_iterator LambdaExpr::explicit_capture_end() const { 1039234353Sdim struct CXXRecordDecl::LambdaDefinitionData &Data 1040234353Sdim = getLambdaClass()->getLambdaData(); 1041234353Sdim return Data.Captures + Data.NumExplicitCaptures; 1042234353Sdim} 1043234353Sdim 1044234353SdimLambdaExpr::capture_iterator LambdaExpr::implicit_capture_begin() const { 1045234353Sdim return explicit_capture_end(); 1046234353Sdim} 1047234353Sdim 1048234353SdimLambdaExpr::capture_iterator LambdaExpr::implicit_capture_end() const { 1049234353Sdim return capture_end(); 1050234353Sdim} 1051234353Sdim 1052234353SdimArrayRef<VarDecl *> 1053234353SdimLambdaExpr::getCaptureInitIndexVars(capture_init_iterator Iter) const { 1054234353Sdim assert(HasArrayIndexVars && "No array index-var data?"); 1055234353Sdim 1056234353Sdim unsigned Index = Iter - capture_init_begin(); 1057234353Sdim assert(Index < getLambdaClass()->getLambdaData().NumCaptures && 1058234353Sdim "Capture index out-of-range"); 1059234353Sdim VarDecl **IndexVars = getArrayIndexVars(); 1060234353Sdim unsigned *IndexStarts = getArrayIndexStarts(); 1061234353Sdim return ArrayRef<VarDecl *>(IndexVars + IndexStarts[Index], 1062234353Sdim IndexVars + IndexStarts[Index + 1]); 1063234353Sdim} 1064234353Sdim 1065234353SdimCXXRecordDecl *LambdaExpr::getLambdaClass() const { 1066234353Sdim return getType()->getAsCXXRecordDecl(); 1067234353Sdim} 1068234353Sdim 1069234353SdimCXXMethodDecl *LambdaExpr::getCallOperator() const { 1070234353Sdim CXXRecordDecl *Record = getLambdaClass(); 1071263508Sdim return Record->getLambdaCallOperator(); 1072234353Sdim} 1073234353Sdim 1074263508SdimTemplateParameterList *LambdaExpr::getTemplateParameterList() const { 1075263508Sdim CXXRecordDecl *Record = getLambdaClass(); 1076263508Sdim return Record->getGenericLambdaTemplateParameterList(); 1077263508Sdim 1078263508Sdim} 1079263508Sdim 1080234353SdimCompoundStmt *LambdaExpr::getBody() const { 1081234353Sdim if (!getStoredStmts()[NumCaptures]) 1082234353Sdim getStoredStmts()[NumCaptures] = getCallOperator()->getBody(); 1083234353Sdim 1084234353Sdim return reinterpret_cast<CompoundStmt *>(getStoredStmts()[NumCaptures]); 1085234353Sdim} 1086234353Sdim 1087234353Sdimbool LambdaExpr::isMutable() const { 1088239462Sdim return !getCallOperator()->isConst(); 1089234353Sdim} 1090234353Sdim 1091234353SdimExprWithCleanups::ExprWithCleanups(Expr *subexpr, 1092234353Sdim ArrayRef<CleanupObject> objects) 1093218893Sdim : Expr(ExprWithCleanupsClass, subexpr->getType(), 1094218893Sdim subexpr->getValueKind(), subexpr->getObjectKind(), 1095218893Sdim subexpr->isTypeDependent(), subexpr->isValueDependent(), 1096224145Sdim subexpr->isInstantiationDependent(), 1097218893Sdim subexpr->containsUnexpandedParameterPack()), 1098234353Sdim SubExpr(subexpr) { 1099234353Sdim ExprWithCleanupsBits.NumObjects = objects.size(); 1100234353Sdim for (unsigned i = 0, e = objects.size(); i != e; ++i) 1101234353Sdim getObjectsBuffer()[i] = objects[i]; 1102193326Sed} 1103193326Sed 1104263508SdimExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, Expr *subexpr, 1105234353Sdim ArrayRef<CleanupObject> objects) { 1106234353Sdim size_t size = sizeof(ExprWithCleanups) 1107234353Sdim + objects.size() * sizeof(CleanupObject); 1108234353Sdim void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>()); 1109234353Sdim return new (buffer) ExprWithCleanups(subexpr, objects); 1110208600Srdivacky} 1111208600Srdivacky 1112234353SdimExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects) 1113234353Sdim : Expr(ExprWithCleanupsClass, empty) { 1114234353Sdim ExprWithCleanupsBits.NumObjects = numObjects; 1115234353Sdim} 1116208600Srdivacky 1117263508SdimExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, 1118263508Sdim EmptyShell empty, 1119234353Sdim unsigned numObjects) { 1120234353Sdim size_t size = sizeof(ExprWithCleanups) + numObjects * sizeof(CleanupObject); 1121234353Sdim void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>()); 1122234353Sdim return new (buffer) ExprWithCleanups(empty, numObjects); 1123193326Sed} 1124193326Sed 1125218893SdimCXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type, 1126193326Sed SourceLocation LParenLoc, 1127243830Sdim ArrayRef<Expr*> Args, 1128193326Sed SourceLocation RParenLoc) 1129218893Sdim : Expr(CXXUnresolvedConstructExprClass, 1130218893Sdim Type->getType().getNonReferenceType(), 1131224145Sdim (Type->getType()->isLValueReferenceType() ? VK_LValue 1132224145Sdim :Type->getType()->isRValueReferenceType()? VK_XValue 1133224145Sdim :VK_RValue), 1134224145Sdim OK_Ordinary, 1135224145Sdim Type->getType()->isDependentType(), true, true, 1136218893Sdim Type->getType()->containsUnexpandedParameterPack()), 1137218893Sdim Type(Type), 1138193326Sed LParenLoc(LParenLoc), 1139193326Sed RParenLoc(RParenLoc), 1140243830Sdim NumArgs(Args.size()) { 1141193326Sed Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1); 1142243830Sdim for (unsigned I = 0; I != Args.size(); ++I) { 1143218893Sdim if (Args[I]->containsUnexpandedParameterPack()) 1144218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 1145218893Sdim 1146218893Sdim StoredArgs[I] = Args[I]; 1147218893Sdim } 1148193326Sed} 1149193326Sed 1150193326SedCXXUnresolvedConstructExpr * 1151263508SdimCXXUnresolvedConstructExpr::Create(const ASTContext &C, 1152218893Sdim TypeSourceInfo *Type, 1153193326Sed SourceLocation LParenLoc, 1154243830Sdim ArrayRef<Expr*> Args, 1155193326Sed SourceLocation RParenLoc) { 1156193326Sed void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) + 1157243830Sdim sizeof(Expr *) * Args.size()); 1158243830Sdim return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc, Args, RParenLoc); 1159193326Sed} 1160193326Sed 1161210299SedCXXUnresolvedConstructExpr * 1162263508SdimCXXUnresolvedConstructExpr::CreateEmpty(const ASTContext &C, unsigned NumArgs) { 1163210299Sed Stmt::EmptyShell Empty; 1164210299Sed void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) + 1165210299Sed sizeof(Expr *) * NumArgs); 1166210299Sed return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs); 1167210299Sed} 1168210299Sed 1169249423SdimSourceLocation CXXUnresolvedConstructExpr::getLocStart() const { 1170249423Sdim return Type->getTypeLoc().getBeginLoc(); 1171193326Sed} 1172193326Sed 1173263508SdimCXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(const ASTContext &C, 1174200583Srdivacky Expr *Base, QualType BaseType, 1175200583Srdivacky bool IsArrow, 1176198092Srdivacky SourceLocation OperatorLoc, 1177234353Sdim NestedNameSpecifierLoc QualifierLoc, 1178234353Sdim SourceLocation TemplateKWLoc, 1179198092Srdivacky NamedDecl *FirstQualifierFoundInScope, 1180212904Sdim DeclarationNameInfo MemberNameInfo, 1181199990Srdivacky const TemplateArgumentListInfo *TemplateArgs) 1182218893Sdim : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, 1183224145Sdim VK_LValue, OK_Ordinary, true, true, true, 1184218893Sdim ((Base && Base->containsUnexpandedParameterPack()) || 1185221345Sdim (QualifierLoc && 1186221345Sdim QualifierLoc.getNestedNameSpecifier() 1187221345Sdim ->containsUnexpandedParameterPack()) || 1188218893Sdim MemberNameInfo.containsUnexpandedParameterPack())), 1189200583Srdivacky Base(Base), BaseType(BaseType), IsArrow(IsArrow), 1190234353Sdim HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid()), 1191221345Sdim OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 1192198092Srdivacky FirstQualifierFoundInScope(FirstQualifierFoundInScope), 1193212904Sdim MemberNameInfo(MemberNameInfo) { 1194218893Sdim if (TemplateArgs) { 1195218893Sdim bool Dependent = true; 1196224145Sdim bool InstantiationDependent = true; 1197218893Sdim bool ContainsUnexpandedParameterPack = false; 1198234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, 1199234353Sdim Dependent, 1200234353Sdim InstantiationDependent, 1201234353Sdim ContainsUnexpandedParameterPack); 1202218893Sdim if (ContainsUnexpandedParameterPack) 1203218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 1204234353Sdim } else if (TemplateKWLoc.isValid()) { 1205234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 1206218893Sdim } 1207193326Sed} 1208193326Sed 1209263508SdimCXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(const ASTContext &C, 1210218893Sdim Expr *Base, QualType BaseType, 1211218893Sdim bool IsArrow, 1212218893Sdim SourceLocation OperatorLoc, 1213221345Sdim NestedNameSpecifierLoc QualifierLoc, 1214218893Sdim NamedDecl *FirstQualifierFoundInScope, 1215218893Sdim DeclarationNameInfo MemberNameInfo) 1216218893Sdim : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, 1217224145Sdim VK_LValue, OK_Ordinary, true, true, true, 1218218893Sdim ((Base && Base->containsUnexpandedParameterPack()) || 1219221345Sdim (QualifierLoc && 1220221345Sdim QualifierLoc.getNestedNameSpecifier()-> 1221221345Sdim containsUnexpandedParameterPack()) || 1222218893Sdim MemberNameInfo.containsUnexpandedParameterPack())), 1223218893Sdim Base(Base), BaseType(BaseType), IsArrow(IsArrow), 1224234353Sdim HasTemplateKWAndArgsInfo(false), 1225234353Sdim OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 1226218893Sdim FirstQualifierFoundInScope(FirstQualifierFoundInScope), 1227218893Sdim MemberNameInfo(MemberNameInfo) { } 1228218893Sdim 1229199990SrdivackyCXXDependentScopeMemberExpr * 1230263508SdimCXXDependentScopeMemberExpr::Create(const ASTContext &C, 1231200583Srdivacky Expr *Base, QualType BaseType, bool IsArrow, 1232198092Srdivacky SourceLocation OperatorLoc, 1233221345Sdim NestedNameSpecifierLoc QualifierLoc, 1234234353Sdim SourceLocation TemplateKWLoc, 1235198092Srdivacky NamedDecl *FirstQualifierFoundInScope, 1236212904Sdim DeclarationNameInfo MemberNameInfo, 1237199990Srdivacky const TemplateArgumentListInfo *TemplateArgs) { 1238234353Sdim if (!TemplateArgs && !TemplateKWLoc.isValid()) 1239200583Srdivacky return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType, 1240200583Srdivacky IsArrow, OperatorLoc, 1241221345Sdim QualifierLoc, 1242200583Srdivacky FirstQualifierFoundInScope, 1243212904Sdim MemberNameInfo); 1244193326Sed 1245234353Sdim unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0; 1246234353Sdim std::size_t size = sizeof(CXXDependentScopeMemberExpr) 1247234353Sdim + ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1248199990Srdivacky 1249218893Sdim void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>()); 1250200583Srdivacky return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType, 1251200583Srdivacky IsArrow, OperatorLoc, 1252221345Sdim QualifierLoc, 1253234353Sdim TemplateKWLoc, 1254200583Srdivacky FirstQualifierFoundInScope, 1255212904Sdim MemberNameInfo, TemplateArgs); 1256193326Sed} 1257193326Sed 1258210299SedCXXDependentScopeMemberExpr * 1259263508SdimCXXDependentScopeMemberExpr::CreateEmpty(const ASTContext &C, 1260234353Sdim bool HasTemplateKWAndArgsInfo, 1261210299Sed unsigned NumTemplateArgs) { 1262234353Sdim if (!HasTemplateKWAndArgsInfo) 1263210299Sed return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(), 1264234353Sdim 0, SourceLocation(), 1265221345Sdim NestedNameSpecifierLoc(), 0, 1266212904Sdim DeclarationNameInfo()); 1267210299Sed 1268210299Sed std::size_t size = sizeof(CXXDependentScopeMemberExpr) + 1269234353Sdim ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1270218893Sdim void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>()); 1271210299Sed CXXDependentScopeMemberExpr *E 1272210299Sed = new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(), 1273234353Sdim 0, SourceLocation(), 1274234353Sdim NestedNameSpecifierLoc(), 1275234353Sdim SourceLocation(), 0, 1276212904Sdim DeclarationNameInfo(), 0); 1277234353Sdim E->HasTemplateKWAndArgsInfo = true; 1278210299Sed return E; 1279210299Sed} 1280210299Sed 1281221345Sdimbool CXXDependentScopeMemberExpr::isImplicitAccess() const { 1282221345Sdim if (Base == 0) 1283221345Sdim return true; 1284221345Sdim 1285221345Sdim return cast<Expr>(Base)->isImplicitCXXThis(); 1286221345Sdim} 1287221345Sdim 1288221345Sdimstatic bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin, 1289221345Sdim UnresolvedSetIterator end) { 1290221345Sdim do { 1291221345Sdim NamedDecl *decl = *begin; 1292221345Sdim if (isa<UnresolvedUsingValueDecl>(decl)) 1293221345Sdim return false; 1294221345Sdim if (isa<UsingShadowDecl>(decl)) 1295221345Sdim decl = cast<UsingShadowDecl>(decl)->getUnderlyingDecl(); 1296221345Sdim 1297221345Sdim // Unresolved member expressions should only contain methods and 1298221345Sdim // method templates. 1299221345Sdim assert(isa<CXXMethodDecl>(decl) || isa<FunctionTemplateDecl>(decl)); 1300221345Sdim 1301221345Sdim if (isa<FunctionTemplateDecl>(decl)) 1302221345Sdim decl = cast<FunctionTemplateDecl>(decl)->getTemplatedDecl(); 1303221345Sdim if (cast<CXXMethodDecl>(decl)->isStatic()) 1304221345Sdim return false; 1305221345Sdim } while (++begin != end); 1306221345Sdim 1307221345Sdim return true; 1308221345Sdim} 1309221345Sdim 1310263508SdimUnresolvedMemberExpr::UnresolvedMemberExpr(const ASTContext &C, 1311199990Srdivacky bool HasUnresolvedUsing, 1312200583Srdivacky Expr *Base, QualType BaseType, 1313200583Srdivacky bool IsArrow, 1314199990Srdivacky SourceLocation OperatorLoc, 1315221345Sdim NestedNameSpecifierLoc QualifierLoc, 1316234353Sdim SourceLocation TemplateKWLoc, 1317212904Sdim const DeclarationNameInfo &MemberNameInfo, 1318208600Srdivacky const TemplateArgumentListInfo *TemplateArgs, 1319208600Srdivacky UnresolvedSetIterator Begin, 1320208600Srdivacky UnresolvedSetIterator End) 1321234353Sdim : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, TemplateKWLoc, 1322234353Sdim MemberNameInfo, TemplateArgs, Begin, End, 1323218893Sdim // Dependent 1324218893Sdim ((Base && Base->isTypeDependent()) || 1325218893Sdim BaseType->isDependentType()), 1326224145Sdim ((Base && Base->isInstantiationDependent()) || 1327224145Sdim BaseType->isInstantiationDependentType()), 1328218893Sdim // Contains unexpanded parameter pack 1329218893Sdim ((Base && Base->containsUnexpandedParameterPack()) || 1330218893Sdim BaseType->containsUnexpandedParameterPack())), 1331203955Srdivacky IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing), 1332203955Srdivacky Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) { 1333221345Sdim 1334221345Sdim // Check whether all of the members are non-static member functions, 1335221345Sdim // and if so, mark give this bound-member type instead of overload type. 1336221345Sdim if (hasOnlyNonStaticMemberFunctions(Begin, End)) 1337221345Sdim setType(C.BoundMemberTy); 1338199990Srdivacky} 1339199990Srdivacky 1340221345Sdimbool UnresolvedMemberExpr::isImplicitAccess() const { 1341221345Sdim if (Base == 0) 1342221345Sdim return true; 1343221345Sdim 1344221345Sdim return cast<Expr>(Base)->isImplicitCXXThis(); 1345221345Sdim} 1346221345Sdim 1347199990SrdivackyUnresolvedMemberExpr * 1348263508SdimUnresolvedMemberExpr::Create(const ASTContext &C, bool HasUnresolvedUsing, 1349200583Srdivacky Expr *Base, QualType BaseType, bool IsArrow, 1350199990Srdivacky SourceLocation OperatorLoc, 1351221345Sdim NestedNameSpecifierLoc QualifierLoc, 1352234353Sdim SourceLocation TemplateKWLoc, 1353212904Sdim const DeclarationNameInfo &MemberNameInfo, 1354208600Srdivacky const TemplateArgumentListInfo *TemplateArgs, 1355208600Srdivacky UnresolvedSetIterator Begin, 1356208600Srdivacky UnresolvedSetIterator End) { 1357199990Srdivacky std::size_t size = sizeof(UnresolvedMemberExpr); 1358199990Srdivacky if (TemplateArgs) 1359234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size()); 1360234353Sdim else if (TemplateKWLoc.isValid()) 1361234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(0); 1362199990Srdivacky 1363218893Sdim void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>()); 1364208600Srdivacky return new (Mem) UnresolvedMemberExpr(C, 1365218893Sdim HasUnresolvedUsing, Base, BaseType, 1366234353Sdim IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc, 1367212904Sdim MemberNameInfo, TemplateArgs, Begin, End); 1368199990Srdivacky} 1369199990Srdivacky 1370210299SedUnresolvedMemberExpr * 1371263508SdimUnresolvedMemberExpr::CreateEmpty(const ASTContext &C, 1372263508Sdim bool HasTemplateKWAndArgsInfo, 1373218893Sdim unsigned NumTemplateArgs) { 1374210299Sed std::size_t size = sizeof(UnresolvedMemberExpr); 1375234353Sdim if (HasTemplateKWAndArgsInfo) 1376234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1377210299Sed 1378218893Sdim void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>()); 1379210299Sed UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell()); 1380234353Sdim E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 1381210299Sed return E; 1382210299Sed} 1383210299Sed 1384203955SrdivackyCXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const { 1385203955Srdivacky // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this. 1386203955Srdivacky 1387203955Srdivacky // If there was a nested name specifier, it names the naming class. 1388203955Srdivacky // It can't be dependent: after all, we were actually able to do the 1389203955Srdivacky // lookup. 1390207619Srdivacky CXXRecordDecl *Record = 0; 1391203955Srdivacky if (getQualifier()) { 1392218893Sdim const Type *T = getQualifier()->getAsType(); 1393203955Srdivacky assert(T && "qualifier in member expression does not name type"); 1394207619Srdivacky Record = T->getAsCXXRecordDecl(); 1395207619Srdivacky assert(Record && "qualifier in member expression does not name record"); 1396207619Srdivacky } 1397203955Srdivacky // Otherwise the naming class must have been the base class. 1398207619Srdivacky else { 1399203955Srdivacky QualType BaseType = getBaseType().getNonReferenceType(); 1400203955Srdivacky if (isArrow()) { 1401203955Srdivacky const PointerType *PT = BaseType->getAs<PointerType>(); 1402203955Srdivacky assert(PT && "base of arrow member access is not pointer"); 1403203955Srdivacky BaseType = PT->getPointeeType(); 1404203955Srdivacky } 1405203955Srdivacky 1406207619Srdivacky Record = BaseType->getAsCXXRecordDecl(); 1407207619Srdivacky assert(Record && "base of member expression does not name record"); 1408203955Srdivacky } 1409203955Srdivacky 1410207619Srdivacky return Record; 1411203955Srdivacky} 1412203955Srdivacky 1413218893SdimSubstNonTypeTemplateParmPackExpr:: 1414218893SdimSubstNonTypeTemplateParmPackExpr(QualType T, 1415218893Sdim NonTypeTemplateParmDecl *Param, 1416218893Sdim SourceLocation NameLoc, 1417218893Sdim const TemplateArgument &ArgPack) 1418218893Sdim : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary, 1419224145Sdim true, true, true, true), 1420218893Sdim Param(Param), Arguments(ArgPack.pack_begin()), 1421218893Sdim NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { } 1422218893Sdim 1423218893SdimTemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const { 1424218893Sdim return TemplateArgument(Arguments, NumArguments); 1425199990Srdivacky} 1426199990Srdivacky 1427243830SdimFunctionParmPackExpr::FunctionParmPackExpr(QualType T, ParmVarDecl *ParamPack, 1428243830Sdim SourceLocation NameLoc, 1429243830Sdim unsigned NumParams, 1430243830Sdim Decl * const *Params) 1431243830Sdim : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary, 1432243830Sdim true, true, true, true), 1433243830Sdim ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) { 1434243830Sdim if (Params) 1435243830Sdim std::uninitialized_copy(Params, Params + NumParams, 1436243830Sdim reinterpret_cast<Decl**>(this+1)); 1437243830Sdim} 1438243830Sdim 1439243830SdimFunctionParmPackExpr * 1440263508SdimFunctionParmPackExpr::Create(const ASTContext &Context, QualType T, 1441243830Sdim ParmVarDecl *ParamPack, SourceLocation NameLoc, 1442249423Sdim ArrayRef<Decl *> Params) { 1443243830Sdim return new (Context.Allocate(sizeof(FunctionParmPackExpr) + 1444243830Sdim sizeof(ParmVarDecl*) * Params.size())) 1445243830Sdim FunctionParmPackExpr(T, ParamPack, NameLoc, Params.size(), Params.data()); 1446243830Sdim} 1447243830Sdim 1448243830SdimFunctionParmPackExpr * 1449263508SdimFunctionParmPackExpr::CreateEmpty(const ASTContext &Context, 1450263508Sdim unsigned NumParams) { 1451243830Sdim return new (Context.Allocate(sizeof(FunctionParmPackExpr) + 1452243830Sdim sizeof(ParmVarDecl*) * NumParams)) 1453243830Sdim FunctionParmPackExpr(QualType(), 0, SourceLocation(), 0, 0); 1454243830Sdim} 1455243830Sdim 1456234353SdimTypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind, 1457234353Sdim ArrayRef<TypeSourceInfo *> Args, 1458234353Sdim SourceLocation RParenLoc, 1459234353Sdim bool Value) 1460234353Sdim : Expr(TypeTraitExprClass, T, VK_RValue, OK_Ordinary, 1461234353Sdim /*TypeDependent=*/false, 1462234353Sdim /*ValueDependent=*/false, 1463234353Sdim /*InstantiationDependent=*/false, 1464234353Sdim /*ContainsUnexpandedParameterPack=*/false), 1465234353Sdim Loc(Loc), RParenLoc(RParenLoc) 1466234353Sdim{ 1467234353Sdim TypeTraitExprBits.Kind = Kind; 1468234353Sdim TypeTraitExprBits.Value = Value; 1469234353Sdim TypeTraitExprBits.NumArgs = Args.size(); 1470218893Sdim 1471234353Sdim TypeSourceInfo **ToArgs = getTypeSourceInfos(); 1472234353Sdim 1473234353Sdim for (unsigned I = 0, N = Args.size(); I != N; ++I) { 1474234353Sdim if (Args[I]->getType()->isDependentType()) 1475234353Sdim setValueDependent(true); 1476234353Sdim if (Args[I]->getType()->isInstantiationDependentType()) 1477234353Sdim setInstantiationDependent(true); 1478234353Sdim if (Args[I]->getType()->containsUnexpandedParameterPack()) 1479234353Sdim setContainsUnexpandedParameterPack(true); 1480234353Sdim 1481234353Sdim ToArgs[I] = Args[I]; 1482234353Sdim } 1483234353Sdim} 1484234353Sdim 1485263508SdimTypeTraitExpr *TypeTraitExpr::Create(const ASTContext &C, QualType T, 1486234353Sdim SourceLocation Loc, 1487234353Sdim TypeTrait Kind, 1488234353Sdim ArrayRef<TypeSourceInfo *> Args, 1489234353Sdim SourceLocation RParenLoc, 1490234353Sdim bool Value) { 1491234353Sdim unsigned Size = sizeof(TypeTraitExpr) + sizeof(TypeSourceInfo*) * Args.size(); 1492234353Sdim void *Mem = C.Allocate(Size); 1493234353Sdim return new (Mem) TypeTraitExpr(T, Loc, Kind, Args, RParenLoc, Value); 1494234353Sdim} 1495234353Sdim 1496263508SdimTypeTraitExpr *TypeTraitExpr::CreateDeserialized(const ASTContext &C, 1497234353Sdim unsigned NumArgs) { 1498234353Sdim unsigned Size = sizeof(TypeTraitExpr) + sizeof(TypeSourceInfo*) * NumArgs; 1499234353Sdim void *Mem = C.Allocate(Size); 1500234353Sdim return new (Mem) TypeTraitExpr(EmptyShell()); 1501234353Sdim} 1502234353Sdim 1503234353Sdimvoid ArrayTypeTraitExpr::anchor() { } 1504