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 43207619SrdivackyQualType CXXTypeidExpr::getTypeOperand() const { 44207619Srdivacky assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)"); 45207619Srdivacky return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType() 46207619Srdivacky .getUnqualifiedType(); 47207619Srdivacky} 48207619Srdivacky 49218893SdimQualType CXXUuidofExpr::getTypeOperand() const { 50218893Sdim assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)"); 51218893Sdim return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType() 52218893Sdim .getUnqualifiedType(); 53193326Sed} 54193326Sed 55243830Sdim// static 56243830SdimUuidAttr *CXXUuidofExpr::GetUuidAttrOfType(QualType QT) { 57243830Sdim // Optionally remove one level of pointer, reference or array indirection. 58243830Sdim const Type *Ty = QT.getTypePtr(); 59243830Sdim if (QT->isPointerType() || QT->isReferenceType()) 60243830Sdim Ty = QT->getPointeeType().getTypePtr(); 61243830Sdim else if (QT->isArrayType()) 62243830Sdim Ty = cast<ArrayType>(QT)->getElementType().getTypePtr(); 63243830Sdim 64243830Sdim // Loop all record redeclaration looking for an uuid attribute. 65243830Sdim CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); 66243830Sdim for (CXXRecordDecl::redecl_iterator I = RD->redecls_begin(), 67243830Sdim E = RD->redecls_end(); I != E; ++I) { 68243830Sdim if (UuidAttr *Uuid = I->getAttr<UuidAttr>()) 69243830Sdim return Uuid; 70243830Sdim } 71243830Sdim 72243830Sdim return 0; 73243830Sdim} 74243830Sdim 75210299Sed// CXXScalarValueInitExpr 76249423SdimSourceLocation CXXScalarValueInitExpr::getLocStart() const { 77249423Sdim return TypeInfo ? TypeInfo->getTypeLoc().getBeginLoc() : RParenLoc; 78193326Sed} 79193326Sed 80193326Sed// CXXNewExpr 81203955SrdivackyCXXNewExpr::CXXNewExpr(ASTContext &C, bool globalNew, FunctionDecl *operatorNew, 82234353Sdim FunctionDecl *operatorDelete, 83234353Sdim bool usualArrayDeleteWantsSize, 84243830Sdim ArrayRef<Expr*> placementArgs, 85234353Sdim SourceRange typeIdParens, Expr *arraySize, 86234353Sdim InitializationStyle initializationStyle, 87234353Sdim Expr *initializer, QualType ty, 88234353Sdim TypeSourceInfo *allocatedTypeInfo, 89243830Sdim SourceRange Range, SourceRange directInitRange) 90218893Sdim : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary, 91218893Sdim ty->isDependentType(), ty->isDependentType(), 92224145Sdim ty->isInstantiationDependentType(), 93218893Sdim ty->containsUnexpandedParameterPack()), 94234353Sdim SubExprs(0), OperatorNew(operatorNew), OperatorDelete(operatorDelete), 95234353Sdim AllocatedTypeInfo(allocatedTypeInfo), TypeIdParens(typeIdParens), 96243830Sdim Range(Range), DirectInitRange(directInitRange), 97234353Sdim GlobalNew(globalNew), UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) { 98234353Sdim assert((initializer != 0 || initializationStyle == NoInit) && 99234353Sdim "Only NoInit can have no initializer."); 100234353Sdim StoredInitializationStyle = initializer ? initializationStyle + 1 : 0; 101243830Sdim AllocateArgsArray(C, arraySize != 0, placementArgs.size(), initializer != 0); 102193326Sed unsigned i = 0; 103218893Sdim if (Array) { 104224145Sdim if (arraySize->isInstantiationDependent()) 105224145Sdim ExprBits.InstantiationDependent = true; 106224145Sdim 107218893Sdim if (arraySize->containsUnexpandedParameterPack()) 108218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 109218893Sdim 110193326Sed SubExprs[i++] = arraySize; 111218893Sdim } 112218893Sdim 113234353Sdim if (initializer) { 114234353Sdim if (initializer->isInstantiationDependent()) 115224145Sdim ExprBits.InstantiationDependent = true; 116234353Sdim 117234353Sdim if (initializer->containsUnexpandedParameterPack()) 118218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 119218893Sdim 120234353Sdim SubExprs[i++] = initializer; 121218893Sdim } 122218893Sdim 123243830Sdim for (unsigned j = 0; j != placementArgs.size(); ++j) { 124234353Sdim if (placementArgs[j]->isInstantiationDependent()) 125224145Sdim ExprBits.InstantiationDependent = true; 126234353Sdim if (placementArgs[j]->containsUnexpandedParameterPack()) 127218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 128218893Sdim 129234353Sdim SubExprs[i++] = placementArgs[j]; 130218893Sdim } 131243830Sdim 132243830Sdim switch (getInitializationStyle()) { 133243830Sdim case CallInit: 134243830Sdim this->Range.setEnd(DirectInitRange.getEnd()); break; 135243830Sdim case ListInit: 136243830Sdim this->Range.setEnd(getInitializer()->getSourceRange().getEnd()); break; 137243830Sdim default: break; 138243830Sdim } 139193326Sed} 140193326Sed 141208600Srdivackyvoid CXXNewExpr::AllocateArgsArray(ASTContext &C, bool isArray, 142234353Sdim unsigned numPlaceArgs, bool hasInitializer){ 143208600Srdivacky assert(SubExprs == 0 && "SubExprs already allocated"); 144208600Srdivacky Array = isArray; 145208600Srdivacky NumPlacementArgs = numPlaceArgs; 146234353Sdim 147234353Sdim unsigned TotalSize = Array + hasInitializer + NumPlacementArgs; 148208600Srdivacky SubExprs = new (C) Stmt*[TotalSize]; 149208600Srdivacky} 150208600Srdivacky 151221345Sdimbool CXXNewExpr::shouldNullCheckAllocation(ASTContext &Ctx) const { 152221345Sdim return getOperatorNew()->getType()-> 153221345Sdim castAs<FunctionProtoType>()->isNothrow(Ctx); 154221345Sdim} 155208600Srdivacky 156193326Sed// CXXDeleteExpr 157218893SdimQualType CXXDeleteExpr::getDestroyedType() const { 158218893Sdim const Expr *Arg = getArgument(); 159218893Sdim // The type-to-delete may not be a pointer if it's a dependent type. 160218893Sdim const QualType ArgType = Arg->getType(); 161193326Sed 162218893Sdim if (ArgType->isDependentType() && !ArgType->isPointerType()) 163218893Sdim return QualType(); 164218893Sdim 165218893Sdim return ArgType->getAs<PointerType>()->getPointeeType(); 166198092Srdivacky} 167198092Srdivacky 168218893Sdim// CXXPseudoDestructorExpr 169204643SrdivackyPseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info) 170204643Srdivacky : Type(Info) 171204643Srdivacky{ 172208600Srdivacky Location = Info->getTypeLoc().getLocalSourceRange().getBegin(); 173204643Srdivacky} 174204643Srdivacky 175218893SdimCXXPseudoDestructorExpr::CXXPseudoDestructorExpr(ASTContext &Context, 176219077Sdim Expr *Base, bool isArrow, SourceLocation OperatorLoc, 177219077Sdim NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType, 178219077Sdim SourceLocation ColonColonLoc, SourceLocation TildeLoc, 179219077Sdim PseudoDestructorTypeStorage DestroyedType) 180218893Sdim : Expr(CXXPseudoDestructorExprClass, 181251662Sdim Context.getPointerType(Context.getFunctionType(Context.VoidTy, None, 182218893Sdim FunctionProtoType::ExtProtoInfo())), 183218893Sdim VK_RValue, OK_Ordinary, 184218893Sdim /*isTypeDependent=*/(Base->isTypeDependent() || 185218893Sdim (DestroyedType.getTypeSourceInfo() && 186218893Sdim DestroyedType.getTypeSourceInfo()->getType()->isDependentType())), 187218893Sdim /*isValueDependent=*/Base->isValueDependent(), 188224145Sdim (Base->isInstantiationDependent() || 189224145Sdim (QualifierLoc && 190224145Sdim QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) || 191224145Sdim (ScopeType && 192224145Sdim ScopeType->getType()->isInstantiationDependentType()) || 193224145Sdim (DestroyedType.getTypeSourceInfo() && 194224145Sdim DestroyedType.getTypeSourceInfo()->getType() 195224145Sdim ->isInstantiationDependentType())), 196218893Sdim // ContainsUnexpandedParameterPack 197218893Sdim (Base->containsUnexpandedParameterPack() || 198219077Sdim (QualifierLoc && 199219077Sdim QualifierLoc.getNestedNameSpecifier() 200219077Sdim ->containsUnexpandedParameterPack()) || 201218893Sdim (ScopeType && 202218893Sdim ScopeType->getType()->containsUnexpandedParameterPack()) || 203218893Sdim (DestroyedType.getTypeSourceInfo() && 204218893Sdim DestroyedType.getTypeSourceInfo()->getType() 205218893Sdim ->containsUnexpandedParameterPack()))), 206218893Sdim Base(static_cast<Stmt *>(Base)), IsArrow(isArrow), 207219077Sdim OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 208218893Sdim ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc), 209218893Sdim DestroyedType(DestroyedType) { } 210218893Sdim 211204643SrdivackyQualType CXXPseudoDestructorExpr::getDestroyedType() const { 212204643Srdivacky if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) 213204643Srdivacky return TInfo->getType(); 214204643Srdivacky 215204643Srdivacky return QualType(); 216204643Srdivacky} 217204643Srdivacky 218249423SdimSourceLocation CXXPseudoDestructorExpr::getLocEnd() const { 219204643Srdivacky SourceLocation End = DestroyedType.getLocation(); 220204643Srdivacky if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) 221208600Srdivacky End = TInfo->getTypeLoc().getLocalSourceRange().getEnd(); 222249423Sdim return End; 223204643Srdivacky} 224204643Srdivacky 225199990Srdivacky// UnresolvedLookupExpr 226199990SrdivackyUnresolvedLookupExpr * 227218893SdimUnresolvedLookupExpr::Create(ASTContext &C, 228203955Srdivacky CXXRecordDecl *NamingClass, 229221345Sdim NestedNameSpecifierLoc QualifierLoc, 230234353Sdim SourceLocation TemplateKWLoc, 231212904Sdim const DeclarationNameInfo &NameInfo, 232212904Sdim bool ADL, 233234353Sdim const TemplateArgumentListInfo *Args, 234234353Sdim UnresolvedSetIterator Begin, 235234353Sdim UnresolvedSetIterator End) 236199990Srdivacky{ 237234353Sdim assert(Args || TemplateKWLoc.isValid()); 238234353Sdim unsigned num_args = Args ? Args->size() : 0; 239234353Sdim void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) + 240234353Sdim ASTTemplateKWAndArgsInfo::sizeFor(num_args)); 241234353Sdim return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc, 242234353Sdim TemplateKWLoc, NameInfo, 243234353Sdim ADL, /*Overload*/ true, Args, 244243830Sdim Begin, End); 245199990Srdivacky} 246199990Srdivacky 247210299SedUnresolvedLookupExpr * 248234353SdimUnresolvedLookupExpr::CreateEmpty(ASTContext &C, 249234353Sdim bool HasTemplateKWAndArgsInfo, 250218893Sdim unsigned NumTemplateArgs) { 251210299Sed std::size_t size = sizeof(UnresolvedLookupExpr); 252234353Sdim if (HasTemplateKWAndArgsInfo) 253234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 254210299Sed 255218893Sdim void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>()); 256210299Sed UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell()); 257234353Sdim E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 258210299Sed return E; 259210299Sed} 260210299Sed 261218893SdimOverloadExpr::OverloadExpr(StmtClass K, ASTContext &C, 262221345Sdim NestedNameSpecifierLoc QualifierLoc, 263234353Sdim SourceLocation TemplateKWLoc, 264212904Sdim const DeclarationNameInfo &NameInfo, 265218893Sdim const TemplateArgumentListInfo *TemplateArgs, 266208600Srdivacky UnresolvedSetIterator Begin, 267218893Sdim UnresolvedSetIterator End, 268218893Sdim bool KnownDependent, 269224145Sdim bool KnownInstantiationDependent, 270218893Sdim bool KnownContainsUnexpandedParameterPack) 271218893Sdim : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent, 272218893Sdim KnownDependent, 273224145Sdim (KnownInstantiationDependent || 274224145Sdim NameInfo.isInstantiationDependent() || 275224145Sdim (QualifierLoc && 276224145Sdim QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), 277218893Sdim (KnownContainsUnexpandedParameterPack || 278218893Sdim NameInfo.containsUnexpandedParameterPack() || 279221345Sdim (QualifierLoc && 280221345Sdim QualifierLoc.getNestedNameSpecifier() 281221345Sdim ->containsUnexpandedParameterPack()))), 282234353Sdim NameInfo(NameInfo), QualifierLoc(QualifierLoc), 283234353Sdim Results(0), NumResults(End - Begin), 284234353Sdim HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid()) 285208600Srdivacky{ 286210299Sed NumResults = End - Begin; 287208600Srdivacky if (NumResults) { 288218893Sdim // Determine whether this expression is type-dependent. 289218893Sdim for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) { 290218893Sdim if ((*I)->getDeclContext()->isDependentContext() || 291218893Sdim isa<UnresolvedUsingValueDecl>(*I)) { 292218893Sdim ExprBits.TypeDependent = true; 293218893Sdim ExprBits.ValueDependent = true; 294239462Sdim ExprBits.InstantiationDependent = true; 295218893Sdim } 296218893Sdim } 297218893Sdim 298208600Srdivacky Results = static_cast<DeclAccessPair *>( 299208600Srdivacky C.Allocate(sizeof(DeclAccessPair) * NumResults, 300218893Sdim llvm::alignOf<DeclAccessPair>())); 301208600Srdivacky memcpy(Results, &*Begin.getIterator(), 302210299Sed NumResults * sizeof(DeclAccessPair)); 303208600Srdivacky } 304208600Srdivacky 305218893Sdim // If we have explicit template arguments, check for dependent 306218893Sdim // template arguments and whether they contain any unexpanded pack 307218893Sdim // expansions. 308218893Sdim if (TemplateArgs) { 309218893Sdim bool Dependent = false; 310224145Sdim bool InstantiationDependent = false; 311218893Sdim bool ContainsUnexpandedParameterPack = false; 312234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, 313234353Sdim Dependent, 314234353Sdim InstantiationDependent, 315234353Sdim ContainsUnexpandedParameterPack); 316210299Sed 317218893Sdim if (Dependent) { 318224145Sdim ExprBits.TypeDependent = true; 319224145Sdim ExprBits.ValueDependent = true; 320224145Sdim } 321224145Sdim if (InstantiationDependent) 322224145Sdim ExprBits.InstantiationDependent = true; 323218893Sdim if (ContainsUnexpandedParameterPack) 324218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 325234353Sdim } else if (TemplateKWLoc.isValid()) { 326234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 327218893Sdim } 328199990Srdivacky 329218893Sdim if (isTypeDependent()) 330218893Sdim setType(C.DependentTy); 331218893Sdim} 332199990Srdivacky 333218893Sdimvoid OverloadExpr::initializeResults(ASTContext &C, 334218893Sdim UnresolvedSetIterator Begin, 335218893Sdim UnresolvedSetIterator End) { 336218893Sdim assert(Results == 0 && "Results already initialized!"); 337218893Sdim NumResults = End - Begin; 338218893Sdim if (NumResults) { 339218893Sdim Results = static_cast<DeclAccessPair *>( 340218893Sdim C.Allocate(sizeof(DeclAccessPair) * NumResults, 341218893Sdim 342218893Sdim llvm::alignOf<DeclAccessPair>())); 343218893Sdim memcpy(Results, &*Begin.getIterator(), 344218893Sdim NumResults * sizeof(DeclAccessPair)); 345218893Sdim } 346199990Srdivacky} 347199990Srdivacky 348207619SrdivackyCXXRecordDecl *OverloadExpr::getNamingClass() const { 349207619Srdivacky if (isa<UnresolvedLookupExpr>(this)) 350207619Srdivacky return cast<UnresolvedLookupExpr>(this)->getNamingClass(); 351207619Srdivacky else 352207619Srdivacky return cast<UnresolvedMemberExpr>(this)->getNamingClass(); 353207619Srdivacky} 354207619Srdivacky 355218893Sdim// DependentScopeDeclRefExpr 356218893SdimDependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T, 357219077Sdim NestedNameSpecifierLoc QualifierLoc, 358234353Sdim SourceLocation TemplateKWLoc, 359218893Sdim const DeclarationNameInfo &NameInfo, 360218893Sdim const TemplateArgumentListInfo *Args) 361218893Sdim : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary, 362218893Sdim true, true, 363224145Sdim (NameInfo.isInstantiationDependent() || 364224145Sdim (QualifierLoc && 365224145Sdim QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), 366218893Sdim (NameInfo.containsUnexpandedParameterPack() || 367219077Sdim (QualifierLoc && 368219077Sdim QualifierLoc.getNestedNameSpecifier() 369219077Sdim ->containsUnexpandedParameterPack()))), 370219077Sdim QualifierLoc(QualifierLoc), NameInfo(NameInfo), 371234353Sdim HasTemplateKWAndArgsInfo(Args != 0 || TemplateKWLoc.isValid()) 372218893Sdim{ 373218893Sdim if (Args) { 374218893Sdim bool Dependent = true; 375224145Sdim bool InstantiationDependent = true; 376218893Sdim bool ContainsUnexpandedParameterPack 377218893Sdim = ExprBits.ContainsUnexpandedParameterPack; 378234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *Args, 379234353Sdim Dependent, 380234353Sdim InstantiationDependent, 381234353Sdim ContainsUnexpandedParameterPack); 382218893Sdim ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; 383234353Sdim } else if (TemplateKWLoc.isValid()) { 384234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 385218893Sdim } 386193326Sed} 387193326Sed 388199990SrdivackyDependentScopeDeclRefExpr * 389199990SrdivackyDependentScopeDeclRefExpr::Create(ASTContext &C, 390219077Sdim NestedNameSpecifierLoc QualifierLoc, 391234353Sdim SourceLocation TemplateKWLoc, 392212904Sdim const DeclarationNameInfo &NameInfo, 393199990Srdivacky const TemplateArgumentListInfo *Args) { 394199990Srdivacky std::size_t size = sizeof(DependentScopeDeclRefExpr); 395218893Sdim if (Args) 396234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(Args->size()); 397234353Sdim else if (TemplateKWLoc.isValid()) 398234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(0); 399199990Srdivacky void *Mem = C.Allocate(size); 400234353Sdim return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc, 401234353Sdim TemplateKWLoc, NameInfo, Args); 402195341Sed} 403195341Sed 404210299SedDependentScopeDeclRefExpr * 405210299SedDependentScopeDeclRefExpr::CreateEmpty(ASTContext &C, 406234353Sdim bool HasTemplateKWAndArgsInfo, 407210299Sed unsigned NumTemplateArgs) { 408210299Sed std::size_t size = sizeof(DependentScopeDeclRefExpr); 409234353Sdim if (HasTemplateKWAndArgsInfo) 410234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 411210299Sed void *Mem = C.Allocate(size); 412234353Sdim DependentScopeDeclRefExpr *E 413219077Sdim = new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(), 414234353Sdim SourceLocation(), 415218893Sdim DeclarationNameInfo(), 0); 416234353Sdim E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 417218893Sdim return E; 418210299Sed} 419210299Sed 420249423SdimSourceLocation CXXConstructExpr::getLocStart() const { 421219077Sdim if (isa<CXXTemporaryObjectExpr>(this)) 422249423Sdim return cast<CXXTemporaryObjectExpr>(this)->getLocStart(); 423249423Sdim return Loc; 424249423Sdim} 425219077Sdim 426249423SdimSourceLocation CXXConstructExpr::getLocEnd() const { 427249423Sdim if (isa<CXXTemporaryObjectExpr>(this)) 428249423Sdim return cast<CXXTemporaryObjectExpr>(this)->getLocEnd(); 429249423Sdim 430218893Sdim if (ParenRange.isValid()) 431249423Sdim return ParenRange.getEnd(); 432195341Sed 433218893Sdim SourceLocation End = Loc; 434218893Sdim for (unsigned I = getNumArgs(); I > 0; --I) { 435218893Sdim const Expr *Arg = getArg(I-1); 436218893Sdim if (!Arg->isDefaultArgument()) { 437218893Sdim SourceLocation NewEnd = Arg->getLocEnd(); 438218893Sdim if (NewEnd.isValid()) { 439218893Sdim End = NewEnd; 440218893Sdim break; 441212904Sdim } 442212904Sdim } 443193326Sed } 444193326Sed 445249423Sdim return End; 446201361Srdivacky} 447201361Srdivacky 448239462SdimSourceRange CXXOperatorCallExpr::getSourceRangeImpl() const { 449193326Sed OverloadedOperatorKind Kind = getOperator(); 450193326Sed if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) { 451193326Sed if (getNumArgs() == 1) 452193326Sed // Prefix operator 453239462Sdim return SourceRange(getOperatorLoc(), getArg(0)->getLocEnd()); 454193326Sed else 455193326Sed // Postfix operator 456239462Sdim return SourceRange(getArg(0)->getLocStart(), getOperatorLoc()); 457221345Sdim } else if (Kind == OO_Arrow) { 458221345Sdim return getArg(0)->getSourceRange(); 459193326Sed } else if (Kind == OO_Call) { 460239462Sdim return SourceRange(getArg(0)->getLocStart(), getRParenLoc()); 461193326Sed } else if (Kind == OO_Subscript) { 462239462Sdim return SourceRange(getArg(0)->getLocStart(), getRParenLoc()); 463193326Sed } else if (getNumArgs() == 1) { 464239462Sdim return SourceRange(getOperatorLoc(), getArg(0)->getLocEnd()); 465193326Sed } else if (getNumArgs() == 2) { 466239462Sdim return SourceRange(getArg(0)->getLocStart(), getArg(1)->getLocEnd()); 467193326Sed } else { 468239462Sdim return getOperatorLoc(); 469193326Sed } 470193326Sed} 471193326Sed 472221345SdimExpr *CXXMemberCallExpr::getImplicitObjectArgument() const { 473239462Sdim const Expr *Callee = getCallee()->IgnoreParens(); 474239462Sdim if (const MemberExpr *MemExpr = dyn_cast<MemberExpr>(Callee)) 475193326Sed return MemExpr->getBase(); 476239462Sdim if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(Callee)) 477239462Sdim if (BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI) 478239462Sdim return BO->getLHS(); 479193326Sed 480193326Sed // FIXME: Will eventually need to cope with member pointers. 481193326Sed return 0; 482193326Sed} 483193326Sed 484221345SdimCXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const { 485221345Sdim if (const MemberExpr *MemExpr = 486221345Sdim dyn_cast<MemberExpr>(getCallee()->IgnoreParens())) 487221345Sdim return cast<CXXMethodDecl>(MemExpr->getMemberDecl()); 488221345Sdim 489221345Sdim // FIXME: Will eventually need to cope with member pointers. 490221345Sdim return 0; 491221345Sdim} 492221345Sdim 493221345Sdim 494239462SdimCXXRecordDecl *CXXMemberCallExpr::getRecordDecl() const { 495218893Sdim Expr* ThisArg = getImplicitObjectArgument(); 496218893Sdim if (!ThisArg) 497218893Sdim return 0; 498218893Sdim 499218893Sdim if (ThisArg->getType()->isAnyPointerType()) 500218893Sdim return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl(); 501218893Sdim 502218893Sdim return ThisArg->getType()->getAsCXXRecordDecl(); 503218893Sdim} 504218893Sdim 505199482Srdivacky 506193326Sed//===----------------------------------------------------------------------===// 507193326Sed// Named casts 508193326Sed//===----------------------------------------------------------------------===// 509193326Sed 510193326Sed/// getCastName - Get the name of the C++ cast being used, e.g., 511193326Sed/// "static_cast", "dynamic_cast", "reinterpret_cast", or 512193326Sed/// "const_cast". The returned pointer must not be freed. 513193326Sedconst char *CXXNamedCastExpr::getCastName() const { 514193326Sed switch (getStmtClass()) { 515193326Sed case CXXStaticCastExprClass: return "static_cast"; 516193326Sed case CXXDynamicCastExprClass: return "dynamic_cast"; 517193326Sed case CXXReinterpretCastExprClass: return "reinterpret_cast"; 518193326Sed case CXXConstCastExprClass: return "const_cast"; 519193326Sed default: return "<invalid cast>"; 520193326Sed } 521193326Sed} 522193326Sed 523212904SdimCXXStaticCastExpr *CXXStaticCastExpr::Create(ASTContext &C, QualType T, 524218893Sdim ExprValueKind VK, 525212904Sdim CastKind K, Expr *Op, 526212904Sdim const CXXCastPath *BasePath, 527212904Sdim TypeSourceInfo *WrittenTy, 528218893Sdim SourceLocation L, 529249423Sdim SourceLocation RParenLoc, 530249423Sdim SourceRange AngleBrackets) { 531212904Sdim unsigned PathSize = (BasePath ? BasePath->size() : 0); 532212904Sdim void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr) 533212904Sdim + PathSize * sizeof(CXXBaseSpecifier*)); 534212904Sdim CXXStaticCastExpr *E = 535218893Sdim new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 536249423Sdim RParenLoc, AngleBrackets); 537212904Sdim if (PathSize) E->setCastPath(*BasePath); 538212904Sdim return E; 539212904Sdim} 540212904Sdim 541212904SdimCXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext &C, 542212904Sdim unsigned PathSize) { 543212904Sdim void *Buffer = 544212904Sdim C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 545212904Sdim return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize); 546212904Sdim} 547212904Sdim 548212904SdimCXXDynamicCastExpr *CXXDynamicCastExpr::Create(ASTContext &C, QualType T, 549218893Sdim ExprValueKind VK, 550212904Sdim CastKind K, Expr *Op, 551212904Sdim const CXXCastPath *BasePath, 552212904Sdim TypeSourceInfo *WrittenTy, 553218893Sdim SourceLocation L, 554249423Sdim SourceLocation RParenLoc, 555249423Sdim SourceRange AngleBrackets) { 556212904Sdim unsigned PathSize = (BasePath ? BasePath->size() : 0); 557212904Sdim void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr) 558212904Sdim + PathSize * sizeof(CXXBaseSpecifier*)); 559212904Sdim CXXDynamicCastExpr *E = 560218893Sdim new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 561249423Sdim RParenLoc, AngleBrackets); 562212904Sdim if (PathSize) E->setCastPath(*BasePath); 563212904Sdim return E; 564212904Sdim} 565212904Sdim 566212904SdimCXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext &C, 567212904Sdim unsigned PathSize) { 568212904Sdim void *Buffer = 569212904Sdim C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 570212904Sdim return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize); 571212904Sdim} 572212904Sdim 573221345Sdim/// isAlwaysNull - Return whether the result of the dynamic_cast is proven 574221345Sdim/// to always be null. For example: 575221345Sdim/// 576221345Sdim/// struct A { }; 577221345Sdim/// struct B final : A { }; 578221345Sdim/// struct C { }; 579221345Sdim/// 580221345Sdim/// C *f(B* b) { return dynamic_cast<C*>(b); } 581221345Sdimbool CXXDynamicCastExpr::isAlwaysNull() const 582221345Sdim{ 583221345Sdim QualType SrcType = getSubExpr()->getType(); 584221345Sdim QualType DestType = getType(); 585221345Sdim 586221345Sdim if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) { 587221345Sdim SrcType = SrcPTy->getPointeeType(); 588221345Sdim DestType = DestType->castAs<PointerType>()->getPointeeType(); 589221345Sdim } 590221345Sdim 591239462Sdim if (DestType->isVoidType()) 592239462Sdim return false; 593239462Sdim 594221345Sdim const CXXRecordDecl *SrcRD = 595221345Sdim cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl()); 596221345Sdim 597221345Sdim if (!SrcRD->hasAttr<FinalAttr>()) 598221345Sdim return false; 599221345Sdim 600221345Sdim const CXXRecordDecl *DestRD = 601221345Sdim cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl()); 602221345Sdim 603221345Sdim return !DestRD->isDerivedFrom(SrcRD); 604221345Sdim} 605221345Sdim 606212904SdimCXXReinterpretCastExpr * 607218893SdimCXXReinterpretCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK, 608218893Sdim CastKind K, Expr *Op, 609212904Sdim const CXXCastPath *BasePath, 610218893Sdim TypeSourceInfo *WrittenTy, SourceLocation L, 611249423Sdim SourceLocation RParenLoc, 612249423Sdim SourceRange AngleBrackets) { 613212904Sdim unsigned PathSize = (BasePath ? BasePath->size() : 0); 614212904Sdim void *Buffer = 615212904Sdim C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 616212904Sdim CXXReinterpretCastExpr *E = 617218893Sdim new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 618249423Sdim RParenLoc, AngleBrackets); 619212904Sdim if (PathSize) E->setCastPath(*BasePath); 620212904Sdim return E; 621212904Sdim} 622212904Sdim 623212904SdimCXXReinterpretCastExpr * 624212904SdimCXXReinterpretCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) { 625212904Sdim void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr) 626212904Sdim + PathSize * sizeof(CXXBaseSpecifier*)); 627212904Sdim return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize); 628212904Sdim} 629212904Sdim 630218893SdimCXXConstCastExpr *CXXConstCastExpr::Create(ASTContext &C, QualType T, 631218893Sdim ExprValueKind VK, Expr *Op, 632212904Sdim TypeSourceInfo *WrittenTy, 633218893Sdim SourceLocation L, 634249423Sdim SourceLocation RParenLoc, 635249423Sdim SourceRange AngleBrackets) { 636249423Sdim return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets); 637212904Sdim} 638212904Sdim 639212904SdimCXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext &C) { 640212904Sdim return new (C) CXXConstCastExpr(EmptyShell()); 641212904Sdim} 642212904Sdim 643212904SdimCXXFunctionalCastExpr * 644218893SdimCXXFunctionalCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK, 645212904Sdim TypeSourceInfo *Written, SourceLocation L, 646212904Sdim CastKind K, Expr *Op, const CXXCastPath *BasePath, 647212904Sdim SourceLocation R) { 648212904Sdim unsigned PathSize = (BasePath ? BasePath->size() : 0); 649212904Sdim void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr) 650212904Sdim + PathSize * sizeof(CXXBaseSpecifier*)); 651212904Sdim CXXFunctionalCastExpr *E = 652218893Sdim new (Buffer) CXXFunctionalCastExpr(T, VK, Written, L, K, Op, PathSize, R); 653212904Sdim if (PathSize) E->setCastPath(*BasePath); 654212904Sdim return E; 655212904Sdim} 656212904Sdim 657212904SdimCXXFunctionalCastExpr * 658212904SdimCXXFunctionalCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) { 659212904Sdim void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr) 660212904Sdim + PathSize * sizeof(CXXBaseSpecifier*)); 661212904Sdim return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize); 662212904Sdim} 663212904Sdim 664234353SdimUserDefinedLiteral::LiteralOperatorKind 665234353SdimUserDefinedLiteral::getLiteralOperatorKind() const { 666234353Sdim if (getNumArgs() == 0) 667234353Sdim return LOK_Template; 668234353Sdim if (getNumArgs() == 2) 669234353Sdim return LOK_String; 670212904Sdim 671234353Sdim assert(getNumArgs() == 1 && "unexpected #args in literal operator call"); 672234353Sdim QualType ParamTy = 673234353Sdim cast<FunctionDecl>(getCalleeDecl())->getParamDecl(0)->getType(); 674234353Sdim if (ParamTy->isPointerType()) 675234353Sdim return LOK_Raw; 676234353Sdim if (ParamTy->isAnyCharacterType()) 677234353Sdim return LOK_Character; 678234353Sdim if (ParamTy->isIntegerType()) 679234353Sdim return LOK_Integer; 680234353Sdim if (ParamTy->isFloatingType()) 681234353Sdim return LOK_Floating; 682234353Sdim 683234353Sdim llvm_unreachable("unknown kind of literal operator"); 684234353Sdim} 685234353Sdim 686234353SdimExpr *UserDefinedLiteral::getCookedLiteral() { 687234353Sdim#ifndef NDEBUG 688234353Sdim LiteralOperatorKind LOK = getLiteralOperatorKind(); 689234353Sdim assert(LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal"); 690234353Sdim#endif 691234353Sdim return getArg(0); 692234353Sdim} 693234353Sdim 694234353Sdimconst IdentifierInfo *UserDefinedLiteral::getUDSuffix() const { 695234353Sdim return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier(); 696234353Sdim} 697234353Sdim 698201361SrdivackyCXXDefaultArgExpr * 699201361SrdivackyCXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc, 700201361Srdivacky ParmVarDecl *Param, Expr *SubExpr) { 701201361Srdivacky void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *)); 702201361Srdivacky return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, 703201361Srdivacky SubExpr); 704201361Srdivacky} 705201361Srdivacky 706251662SdimCXXDefaultInitExpr::CXXDefaultInitExpr(ASTContext &C, SourceLocation Loc, 707251662Sdim FieldDecl *Field, QualType T) 708251662Sdim : Expr(CXXDefaultInitExprClass, T.getNonLValueExprType(C), 709251662Sdim T->isLValueReferenceType() ? VK_LValue : T->isRValueReferenceType() 710251662Sdim ? VK_XValue 711251662Sdim : VK_RValue, 712251662Sdim /*FIXME*/ OK_Ordinary, false, false, false, false), 713251662Sdim Field(Field), Loc(Loc) { 714251662Sdim assert(Field->hasInClassInitializer()); 715251662Sdim} 716251662Sdim 717198092SrdivackyCXXTemporary *CXXTemporary::Create(ASTContext &C, 718193326Sed const CXXDestructorDecl *Destructor) { 719193326Sed return new (C) CXXTemporary(Destructor); 720193326Sed} 721193326Sed 722198092SrdivackyCXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C, 723193326Sed CXXTemporary *Temp, 724193326Sed Expr* SubExpr) { 725234353Sdim assert((SubExpr->getType()->isRecordType() || 726234353Sdim SubExpr->getType()->isArrayType()) && 727234353Sdim "Expression bound to a temporary must have record or array type!"); 728193326Sed 729193326Sed return new (C) CXXBindTemporaryExpr(Temp, SubExpr); 730193326Sed} 731193326Sed 732193326SedCXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C, 733193326Sed CXXConstructorDecl *Cons, 734218893Sdim TypeSourceInfo *Type, 735243830Sdim ArrayRef<Expr*> Args, 736218893Sdim SourceRange parenRange, 737226633Sdim bool HadMultipleCandidates, 738249423Sdim bool ListInitialization, 739207619Srdivacky bool ZeroInitialization) 740218893Sdim : CXXConstructExpr(C, CXXTemporaryObjectExprClass, 741218893Sdim Type->getType().getNonReferenceType(), 742218893Sdim Type->getTypeLoc().getBeginLoc(), 743243830Sdim Cons, false, Args, 744249423Sdim HadMultipleCandidates, 745249423Sdim ListInitialization, ZeroInitialization, 746218893Sdim CXXConstructExpr::CK_Complete, parenRange), 747218893Sdim Type(Type) { 748193326Sed} 749193326Sed 750249423SdimSourceLocation CXXTemporaryObjectExpr::getLocStart() const { 751249423Sdim return Type->getTypeLoc().getBeginLoc(); 752218893Sdim} 753218893Sdim 754249423SdimSourceLocation CXXTemporaryObjectExpr::getLocEnd() const { 755249423Sdim return getParenRange().getEnd(); 756249423Sdim} 757249423Sdim 758198092SrdivackyCXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T, 759201361Srdivacky SourceLocation Loc, 760193326Sed CXXConstructorDecl *D, bool Elidable, 761243830Sdim ArrayRef<Expr*> Args, 762226633Sdim bool HadMultipleCandidates, 763234353Sdim bool ListInitialization, 764203955Srdivacky bool ZeroInitialization, 765218893Sdim ConstructionKind ConstructKind, 766218893Sdim SourceRange ParenRange) { 767201361Srdivacky return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D, 768243830Sdim Elidable, Args, 769234353Sdim HadMultipleCandidates, ListInitialization, 770234353Sdim ZeroInitialization, ConstructKind, 771234353Sdim ParenRange); 772193326Sed} 773193326Sed 774198092SrdivackyCXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T, 775201361Srdivacky SourceLocation Loc, 776193326Sed CXXConstructorDecl *D, bool elidable, 777243830Sdim ArrayRef<Expr*> args, 778226633Sdim bool HadMultipleCandidates, 779234353Sdim bool ListInitialization, 780226633Sdim bool ZeroInitialization, 781218893Sdim ConstructionKind ConstructKind, 782218893Sdim SourceRange ParenRange) 783218893Sdim : Expr(SC, T, VK_RValue, OK_Ordinary, 784218893Sdim T->isDependentType(), T->isDependentType(), 785224145Sdim T->isInstantiationDependentType(), 786218893Sdim T->containsUnexpandedParameterPack()), 787243830Sdim Constructor(D), Loc(Loc), ParenRange(ParenRange), NumArgs(args.size()), 788226633Sdim Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates), 789234353Sdim ListInitialization(ListInitialization), 790226633Sdim ZeroInitialization(ZeroInitialization), 791226633Sdim ConstructKind(ConstructKind), Args(0) 792201361Srdivacky{ 793201361Srdivacky if (NumArgs) { 794243830Sdim Args = new (C) Stmt*[args.size()]; 795201361Srdivacky 796243830Sdim for (unsigned i = 0; i != args.size(); ++i) { 797201361Srdivacky assert(args[i] && "NULL argument in CXXConstructExpr"); 798218893Sdim 799218893Sdim if (args[i]->isValueDependent()) 800218893Sdim ExprBits.ValueDependent = true; 801224145Sdim if (args[i]->isInstantiationDependent()) 802224145Sdim ExprBits.InstantiationDependent = true; 803218893Sdim if (args[i]->containsUnexpandedParameterPack()) 804218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 805218893Sdim 806201361Srdivacky Args[i] = args[i]; 807193326Sed } 808201361Srdivacky } 809193326Sed} 810193326Sed 811234353SdimLambdaExpr::Capture::Capture(SourceLocation Loc, bool Implicit, 812234353Sdim LambdaCaptureKind Kind, VarDecl *Var, 813234353Sdim SourceLocation EllipsisLoc) 814234353Sdim : VarAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc) 815234353Sdim{ 816234353Sdim unsigned Bits = 0; 817234353Sdim if (Implicit) 818234353Sdim Bits |= Capture_Implicit; 819234353Sdim 820234353Sdim switch (Kind) { 821234353Sdim case LCK_This: 822234353Sdim assert(Var == 0 && "'this' capture cannot have a variable!"); 823234353Sdim break; 824234353Sdim 825234353Sdim case LCK_ByCopy: 826234353Sdim Bits |= Capture_ByCopy; 827234353Sdim // Fall through 828234353Sdim case LCK_ByRef: 829234353Sdim assert(Var && "capture must have a variable!"); 830234353Sdim break; 831234353Sdim } 832234353Sdim VarAndBits.setInt(Bits); 833234353Sdim} 834234353Sdim 835234353SdimLambdaCaptureKind LambdaExpr::Capture::getCaptureKind() const { 836234353Sdim if (capturesThis()) 837234353Sdim return LCK_This; 838234353Sdim 839234353Sdim return (VarAndBits.getInt() & Capture_ByCopy)? LCK_ByCopy : LCK_ByRef; 840234353Sdim} 841234353Sdim 842234353SdimLambdaExpr::LambdaExpr(QualType T, 843234353Sdim SourceRange IntroducerRange, 844234353Sdim LambdaCaptureDefault CaptureDefault, 845234353Sdim ArrayRef<Capture> Captures, 846234353Sdim bool ExplicitParams, 847234353Sdim bool ExplicitResultType, 848234353Sdim ArrayRef<Expr *> CaptureInits, 849234353Sdim ArrayRef<VarDecl *> ArrayIndexVars, 850234353Sdim ArrayRef<unsigned> ArrayIndexStarts, 851239462Sdim SourceLocation ClosingBrace, 852239462Sdim bool ContainsUnexpandedParameterPack) 853234353Sdim : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary, 854234353Sdim T->isDependentType(), T->isDependentType(), T->isDependentType(), 855239462Sdim ContainsUnexpandedParameterPack), 856234353Sdim IntroducerRange(IntroducerRange), 857234353Sdim NumCaptures(Captures.size()), 858234353Sdim CaptureDefault(CaptureDefault), 859234353Sdim ExplicitParams(ExplicitParams), 860234353Sdim ExplicitResultType(ExplicitResultType), 861234353Sdim ClosingBrace(ClosingBrace) 862234353Sdim{ 863234353Sdim assert(CaptureInits.size() == Captures.size() && "Wrong number of arguments"); 864234353Sdim CXXRecordDecl *Class = getLambdaClass(); 865234353Sdim CXXRecordDecl::LambdaDefinitionData &Data = Class->getLambdaData(); 866234353Sdim 867234353Sdim // FIXME: Propagate "has unexpanded parameter pack" bit. 868234353Sdim 869234353Sdim // Copy captures. 870234353Sdim ASTContext &Context = Class->getASTContext(); 871234353Sdim Data.NumCaptures = NumCaptures; 872234353Sdim Data.NumExplicitCaptures = 0; 873234353Sdim Data.Captures = (Capture *)Context.Allocate(sizeof(Capture) * NumCaptures); 874234353Sdim Capture *ToCapture = Data.Captures; 875234353Sdim for (unsigned I = 0, N = Captures.size(); I != N; ++I) { 876234353Sdim if (Captures[I].isExplicit()) 877234353Sdim ++Data.NumExplicitCaptures; 878234353Sdim 879234353Sdim *ToCapture++ = Captures[I]; 880234353Sdim } 881234353Sdim 882234353Sdim // Copy initialization expressions for the non-static data members. 883234353Sdim Stmt **Stored = getStoredStmts(); 884234353Sdim for (unsigned I = 0, N = CaptureInits.size(); I != N; ++I) 885234353Sdim *Stored++ = CaptureInits[I]; 886234353Sdim 887234353Sdim // Copy the body of the lambda. 888234353Sdim *Stored++ = getCallOperator()->getBody(); 889234353Sdim 890234353Sdim // Copy the array index variables, if any. 891234353Sdim HasArrayIndexVars = !ArrayIndexVars.empty(); 892234353Sdim if (HasArrayIndexVars) { 893234353Sdim assert(ArrayIndexStarts.size() == NumCaptures); 894234353Sdim memcpy(getArrayIndexVars(), ArrayIndexVars.data(), 895234353Sdim sizeof(VarDecl *) * ArrayIndexVars.size()); 896234353Sdim memcpy(getArrayIndexStarts(), ArrayIndexStarts.data(), 897234353Sdim sizeof(unsigned) * Captures.size()); 898234353Sdim getArrayIndexStarts()[Captures.size()] = ArrayIndexVars.size(); 899234353Sdim } 900234353Sdim} 901234353Sdim 902234353SdimLambdaExpr *LambdaExpr::Create(ASTContext &Context, 903234353Sdim CXXRecordDecl *Class, 904234353Sdim SourceRange IntroducerRange, 905234353Sdim LambdaCaptureDefault CaptureDefault, 906234353Sdim ArrayRef<Capture> Captures, 907234353Sdim bool ExplicitParams, 908234353Sdim bool ExplicitResultType, 909234353Sdim ArrayRef<Expr *> CaptureInits, 910234353Sdim ArrayRef<VarDecl *> ArrayIndexVars, 911234353Sdim ArrayRef<unsigned> ArrayIndexStarts, 912239462Sdim SourceLocation ClosingBrace, 913239462Sdim bool ContainsUnexpandedParameterPack) { 914234353Sdim // Determine the type of the expression (i.e., the type of the 915234353Sdim // function object we're creating). 916234353Sdim QualType T = Context.getTypeDeclType(Class); 917234353Sdim 918234353Sdim unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (Captures.size() + 1); 919243830Sdim if (!ArrayIndexVars.empty()) { 920243830Sdim Size += sizeof(unsigned) * (Captures.size() + 1); 921243830Sdim // Realign for following VarDecl array. 922243830Sdim Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<VarDecl*>()); 923243830Sdim Size += sizeof(VarDecl *) * ArrayIndexVars.size(); 924243830Sdim } 925234353Sdim void *Mem = Context.Allocate(Size); 926234353Sdim return new (Mem) LambdaExpr(T, IntroducerRange, CaptureDefault, 927234353Sdim Captures, ExplicitParams, ExplicitResultType, 928234353Sdim CaptureInits, ArrayIndexVars, ArrayIndexStarts, 929239462Sdim ClosingBrace, ContainsUnexpandedParameterPack); 930234353Sdim} 931234353Sdim 932234353SdimLambdaExpr *LambdaExpr::CreateDeserialized(ASTContext &C, unsigned NumCaptures, 933234353Sdim unsigned NumArrayIndexVars) { 934234353Sdim unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (NumCaptures + 1); 935234353Sdim if (NumArrayIndexVars) 936234353Sdim Size += sizeof(VarDecl) * NumArrayIndexVars 937234353Sdim + sizeof(unsigned) * (NumCaptures + 1); 938234353Sdim void *Mem = C.Allocate(Size); 939234353Sdim return new (Mem) LambdaExpr(EmptyShell(), NumCaptures, NumArrayIndexVars > 0); 940234353Sdim} 941234353Sdim 942234353SdimLambdaExpr::capture_iterator LambdaExpr::capture_begin() const { 943234353Sdim return getLambdaClass()->getLambdaData().Captures; 944234353Sdim} 945234353Sdim 946234353SdimLambdaExpr::capture_iterator LambdaExpr::capture_end() const { 947234353Sdim return capture_begin() + NumCaptures; 948234353Sdim} 949234353Sdim 950234353SdimLambdaExpr::capture_iterator LambdaExpr::explicit_capture_begin() const { 951234353Sdim return capture_begin(); 952234353Sdim} 953234353Sdim 954234353SdimLambdaExpr::capture_iterator LambdaExpr::explicit_capture_end() const { 955234353Sdim struct CXXRecordDecl::LambdaDefinitionData &Data 956234353Sdim = getLambdaClass()->getLambdaData(); 957234353Sdim return Data.Captures + Data.NumExplicitCaptures; 958234353Sdim} 959234353Sdim 960234353SdimLambdaExpr::capture_iterator LambdaExpr::implicit_capture_begin() const { 961234353Sdim return explicit_capture_end(); 962234353Sdim} 963234353Sdim 964234353SdimLambdaExpr::capture_iterator LambdaExpr::implicit_capture_end() const { 965234353Sdim return capture_end(); 966234353Sdim} 967234353Sdim 968234353SdimArrayRef<VarDecl *> 969234353SdimLambdaExpr::getCaptureInitIndexVars(capture_init_iterator Iter) const { 970234353Sdim assert(HasArrayIndexVars && "No array index-var data?"); 971234353Sdim 972234353Sdim unsigned Index = Iter - capture_init_begin(); 973234353Sdim assert(Index < getLambdaClass()->getLambdaData().NumCaptures && 974234353Sdim "Capture index out-of-range"); 975234353Sdim VarDecl **IndexVars = getArrayIndexVars(); 976234353Sdim unsigned *IndexStarts = getArrayIndexStarts(); 977234353Sdim return ArrayRef<VarDecl *>(IndexVars + IndexStarts[Index], 978234353Sdim IndexVars + IndexStarts[Index + 1]); 979234353Sdim} 980234353Sdim 981234353SdimCXXRecordDecl *LambdaExpr::getLambdaClass() const { 982234353Sdim return getType()->getAsCXXRecordDecl(); 983234353Sdim} 984234353Sdim 985234353SdimCXXMethodDecl *LambdaExpr::getCallOperator() const { 986234353Sdim CXXRecordDecl *Record = getLambdaClass(); 987234353Sdim DeclarationName Name 988234353Sdim = Record->getASTContext().DeclarationNames.getCXXOperatorName(OO_Call); 989234353Sdim DeclContext::lookup_result Calls = Record->lookup(Name); 990249423Sdim assert(!Calls.empty() && "Missing lambda call operator!"); 991249423Sdim assert(Calls.size() == 1 && "More than one lambda call operator!"); 992249423Sdim CXXMethodDecl *Result = cast<CXXMethodDecl>(Calls.front()); 993234353Sdim return Result; 994234353Sdim} 995234353Sdim 996234353SdimCompoundStmt *LambdaExpr::getBody() const { 997234353Sdim if (!getStoredStmts()[NumCaptures]) 998234353Sdim getStoredStmts()[NumCaptures] = getCallOperator()->getBody(); 999234353Sdim 1000234353Sdim return reinterpret_cast<CompoundStmt *>(getStoredStmts()[NumCaptures]); 1001234353Sdim} 1002234353Sdim 1003234353Sdimbool LambdaExpr::isMutable() const { 1004239462Sdim return !getCallOperator()->isConst(); 1005234353Sdim} 1006234353Sdim 1007234353SdimExprWithCleanups::ExprWithCleanups(Expr *subexpr, 1008234353Sdim ArrayRef<CleanupObject> objects) 1009218893Sdim : Expr(ExprWithCleanupsClass, subexpr->getType(), 1010218893Sdim subexpr->getValueKind(), subexpr->getObjectKind(), 1011218893Sdim subexpr->isTypeDependent(), subexpr->isValueDependent(), 1012224145Sdim subexpr->isInstantiationDependent(), 1013218893Sdim subexpr->containsUnexpandedParameterPack()), 1014234353Sdim SubExpr(subexpr) { 1015234353Sdim ExprWithCleanupsBits.NumObjects = objects.size(); 1016234353Sdim for (unsigned i = 0, e = objects.size(); i != e; ++i) 1017234353Sdim getObjectsBuffer()[i] = objects[i]; 1018193326Sed} 1019193326Sed 1020234353SdimExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, Expr *subexpr, 1021234353Sdim ArrayRef<CleanupObject> objects) { 1022234353Sdim size_t size = sizeof(ExprWithCleanups) 1023234353Sdim + objects.size() * sizeof(CleanupObject); 1024234353Sdim void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>()); 1025234353Sdim return new (buffer) ExprWithCleanups(subexpr, objects); 1026208600Srdivacky} 1027208600Srdivacky 1028234353SdimExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects) 1029234353Sdim : Expr(ExprWithCleanupsClass, empty) { 1030234353Sdim ExprWithCleanupsBits.NumObjects = numObjects; 1031234353Sdim} 1032208600Srdivacky 1033234353SdimExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, EmptyShell empty, 1034234353Sdim unsigned numObjects) { 1035234353Sdim size_t size = sizeof(ExprWithCleanups) + numObjects * sizeof(CleanupObject); 1036234353Sdim void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>()); 1037234353Sdim return new (buffer) ExprWithCleanups(empty, numObjects); 1038193326Sed} 1039193326Sed 1040218893SdimCXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type, 1041193326Sed SourceLocation LParenLoc, 1042243830Sdim ArrayRef<Expr*> Args, 1043193326Sed SourceLocation RParenLoc) 1044218893Sdim : Expr(CXXUnresolvedConstructExprClass, 1045218893Sdim Type->getType().getNonReferenceType(), 1046224145Sdim (Type->getType()->isLValueReferenceType() ? VK_LValue 1047224145Sdim :Type->getType()->isRValueReferenceType()? VK_XValue 1048224145Sdim :VK_RValue), 1049224145Sdim OK_Ordinary, 1050224145Sdim Type->getType()->isDependentType(), true, true, 1051218893Sdim Type->getType()->containsUnexpandedParameterPack()), 1052218893Sdim Type(Type), 1053193326Sed LParenLoc(LParenLoc), 1054193326Sed RParenLoc(RParenLoc), 1055243830Sdim NumArgs(Args.size()) { 1056193326Sed Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1); 1057243830Sdim for (unsigned I = 0; I != Args.size(); ++I) { 1058218893Sdim if (Args[I]->containsUnexpandedParameterPack()) 1059218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 1060218893Sdim 1061218893Sdim StoredArgs[I] = Args[I]; 1062218893Sdim } 1063193326Sed} 1064193326Sed 1065193326SedCXXUnresolvedConstructExpr * 1066198092SrdivackyCXXUnresolvedConstructExpr::Create(ASTContext &C, 1067218893Sdim TypeSourceInfo *Type, 1068193326Sed SourceLocation LParenLoc, 1069243830Sdim ArrayRef<Expr*> Args, 1070193326Sed SourceLocation RParenLoc) { 1071193326Sed void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) + 1072243830Sdim sizeof(Expr *) * Args.size()); 1073243830Sdim return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc, Args, RParenLoc); 1074193326Sed} 1075193326Sed 1076210299SedCXXUnresolvedConstructExpr * 1077210299SedCXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) { 1078210299Sed Stmt::EmptyShell Empty; 1079210299Sed void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) + 1080210299Sed sizeof(Expr *) * NumArgs); 1081210299Sed return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs); 1082210299Sed} 1083210299Sed 1084249423SdimSourceLocation CXXUnresolvedConstructExpr::getLocStart() const { 1085249423Sdim return Type->getTypeLoc().getBeginLoc(); 1086193326Sed} 1087193326Sed 1088199990SrdivackyCXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C, 1089200583Srdivacky Expr *Base, QualType BaseType, 1090200583Srdivacky bool IsArrow, 1091198092Srdivacky SourceLocation OperatorLoc, 1092234353Sdim NestedNameSpecifierLoc QualifierLoc, 1093234353Sdim SourceLocation TemplateKWLoc, 1094198092Srdivacky NamedDecl *FirstQualifierFoundInScope, 1095212904Sdim DeclarationNameInfo MemberNameInfo, 1096199990Srdivacky const TemplateArgumentListInfo *TemplateArgs) 1097218893Sdim : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, 1098224145Sdim VK_LValue, OK_Ordinary, true, true, true, 1099218893Sdim ((Base && Base->containsUnexpandedParameterPack()) || 1100221345Sdim (QualifierLoc && 1101221345Sdim QualifierLoc.getNestedNameSpecifier() 1102221345Sdim ->containsUnexpandedParameterPack()) || 1103218893Sdim MemberNameInfo.containsUnexpandedParameterPack())), 1104200583Srdivacky Base(Base), BaseType(BaseType), IsArrow(IsArrow), 1105234353Sdim HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid()), 1106221345Sdim OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 1107198092Srdivacky FirstQualifierFoundInScope(FirstQualifierFoundInScope), 1108212904Sdim MemberNameInfo(MemberNameInfo) { 1109218893Sdim if (TemplateArgs) { 1110218893Sdim bool Dependent = true; 1111224145Sdim bool InstantiationDependent = true; 1112218893Sdim bool ContainsUnexpandedParameterPack = false; 1113234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, 1114234353Sdim Dependent, 1115234353Sdim InstantiationDependent, 1116234353Sdim ContainsUnexpandedParameterPack); 1117218893Sdim if (ContainsUnexpandedParameterPack) 1118218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 1119234353Sdim } else if (TemplateKWLoc.isValid()) { 1120234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 1121218893Sdim } 1122193326Sed} 1123193326Sed 1124218893SdimCXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C, 1125218893Sdim Expr *Base, QualType BaseType, 1126218893Sdim bool IsArrow, 1127218893Sdim SourceLocation OperatorLoc, 1128221345Sdim NestedNameSpecifierLoc QualifierLoc, 1129218893Sdim NamedDecl *FirstQualifierFoundInScope, 1130218893Sdim DeclarationNameInfo MemberNameInfo) 1131218893Sdim : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, 1132224145Sdim VK_LValue, OK_Ordinary, true, true, true, 1133218893Sdim ((Base && Base->containsUnexpandedParameterPack()) || 1134221345Sdim (QualifierLoc && 1135221345Sdim QualifierLoc.getNestedNameSpecifier()-> 1136221345Sdim containsUnexpandedParameterPack()) || 1137218893Sdim MemberNameInfo.containsUnexpandedParameterPack())), 1138218893Sdim Base(Base), BaseType(BaseType), IsArrow(IsArrow), 1139234353Sdim HasTemplateKWAndArgsInfo(false), 1140234353Sdim OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 1141218893Sdim FirstQualifierFoundInScope(FirstQualifierFoundInScope), 1142218893Sdim MemberNameInfo(MemberNameInfo) { } 1143218893Sdim 1144199990SrdivackyCXXDependentScopeMemberExpr * 1145199990SrdivackyCXXDependentScopeMemberExpr::Create(ASTContext &C, 1146200583Srdivacky Expr *Base, QualType BaseType, bool IsArrow, 1147198092Srdivacky SourceLocation OperatorLoc, 1148221345Sdim NestedNameSpecifierLoc QualifierLoc, 1149234353Sdim SourceLocation TemplateKWLoc, 1150198092Srdivacky NamedDecl *FirstQualifierFoundInScope, 1151212904Sdim DeclarationNameInfo MemberNameInfo, 1152199990Srdivacky const TemplateArgumentListInfo *TemplateArgs) { 1153234353Sdim if (!TemplateArgs && !TemplateKWLoc.isValid()) 1154200583Srdivacky return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType, 1155200583Srdivacky IsArrow, OperatorLoc, 1156221345Sdim QualifierLoc, 1157200583Srdivacky FirstQualifierFoundInScope, 1158212904Sdim MemberNameInfo); 1159193326Sed 1160234353Sdim unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0; 1161234353Sdim std::size_t size = sizeof(CXXDependentScopeMemberExpr) 1162234353Sdim + ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1163199990Srdivacky 1164218893Sdim void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>()); 1165200583Srdivacky return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType, 1166200583Srdivacky IsArrow, OperatorLoc, 1167221345Sdim QualifierLoc, 1168234353Sdim TemplateKWLoc, 1169200583Srdivacky FirstQualifierFoundInScope, 1170212904Sdim MemberNameInfo, TemplateArgs); 1171193326Sed} 1172193326Sed 1173210299SedCXXDependentScopeMemberExpr * 1174210299SedCXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C, 1175234353Sdim bool HasTemplateKWAndArgsInfo, 1176210299Sed unsigned NumTemplateArgs) { 1177234353Sdim if (!HasTemplateKWAndArgsInfo) 1178210299Sed return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(), 1179234353Sdim 0, SourceLocation(), 1180221345Sdim NestedNameSpecifierLoc(), 0, 1181212904Sdim DeclarationNameInfo()); 1182210299Sed 1183210299Sed std::size_t size = sizeof(CXXDependentScopeMemberExpr) + 1184234353Sdim ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1185218893Sdim void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>()); 1186210299Sed CXXDependentScopeMemberExpr *E 1187210299Sed = new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(), 1188234353Sdim 0, SourceLocation(), 1189234353Sdim NestedNameSpecifierLoc(), 1190234353Sdim SourceLocation(), 0, 1191212904Sdim DeclarationNameInfo(), 0); 1192234353Sdim E->HasTemplateKWAndArgsInfo = true; 1193210299Sed return E; 1194210299Sed} 1195210299Sed 1196221345Sdimbool CXXDependentScopeMemberExpr::isImplicitAccess() const { 1197221345Sdim if (Base == 0) 1198221345Sdim return true; 1199221345Sdim 1200221345Sdim return cast<Expr>(Base)->isImplicitCXXThis(); 1201221345Sdim} 1202221345Sdim 1203221345Sdimstatic bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin, 1204221345Sdim UnresolvedSetIterator end) { 1205221345Sdim do { 1206221345Sdim NamedDecl *decl = *begin; 1207221345Sdim if (isa<UnresolvedUsingValueDecl>(decl)) 1208221345Sdim return false; 1209221345Sdim if (isa<UsingShadowDecl>(decl)) 1210221345Sdim decl = cast<UsingShadowDecl>(decl)->getUnderlyingDecl(); 1211221345Sdim 1212221345Sdim // Unresolved member expressions should only contain methods and 1213221345Sdim // method templates. 1214221345Sdim assert(isa<CXXMethodDecl>(decl) || isa<FunctionTemplateDecl>(decl)); 1215221345Sdim 1216221345Sdim if (isa<FunctionTemplateDecl>(decl)) 1217221345Sdim decl = cast<FunctionTemplateDecl>(decl)->getTemplatedDecl(); 1218221345Sdim if (cast<CXXMethodDecl>(decl)->isStatic()) 1219221345Sdim return false; 1220221345Sdim } while (++begin != end); 1221221345Sdim 1222221345Sdim return true; 1223221345Sdim} 1224221345Sdim 1225218893SdimUnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C, 1226199990Srdivacky bool HasUnresolvedUsing, 1227200583Srdivacky Expr *Base, QualType BaseType, 1228200583Srdivacky bool IsArrow, 1229199990Srdivacky SourceLocation OperatorLoc, 1230221345Sdim NestedNameSpecifierLoc QualifierLoc, 1231234353Sdim SourceLocation TemplateKWLoc, 1232212904Sdim const DeclarationNameInfo &MemberNameInfo, 1233208600Srdivacky const TemplateArgumentListInfo *TemplateArgs, 1234208600Srdivacky UnresolvedSetIterator Begin, 1235208600Srdivacky UnresolvedSetIterator End) 1236234353Sdim : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, TemplateKWLoc, 1237234353Sdim MemberNameInfo, TemplateArgs, Begin, End, 1238218893Sdim // Dependent 1239218893Sdim ((Base && Base->isTypeDependent()) || 1240218893Sdim BaseType->isDependentType()), 1241224145Sdim ((Base && Base->isInstantiationDependent()) || 1242224145Sdim BaseType->isInstantiationDependentType()), 1243218893Sdim // Contains unexpanded parameter pack 1244218893Sdim ((Base && Base->containsUnexpandedParameterPack()) || 1245218893Sdim BaseType->containsUnexpandedParameterPack())), 1246203955Srdivacky IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing), 1247203955Srdivacky Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) { 1248221345Sdim 1249221345Sdim // Check whether all of the members are non-static member functions, 1250221345Sdim // and if so, mark give this bound-member type instead of overload type. 1251221345Sdim if (hasOnlyNonStaticMemberFunctions(Begin, End)) 1252221345Sdim setType(C.BoundMemberTy); 1253199990Srdivacky} 1254199990Srdivacky 1255221345Sdimbool UnresolvedMemberExpr::isImplicitAccess() const { 1256221345Sdim if (Base == 0) 1257221345Sdim return true; 1258221345Sdim 1259221345Sdim return cast<Expr>(Base)->isImplicitCXXThis(); 1260221345Sdim} 1261221345Sdim 1262199990SrdivackyUnresolvedMemberExpr * 1263218893SdimUnresolvedMemberExpr::Create(ASTContext &C, 1264199990Srdivacky bool HasUnresolvedUsing, 1265200583Srdivacky Expr *Base, QualType BaseType, bool IsArrow, 1266199990Srdivacky SourceLocation OperatorLoc, 1267221345Sdim NestedNameSpecifierLoc QualifierLoc, 1268234353Sdim SourceLocation TemplateKWLoc, 1269212904Sdim const DeclarationNameInfo &MemberNameInfo, 1270208600Srdivacky const TemplateArgumentListInfo *TemplateArgs, 1271208600Srdivacky UnresolvedSetIterator Begin, 1272208600Srdivacky UnresolvedSetIterator End) { 1273199990Srdivacky std::size_t size = sizeof(UnresolvedMemberExpr); 1274199990Srdivacky if (TemplateArgs) 1275234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size()); 1276234353Sdim else if (TemplateKWLoc.isValid()) 1277234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(0); 1278199990Srdivacky 1279218893Sdim void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>()); 1280208600Srdivacky return new (Mem) UnresolvedMemberExpr(C, 1281218893Sdim HasUnresolvedUsing, Base, BaseType, 1282234353Sdim IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc, 1283212904Sdim MemberNameInfo, TemplateArgs, Begin, End); 1284199990Srdivacky} 1285199990Srdivacky 1286210299SedUnresolvedMemberExpr * 1287234353SdimUnresolvedMemberExpr::CreateEmpty(ASTContext &C, bool HasTemplateKWAndArgsInfo, 1288218893Sdim unsigned NumTemplateArgs) { 1289210299Sed std::size_t size = sizeof(UnresolvedMemberExpr); 1290234353Sdim if (HasTemplateKWAndArgsInfo) 1291234353Sdim size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1292210299Sed 1293218893Sdim void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>()); 1294210299Sed UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell()); 1295234353Sdim E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 1296210299Sed return E; 1297210299Sed} 1298210299Sed 1299203955SrdivackyCXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const { 1300203955Srdivacky // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this. 1301203955Srdivacky 1302203955Srdivacky // If there was a nested name specifier, it names the naming class. 1303203955Srdivacky // It can't be dependent: after all, we were actually able to do the 1304203955Srdivacky // lookup. 1305207619Srdivacky CXXRecordDecl *Record = 0; 1306203955Srdivacky if (getQualifier()) { 1307218893Sdim const Type *T = getQualifier()->getAsType(); 1308203955Srdivacky assert(T && "qualifier in member expression does not name type"); 1309207619Srdivacky Record = T->getAsCXXRecordDecl(); 1310207619Srdivacky assert(Record && "qualifier in member expression does not name record"); 1311207619Srdivacky } 1312203955Srdivacky // Otherwise the naming class must have been the base class. 1313207619Srdivacky else { 1314203955Srdivacky QualType BaseType = getBaseType().getNonReferenceType(); 1315203955Srdivacky if (isArrow()) { 1316203955Srdivacky const PointerType *PT = BaseType->getAs<PointerType>(); 1317203955Srdivacky assert(PT && "base of arrow member access is not pointer"); 1318203955Srdivacky BaseType = PT->getPointeeType(); 1319203955Srdivacky } 1320203955Srdivacky 1321207619Srdivacky Record = BaseType->getAsCXXRecordDecl(); 1322207619Srdivacky assert(Record && "base of member expression does not name record"); 1323203955Srdivacky } 1324203955Srdivacky 1325207619Srdivacky return Record; 1326203955Srdivacky} 1327203955Srdivacky 1328218893SdimSubstNonTypeTemplateParmPackExpr:: 1329218893SdimSubstNonTypeTemplateParmPackExpr(QualType T, 1330218893Sdim NonTypeTemplateParmDecl *Param, 1331218893Sdim SourceLocation NameLoc, 1332218893Sdim const TemplateArgument &ArgPack) 1333218893Sdim : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary, 1334224145Sdim true, true, true, true), 1335218893Sdim Param(Param), Arguments(ArgPack.pack_begin()), 1336218893Sdim NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { } 1337218893Sdim 1338218893SdimTemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const { 1339218893Sdim return TemplateArgument(Arguments, NumArguments); 1340199990Srdivacky} 1341199990Srdivacky 1342243830SdimFunctionParmPackExpr::FunctionParmPackExpr(QualType T, ParmVarDecl *ParamPack, 1343243830Sdim SourceLocation NameLoc, 1344243830Sdim unsigned NumParams, 1345243830Sdim Decl * const *Params) 1346243830Sdim : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary, 1347243830Sdim true, true, true, true), 1348243830Sdim ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) { 1349243830Sdim if (Params) 1350243830Sdim std::uninitialized_copy(Params, Params + NumParams, 1351243830Sdim reinterpret_cast<Decl**>(this+1)); 1352243830Sdim} 1353243830Sdim 1354243830SdimFunctionParmPackExpr * 1355243830SdimFunctionParmPackExpr::Create(ASTContext &Context, QualType T, 1356243830Sdim ParmVarDecl *ParamPack, SourceLocation NameLoc, 1357249423Sdim ArrayRef<Decl *> Params) { 1358243830Sdim return new (Context.Allocate(sizeof(FunctionParmPackExpr) + 1359243830Sdim sizeof(ParmVarDecl*) * Params.size())) 1360243830Sdim FunctionParmPackExpr(T, ParamPack, NameLoc, Params.size(), Params.data()); 1361243830Sdim} 1362243830Sdim 1363243830SdimFunctionParmPackExpr * 1364243830SdimFunctionParmPackExpr::CreateEmpty(ASTContext &Context, unsigned NumParams) { 1365243830Sdim return new (Context.Allocate(sizeof(FunctionParmPackExpr) + 1366243830Sdim sizeof(ParmVarDecl*) * NumParams)) 1367243830Sdim FunctionParmPackExpr(QualType(), 0, SourceLocation(), 0, 0); 1368243830Sdim} 1369243830Sdim 1370234353SdimTypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind, 1371234353Sdim ArrayRef<TypeSourceInfo *> Args, 1372234353Sdim SourceLocation RParenLoc, 1373234353Sdim bool Value) 1374234353Sdim : Expr(TypeTraitExprClass, T, VK_RValue, OK_Ordinary, 1375234353Sdim /*TypeDependent=*/false, 1376234353Sdim /*ValueDependent=*/false, 1377234353Sdim /*InstantiationDependent=*/false, 1378234353Sdim /*ContainsUnexpandedParameterPack=*/false), 1379234353Sdim Loc(Loc), RParenLoc(RParenLoc) 1380234353Sdim{ 1381234353Sdim TypeTraitExprBits.Kind = Kind; 1382234353Sdim TypeTraitExprBits.Value = Value; 1383234353Sdim TypeTraitExprBits.NumArgs = Args.size(); 1384218893Sdim 1385234353Sdim TypeSourceInfo **ToArgs = getTypeSourceInfos(); 1386234353Sdim 1387234353Sdim for (unsigned I = 0, N = Args.size(); I != N; ++I) { 1388234353Sdim if (Args[I]->getType()->isDependentType()) 1389234353Sdim setValueDependent(true); 1390234353Sdim if (Args[I]->getType()->isInstantiationDependentType()) 1391234353Sdim setInstantiationDependent(true); 1392234353Sdim if (Args[I]->getType()->containsUnexpandedParameterPack()) 1393234353Sdim setContainsUnexpandedParameterPack(true); 1394234353Sdim 1395234353Sdim ToArgs[I] = Args[I]; 1396234353Sdim } 1397234353Sdim} 1398234353Sdim 1399234353SdimTypeTraitExpr *TypeTraitExpr::Create(ASTContext &C, QualType T, 1400234353Sdim SourceLocation Loc, 1401234353Sdim TypeTrait Kind, 1402234353Sdim ArrayRef<TypeSourceInfo *> Args, 1403234353Sdim SourceLocation RParenLoc, 1404234353Sdim bool Value) { 1405234353Sdim unsigned Size = sizeof(TypeTraitExpr) + sizeof(TypeSourceInfo*) * Args.size(); 1406234353Sdim void *Mem = C.Allocate(Size); 1407234353Sdim return new (Mem) TypeTraitExpr(T, Loc, Kind, Args, RParenLoc, Value); 1408234353Sdim} 1409234353Sdim 1410234353SdimTypeTraitExpr *TypeTraitExpr::CreateDeserialized(ASTContext &C, 1411234353Sdim unsigned NumArgs) { 1412234353Sdim unsigned Size = sizeof(TypeTraitExpr) + sizeof(TypeSourceInfo*) * NumArgs; 1413234353Sdim void *Mem = C.Allocate(Size); 1414234353Sdim return new (Mem) TypeTraitExpr(EmptyShell()); 1415234353Sdim} 1416234353Sdim 1417234353Sdimvoid ArrayTypeTraitExpr::anchor() { } 1418