1 //===--- ExprCXX.cpp - (C++) Expression AST Node Implementation -----------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the subclesses of Expr class declared in ExprCXX.h 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/AST/ASTContext.h" 15 #include "clang/AST/Attr.h" 16 #include "clang/AST/DeclCXX.h" 17 #include "clang/AST/DeclTemplate.h" 18 #include "clang/AST/ExprCXX.h" 19 #include "clang/AST/TypeLoc.h" 20 #include "clang/Basic/IdentifierTable.h" 21 using namespace clang; 22 23 24 //===----------------------------------------------------------------------===// 25 // Child Iterators for iterating over subexpressions/substatements 26 //===----------------------------------------------------------------------===// 27 28 bool CXXTypeidExpr::isPotentiallyEvaluated() const { 29 if (isTypeOperand()) 30 return false; 31 32 // C++11 [expr.typeid]p3: 33 // When typeid is applied to an expression other than a glvalue of 34 // polymorphic class type, [...] the expression is an unevaluated operand. 35 const Expr *E = getExprOperand(); 36 if (const CXXRecordDecl *RD = E->getType()->getAsCXXRecordDecl()) 37 if (RD->isPolymorphic() && E->isGLValue()) 38 return true; 39 40 return false; 41 } 42 43 QualType CXXTypeidExpr::getTypeOperand() const { 44 assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)"); 45 return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType() 46 .getUnqualifiedType(); 47 } 48 49 QualType CXXUuidofExpr::getTypeOperand() const { 50 assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)"); 51 return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType() 52 .getUnqualifiedType(); 53 } 54 55 // static 56 UuidAttr *CXXUuidofExpr::GetUuidAttrOfType(QualType QT) { 57 // Optionally remove one level of pointer, reference or array indirection. 58 const Type *Ty = QT.getTypePtr(); 59 if (QT->isPointerType() || QT->isReferenceType()) 60 Ty = QT->getPointeeType().getTypePtr(); 61 else if (QT->isArrayType()) 62 Ty = cast<ArrayType>(QT)->getElementType().getTypePtr(); 63 64 // Loop all record redeclaration looking for an uuid attribute. 65 CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); 66 for (CXXRecordDecl::redecl_iterator I = RD->redecls_begin(), 67 E = RD->redecls_end(); I != E; ++I) { 68 if (UuidAttr *Uuid = I->getAttr<UuidAttr>()) 69 return Uuid; 70 } 71 72 return 0; 73 } 74 75 // CXXScalarValueInitExpr 76 SourceLocation CXXScalarValueInitExpr::getLocStart() const { 77 return TypeInfo ? TypeInfo->getTypeLoc().getBeginLoc() : RParenLoc; 78 } 79 80 // CXXNewExpr 81 CXXNewExpr::CXXNewExpr(ASTContext &C, bool globalNew, FunctionDecl *operatorNew, 82 FunctionDecl *operatorDelete, 83 bool usualArrayDeleteWantsSize, 84 ArrayRef<Expr*> placementArgs, 85 SourceRange typeIdParens, Expr *arraySize, 86 InitializationStyle initializationStyle, 87 Expr *initializer, QualType ty, 88 TypeSourceInfo *allocatedTypeInfo, 89 SourceRange Range, SourceRange directInitRange) 90 : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary, 91 ty->isDependentType(), ty->isDependentType(), 92 ty->isInstantiationDependentType(), 93 ty->containsUnexpandedParameterPack()), 94 SubExprs(0), OperatorNew(operatorNew), OperatorDelete(operatorDelete), 95 AllocatedTypeInfo(allocatedTypeInfo), TypeIdParens(typeIdParens), 96 Range(Range), DirectInitRange(directInitRange), 97 GlobalNew(globalNew), UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) { 98 assert((initializer != 0 || initializationStyle == NoInit) && 99 "Only NoInit can have no initializer."); 100 StoredInitializationStyle = initializer ? initializationStyle + 1 : 0; 101 AllocateArgsArray(C, arraySize != 0, placementArgs.size(), initializer != 0); 102 unsigned i = 0; 103 if (Array) { 104 if (arraySize->isInstantiationDependent()) 105 ExprBits.InstantiationDependent = true; 106 107 if (arraySize->containsUnexpandedParameterPack()) 108 ExprBits.ContainsUnexpandedParameterPack = true; 109 110 SubExprs[i++] = arraySize; 111 } 112 113 if (initializer) { 114 if (initializer->isInstantiationDependent()) 115 ExprBits.InstantiationDependent = true; 116 117 if (initializer->containsUnexpandedParameterPack()) 118 ExprBits.ContainsUnexpandedParameterPack = true; 119 120 SubExprs[i++] = initializer; 121 } 122 123 for (unsigned j = 0; j != placementArgs.size(); ++j) { 124 if (placementArgs[j]->isInstantiationDependent()) 125 ExprBits.InstantiationDependent = true; 126 if (placementArgs[j]->containsUnexpandedParameterPack()) 127 ExprBits.ContainsUnexpandedParameterPack = true; 128 129 SubExprs[i++] = placementArgs[j]; 130 } 131 132 switch (getInitializationStyle()) { 133 case CallInit: 134 this->Range.setEnd(DirectInitRange.getEnd()); break; 135 case ListInit: 136 this->Range.setEnd(getInitializer()->getSourceRange().getEnd()); break; 137 default: break; 138 } 139 } 140 141 void CXXNewExpr::AllocateArgsArray(ASTContext &C, bool isArray, 142 unsigned numPlaceArgs, bool hasInitializer){ 143 assert(SubExprs == 0 && "SubExprs already allocated"); 144 Array = isArray; 145 NumPlacementArgs = numPlaceArgs; 146 147 unsigned TotalSize = Array + hasInitializer + NumPlacementArgs; 148 SubExprs = new (C) Stmt*[TotalSize]; 149 } 150 151 bool CXXNewExpr::shouldNullCheckAllocation(ASTContext &Ctx) const { 152 return getOperatorNew()->getType()-> 153 castAs<FunctionProtoType>()->isNothrow(Ctx); 154 } 155 156 // CXXDeleteExpr 157 QualType CXXDeleteExpr::getDestroyedType() const { 158 const Expr *Arg = getArgument(); 159 // The type-to-delete may not be a pointer if it's a dependent type. 160 const QualType ArgType = Arg->getType(); 161 162 if (ArgType->isDependentType() && !ArgType->isPointerType()) 163 return QualType(); 164 165 return ArgType->getAs<PointerType>()->getPointeeType(); 166 } 167 168 // CXXPseudoDestructorExpr 169 PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info) 170 : Type(Info) 171 { 172 Location = Info->getTypeLoc().getLocalSourceRange().getBegin(); 173 } 174 175 CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(ASTContext &Context, 176 Expr *Base, bool isArrow, SourceLocation OperatorLoc, 177 NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType, 178 SourceLocation ColonColonLoc, SourceLocation TildeLoc, 179 PseudoDestructorTypeStorage DestroyedType) 180 : Expr(CXXPseudoDestructorExprClass, 181 Context.getPointerType(Context.getFunctionType(Context.VoidTy, 182 ArrayRef<QualType>(), 183 FunctionProtoType::ExtProtoInfo())), 184 VK_RValue, OK_Ordinary, 185 /*isTypeDependent=*/(Base->isTypeDependent() || 186 (DestroyedType.getTypeSourceInfo() && 187 DestroyedType.getTypeSourceInfo()->getType()->isDependentType())), 188 /*isValueDependent=*/Base->isValueDependent(), 189 (Base->isInstantiationDependent() || 190 (QualifierLoc && 191 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) || 192 (ScopeType && 193 ScopeType->getType()->isInstantiationDependentType()) || 194 (DestroyedType.getTypeSourceInfo() && 195 DestroyedType.getTypeSourceInfo()->getType() 196 ->isInstantiationDependentType())), 197 // ContainsUnexpandedParameterPack 198 (Base->containsUnexpandedParameterPack() || 199 (QualifierLoc && 200 QualifierLoc.getNestedNameSpecifier() 201 ->containsUnexpandedParameterPack()) || 202 (ScopeType && 203 ScopeType->getType()->containsUnexpandedParameterPack()) || 204 (DestroyedType.getTypeSourceInfo() && 205 DestroyedType.getTypeSourceInfo()->getType() 206 ->containsUnexpandedParameterPack()))), 207 Base(static_cast<Stmt *>(Base)), IsArrow(isArrow), 208 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 209 ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc), 210 DestroyedType(DestroyedType) { } 211 212 QualType CXXPseudoDestructorExpr::getDestroyedType() const { 213 if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) 214 return TInfo->getType(); 215 216 return QualType(); 217 } 218 219 SourceLocation CXXPseudoDestructorExpr::getLocEnd() const { 220 SourceLocation End = DestroyedType.getLocation(); 221 if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) 222 End = TInfo->getTypeLoc().getLocalSourceRange().getEnd(); 223 return End; 224 } 225 226 // UnresolvedLookupExpr 227 UnresolvedLookupExpr * 228 UnresolvedLookupExpr::Create(ASTContext &C, 229 CXXRecordDecl *NamingClass, 230 NestedNameSpecifierLoc QualifierLoc, 231 SourceLocation TemplateKWLoc, 232 const DeclarationNameInfo &NameInfo, 233 bool ADL, 234 const TemplateArgumentListInfo *Args, 235 UnresolvedSetIterator Begin, 236 UnresolvedSetIterator End) 237 { 238 assert(Args || TemplateKWLoc.isValid()); 239 unsigned num_args = Args ? Args->size() : 0; 240 void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) + 241 ASTTemplateKWAndArgsInfo::sizeFor(num_args)); 242 return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc, 243 TemplateKWLoc, NameInfo, 244 ADL, /*Overload*/ true, Args, 245 Begin, End); 246 } 247 248 UnresolvedLookupExpr * 249 UnresolvedLookupExpr::CreateEmpty(ASTContext &C, 250 bool HasTemplateKWAndArgsInfo, 251 unsigned NumTemplateArgs) { 252 std::size_t size = sizeof(UnresolvedLookupExpr); 253 if (HasTemplateKWAndArgsInfo) 254 size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 255 256 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>()); 257 UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell()); 258 E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 259 return E; 260 } 261 262 OverloadExpr::OverloadExpr(StmtClass K, ASTContext &C, 263 NestedNameSpecifierLoc QualifierLoc, 264 SourceLocation TemplateKWLoc, 265 const DeclarationNameInfo &NameInfo, 266 const TemplateArgumentListInfo *TemplateArgs, 267 UnresolvedSetIterator Begin, 268 UnresolvedSetIterator End, 269 bool KnownDependent, 270 bool KnownInstantiationDependent, 271 bool KnownContainsUnexpandedParameterPack) 272 : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent, 273 KnownDependent, 274 (KnownInstantiationDependent || 275 NameInfo.isInstantiationDependent() || 276 (QualifierLoc && 277 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), 278 (KnownContainsUnexpandedParameterPack || 279 NameInfo.containsUnexpandedParameterPack() || 280 (QualifierLoc && 281 QualifierLoc.getNestedNameSpecifier() 282 ->containsUnexpandedParameterPack()))), 283 NameInfo(NameInfo), QualifierLoc(QualifierLoc), 284 Results(0), NumResults(End - Begin), 285 HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid()) 286 { 287 NumResults = End - Begin; 288 if (NumResults) { 289 // Determine whether this expression is type-dependent. 290 for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) { 291 if ((*I)->getDeclContext()->isDependentContext() || 292 isa<UnresolvedUsingValueDecl>(*I)) { 293 ExprBits.TypeDependent = true; 294 ExprBits.ValueDependent = true; 295 ExprBits.InstantiationDependent = true; 296 } 297 } 298 299 Results = static_cast<DeclAccessPair *>( 300 C.Allocate(sizeof(DeclAccessPair) * NumResults, 301 llvm::alignOf<DeclAccessPair>())); 302 memcpy(Results, &*Begin.getIterator(), 303 NumResults * sizeof(DeclAccessPair)); 304 } 305 306 // If we have explicit template arguments, check for dependent 307 // template arguments and whether they contain any unexpanded pack 308 // expansions. 309 if (TemplateArgs) { 310 bool Dependent = false; 311 bool InstantiationDependent = false; 312 bool ContainsUnexpandedParameterPack = false; 313 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, 314 Dependent, 315 InstantiationDependent, 316 ContainsUnexpandedParameterPack); 317 318 if (Dependent) { 319 ExprBits.TypeDependent = true; 320 ExprBits.ValueDependent = true; 321 } 322 if (InstantiationDependent) 323 ExprBits.InstantiationDependent = true; 324 if (ContainsUnexpandedParameterPack) 325 ExprBits.ContainsUnexpandedParameterPack = true; 326 } else if (TemplateKWLoc.isValid()) { 327 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 328 } 329 330 if (isTypeDependent()) 331 setType(C.DependentTy); 332 } 333 334 void OverloadExpr::initializeResults(ASTContext &C, 335 UnresolvedSetIterator Begin, 336 UnresolvedSetIterator End) { 337 assert(Results == 0 && "Results already initialized!"); 338 NumResults = End - Begin; 339 if (NumResults) { 340 Results = static_cast<DeclAccessPair *>( 341 C.Allocate(sizeof(DeclAccessPair) * NumResults, 342 343 llvm::alignOf<DeclAccessPair>())); 344 memcpy(Results, &*Begin.getIterator(), 345 NumResults * sizeof(DeclAccessPair)); 346 } 347 } 348 349 CXXRecordDecl *OverloadExpr::getNamingClass() const { 350 if (isa<UnresolvedLookupExpr>(this)) 351 return cast<UnresolvedLookupExpr>(this)->getNamingClass(); 352 else 353 return cast<UnresolvedMemberExpr>(this)->getNamingClass(); 354 } 355 356 // DependentScopeDeclRefExpr 357 DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T, 358 NestedNameSpecifierLoc QualifierLoc, 359 SourceLocation TemplateKWLoc, 360 const DeclarationNameInfo &NameInfo, 361 const TemplateArgumentListInfo *Args) 362 : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary, 363 true, true, 364 (NameInfo.isInstantiationDependent() || 365 (QualifierLoc && 366 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), 367 (NameInfo.containsUnexpandedParameterPack() || 368 (QualifierLoc && 369 QualifierLoc.getNestedNameSpecifier() 370 ->containsUnexpandedParameterPack()))), 371 QualifierLoc(QualifierLoc), NameInfo(NameInfo), 372 HasTemplateKWAndArgsInfo(Args != 0 || TemplateKWLoc.isValid()) 373 { 374 if (Args) { 375 bool Dependent = true; 376 bool InstantiationDependent = true; 377 bool ContainsUnexpandedParameterPack 378 = ExprBits.ContainsUnexpandedParameterPack; 379 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *Args, 380 Dependent, 381 InstantiationDependent, 382 ContainsUnexpandedParameterPack); 383 ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; 384 } else if (TemplateKWLoc.isValid()) { 385 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 386 } 387 } 388 389 DependentScopeDeclRefExpr * 390 DependentScopeDeclRefExpr::Create(ASTContext &C, 391 NestedNameSpecifierLoc QualifierLoc, 392 SourceLocation TemplateKWLoc, 393 const DeclarationNameInfo &NameInfo, 394 const TemplateArgumentListInfo *Args) { 395 std::size_t size = sizeof(DependentScopeDeclRefExpr); 396 if (Args) 397 size += ASTTemplateKWAndArgsInfo::sizeFor(Args->size()); 398 else if (TemplateKWLoc.isValid()) 399 size += ASTTemplateKWAndArgsInfo::sizeFor(0); 400 void *Mem = C.Allocate(size); 401 return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc, 402 TemplateKWLoc, NameInfo, Args); 403 } 404 405 DependentScopeDeclRefExpr * 406 DependentScopeDeclRefExpr::CreateEmpty(ASTContext &C, 407 bool HasTemplateKWAndArgsInfo, 408 unsigned NumTemplateArgs) { 409 std::size_t size = sizeof(DependentScopeDeclRefExpr); 410 if (HasTemplateKWAndArgsInfo) 411 size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 412 void *Mem = C.Allocate(size); 413 DependentScopeDeclRefExpr *E 414 = new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(), 415 SourceLocation(), 416 DeclarationNameInfo(), 0); 417 E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 418 return E; 419 } 420 421 SourceLocation CXXConstructExpr::getLocStart() const { 422 if (isa<CXXTemporaryObjectExpr>(this)) 423 return cast<CXXTemporaryObjectExpr>(this)->getLocStart(); 424 return Loc; 425 } 426 427 SourceLocation CXXConstructExpr::getLocEnd() const { 428 if (isa<CXXTemporaryObjectExpr>(this)) 429 return cast<CXXTemporaryObjectExpr>(this)->getLocEnd(); 430 431 if (ParenRange.isValid()) 432 return ParenRange.getEnd(); 433 434 SourceLocation End = Loc; 435 for (unsigned I = getNumArgs(); I > 0; --I) { 436 const Expr *Arg = getArg(I-1); 437 if (!Arg->isDefaultArgument()) { 438 SourceLocation NewEnd = Arg->getLocEnd(); 439 if (NewEnd.isValid()) { 440 End = NewEnd; 441 break; 442 } 443 } 444 } 445 446 return End; 447 } 448 449 SourceRange CXXOperatorCallExpr::getSourceRangeImpl() const { 450 OverloadedOperatorKind Kind = getOperator(); 451 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) { 452 if (getNumArgs() == 1) 453 // Prefix operator 454 return SourceRange(getOperatorLoc(), getArg(0)->getLocEnd()); 455 else 456 // Postfix operator 457 return SourceRange(getArg(0)->getLocStart(), getOperatorLoc()); 458 } else if (Kind == OO_Arrow) { 459 return getArg(0)->getSourceRange(); 460 } else if (Kind == OO_Call) { 461 return SourceRange(getArg(0)->getLocStart(), getRParenLoc()); 462 } else if (Kind == OO_Subscript) { 463 return SourceRange(getArg(0)->getLocStart(), getRParenLoc()); 464 } else if (getNumArgs() == 1) { 465 return SourceRange(getOperatorLoc(), getArg(0)->getLocEnd()); 466 } else if (getNumArgs() == 2) { 467 return SourceRange(getArg(0)->getLocStart(), getArg(1)->getLocEnd()); 468 } else { 469 return getOperatorLoc(); 470 } 471 } 472 473 Expr *CXXMemberCallExpr::getImplicitObjectArgument() const { 474 const Expr *Callee = getCallee()->IgnoreParens(); 475 if (const MemberExpr *MemExpr = dyn_cast<MemberExpr>(Callee)) 476 return MemExpr->getBase(); 477 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(Callee)) 478 if (BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI) 479 return BO->getLHS(); 480 481 // FIXME: Will eventually need to cope with member pointers. 482 return 0; 483 } 484 485 CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const { 486 if (const MemberExpr *MemExpr = 487 dyn_cast<MemberExpr>(getCallee()->IgnoreParens())) 488 return cast<CXXMethodDecl>(MemExpr->getMemberDecl()); 489 490 // FIXME: Will eventually need to cope with member pointers. 491 return 0; 492 } 493 494 495 CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() const { 496 Expr* ThisArg = getImplicitObjectArgument(); 497 if (!ThisArg) 498 return 0; 499 500 if (ThisArg->getType()->isAnyPointerType()) 501 return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl(); 502 503 return ThisArg->getType()->getAsCXXRecordDecl(); 504 } 505 506 507 //===----------------------------------------------------------------------===// 508 // Named casts 509 //===----------------------------------------------------------------------===// 510 511 /// getCastName - Get the name of the C++ cast being used, e.g., 512 /// "static_cast", "dynamic_cast", "reinterpret_cast", or 513 /// "const_cast". The returned pointer must not be freed. 514 const char *CXXNamedCastExpr::getCastName() const { 515 switch (getStmtClass()) { 516 case CXXStaticCastExprClass: return "static_cast"; 517 case CXXDynamicCastExprClass: return "dynamic_cast"; 518 case CXXReinterpretCastExprClass: return "reinterpret_cast"; 519 case CXXConstCastExprClass: return "const_cast"; 520 default: return "<invalid cast>"; 521 } 522 } 523 524 CXXStaticCastExpr *CXXStaticCastExpr::Create(ASTContext &C, QualType T, 525 ExprValueKind VK, 526 CastKind K, Expr *Op, 527 const CXXCastPath *BasePath, 528 TypeSourceInfo *WrittenTy, 529 SourceLocation L, 530 SourceLocation RParenLoc, 531 SourceRange AngleBrackets) { 532 unsigned PathSize = (BasePath ? BasePath->size() : 0); 533 void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr) 534 + PathSize * sizeof(CXXBaseSpecifier*)); 535 CXXStaticCastExpr *E = 536 new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 537 RParenLoc, AngleBrackets); 538 if (PathSize) E->setCastPath(*BasePath); 539 return E; 540 } 541 542 CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext &C, 543 unsigned PathSize) { 544 void *Buffer = 545 C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 546 return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize); 547 } 548 549 CXXDynamicCastExpr *CXXDynamicCastExpr::Create(ASTContext &C, QualType T, 550 ExprValueKind VK, 551 CastKind K, Expr *Op, 552 const CXXCastPath *BasePath, 553 TypeSourceInfo *WrittenTy, 554 SourceLocation L, 555 SourceLocation RParenLoc, 556 SourceRange AngleBrackets) { 557 unsigned PathSize = (BasePath ? BasePath->size() : 0); 558 void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr) 559 + PathSize * sizeof(CXXBaseSpecifier*)); 560 CXXDynamicCastExpr *E = 561 new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 562 RParenLoc, AngleBrackets); 563 if (PathSize) E->setCastPath(*BasePath); 564 return E; 565 } 566 567 CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext &C, 568 unsigned PathSize) { 569 void *Buffer = 570 C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 571 return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize); 572 } 573 574 /// isAlwaysNull - Return whether the result of the dynamic_cast is proven 575 /// to always be null. For example: 576 /// 577 /// struct A { }; 578 /// struct B final : A { }; 579 /// struct C { }; 580 /// 581 /// C *f(B* b) { return dynamic_cast<C*>(b); } 582 bool CXXDynamicCastExpr::isAlwaysNull() const 583 { 584 QualType SrcType = getSubExpr()->getType(); 585 QualType DestType = getType(); 586 587 if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) { 588 SrcType = SrcPTy->getPointeeType(); 589 DestType = DestType->castAs<PointerType>()->getPointeeType(); 590 } 591 592 if (DestType->isVoidType()) 593 return false; 594 595 const CXXRecordDecl *SrcRD = 596 cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl()); 597 598 if (!SrcRD->hasAttr<FinalAttr>()) 599 return false; 600 601 const CXXRecordDecl *DestRD = 602 cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl()); 603 604 return !DestRD->isDerivedFrom(SrcRD); 605 } 606 607 CXXReinterpretCastExpr * 608 CXXReinterpretCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK, 609 CastKind K, Expr *Op, 610 const CXXCastPath *BasePath, 611 TypeSourceInfo *WrittenTy, SourceLocation L, 612 SourceLocation RParenLoc, 613 SourceRange AngleBrackets) { 614 unsigned PathSize = (BasePath ? BasePath->size() : 0); 615 void *Buffer = 616 C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 617 CXXReinterpretCastExpr *E = 618 new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 619 RParenLoc, AngleBrackets); 620 if (PathSize) E->setCastPath(*BasePath); 621 return E; 622 } 623 624 CXXReinterpretCastExpr * 625 CXXReinterpretCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) { 626 void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr) 627 + PathSize * sizeof(CXXBaseSpecifier*)); 628 return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize); 629 } 630 631 CXXConstCastExpr *CXXConstCastExpr::Create(ASTContext &C, QualType T, 632 ExprValueKind VK, Expr *Op, 633 TypeSourceInfo *WrittenTy, 634 SourceLocation L, 635 SourceLocation RParenLoc, 636 SourceRange AngleBrackets) { 637 return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets); 638 } 639 640 CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext &C) { 641 return new (C) CXXConstCastExpr(EmptyShell()); 642 } 643 644 CXXFunctionalCastExpr * 645 CXXFunctionalCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK, 646 TypeSourceInfo *Written, SourceLocation L, 647 CastKind K, Expr *Op, const CXXCastPath *BasePath, 648 SourceLocation R) { 649 unsigned PathSize = (BasePath ? BasePath->size() : 0); 650 void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr) 651 + PathSize * sizeof(CXXBaseSpecifier*)); 652 CXXFunctionalCastExpr *E = 653 new (Buffer) CXXFunctionalCastExpr(T, VK, Written, L, K, Op, PathSize, R); 654 if (PathSize) E->setCastPath(*BasePath); 655 return E; 656 } 657 658 CXXFunctionalCastExpr * 659 CXXFunctionalCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) { 660 void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr) 661 + PathSize * sizeof(CXXBaseSpecifier*)); 662 return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize); 663 } 664 665 UserDefinedLiteral::LiteralOperatorKind 666 UserDefinedLiteral::getLiteralOperatorKind() const { 667 if (getNumArgs() == 0) 668 return LOK_Template; 669 if (getNumArgs() == 2) 670 return LOK_String; 671 672 assert(getNumArgs() == 1 && "unexpected #args in literal operator call"); 673 QualType ParamTy = 674 cast<FunctionDecl>(getCalleeDecl())->getParamDecl(0)->getType(); 675 if (ParamTy->isPointerType()) 676 return LOK_Raw; 677 if (ParamTy->isAnyCharacterType()) 678 return LOK_Character; 679 if (ParamTy->isIntegerType()) 680 return LOK_Integer; 681 if (ParamTy->isFloatingType()) 682 return LOK_Floating; 683 684 llvm_unreachable("unknown kind of literal operator"); 685 } 686 687 Expr *UserDefinedLiteral::getCookedLiteral() { 688 #ifndef NDEBUG 689 LiteralOperatorKind LOK = getLiteralOperatorKind(); 690 assert(LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal"); 691 #endif 692 return getArg(0); 693 } 694 695 const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const { 696 return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier(); 697 } 698 699 CXXDefaultArgExpr * 700 CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc, 701 ParmVarDecl *Param, Expr *SubExpr) { 702 void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *)); 703 return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, 704 SubExpr); 705 } 706 707 CXXTemporary *CXXTemporary::Create(ASTContext &C, 708 const CXXDestructorDecl *Destructor) { 709 return new (C) CXXTemporary(Destructor); 710 } 711 712 CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C, 713 CXXTemporary *Temp, 714 Expr* SubExpr) { 715 assert((SubExpr->getType()->isRecordType() || 716 SubExpr->getType()->isArrayType()) && 717 "Expression bound to a temporary must have record or array type!"); 718 719 return new (C) CXXBindTemporaryExpr(Temp, SubExpr); 720 } 721 722 CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C, 723 CXXConstructorDecl *Cons, 724 TypeSourceInfo *Type, 725 ArrayRef<Expr*> Args, 726 SourceRange parenRange, 727 bool HadMultipleCandidates, 728 bool ListInitialization, 729 bool ZeroInitialization) 730 : CXXConstructExpr(C, CXXTemporaryObjectExprClass, 731 Type->getType().getNonReferenceType(), 732 Type->getTypeLoc().getBeginLoc(), 733 Cons, false, Args, 734 HadMultipleCandidates, 735 ListInitialization, ZeroInitialization, 736 CXXConstructExpr::CK_Complete, parenRange), 737 Type(Type) { 738 } 739 740 SourceLocation CXXTemporaryObjectExpr::getLocStart() const { 741 return Type->getTypeLoc().getBeginLoc(); 742 } 743 744 SourceLocation CXXTemporaryObjectExpr::getLocEnd() const { 745 return getParenRange().getEnd(); 746 } 747 748 CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T, 749 SourceLocation Loc, 750 CXXConstructorDecl *D, bool Elidable, 751 ArrayRef<Expr*> Args, 752 bool HadMultipleCandidates, 753 bool ListInitialization, 754 bool ZeroInitialization, 755 ConstructionKind ConstructKind, 756 SourceRange ParenRange) { 757 return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D, 758 Elidable, Args, 759 HadMultipleCandidates, ListInitialization, 760 ZeroInitialization, ConstructKind, 761 ParenRange); 762 } 763 764 CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T, 765 SourceLocation Loc, 766 CXXConstructorDecl *D, bool elidable, 767 ArrayRef<Expr*> args, 768 bool HadMultipleCandidates, 769 bool ListInitialization, 770 bool ZeroInitialization, 771 ConstructionKind ConstructKind, 772 SourceRange ParenRange) 773 : Expr(SC, T, VK_RValue, OK_Ordinary, 774 T->isDependentType(), T->isDependentType(), 775 T->isInstantiationDependentType(), 776 T->containsUnexpandedParameterPack()), 777 Constructor(D), Loc(Loc), ParenRange(ParenRange), NumArgs(args.size()), 778 Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates), 779 ListInitialization(ListInitialization), 780 ZeroInitialization(ZeroInitialization), 781 ConstructKind(ConstructKind), Args(0) 782 { 783 if (NumArgs) { 784 Args = new (C) Stmt*[args.size()]; 785 786 for (unsigned i = 0; i != args.size(); ++i) { 787 assert(args[i] && "NULL argument in CXXConstructExpr"); 788 789 if (args[i]->isValueDependent()) 790 ExprBits.ValueDependent = true; 791 if (args[i]->isInstantiationDependent()) 792 ExprBits.InstantiationDependent = true; 793 if (args[i]->containsUnexpandedParameterPack()) 794 ExprBits.ContainsUnexpandedParameterPack = true; 795 796 Args[i] = args[i]; 797 } 798 } 799 } 800 801 LambdaExpr::Capture::Capture(SourceLocation Loc, bool Implicit, 802 LambdaCaptureKind Kind, VarDecl *Var, 803 SourceLocation EllipsisLoc) 804 : VarAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc) 805 { 806 unsigned Bits = 0; 807 if (Implicit) 808 Bits |= Capture_Implicit; 809 810 switch (Kind) { 811 case LCK_This: 812 assert(Var == 0 && "'this' capture cannot have a variable!"); 813 break; 814 815 case LCK_ByCopy: 816 Bits |= Capture_ByCopy; 817 // Fall through 818 case LCK_ByRef: 819 assert(Var && "capture must have a variable!"); 820 break; 821 } 822 VarAndBits.setInt(Bits); 823 } 824 825 LambdaCaptureKind LambdaExpr::Capture::getCaptureKind() const { 826 if (capturesThis()) 827 return LCK_This; 828 829 return (VarAndBits.getInt() & Capture_ByCopy)? LCK_ByCopy : LCK_ByRef; 830 } 831 832 LambdaExpr::LambdaExpr(QualType T, 833 SourceRange IntroducerRange, 834 LambdaCaptureDefault CaptureDefault, 835 ArrayRef<Capture> Captures, 836 bool ExplicitParams, 837 bool ExplicitResultType, 838 ArrayRef<Expr *> CaptureInits, 839 ArrayRef<VarDecl *> ArrayIndexVars, 840 ArrayRef<unsigned> ArrayIndexStarts, 841 SourceLocation ClosingBrace, 842 bool ContainsUnexpandedParameterPack) 843 : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary, 844 T->isDependentType(), T->isDependentType(), T->isDependentType(), 845 ContainsUnexpandedParameterPack), 846 IntroducerRange(IntroducerRange), 847 NumCaptures(Captures.size()), 848 CaptureDefault(CaptureDefault), 849 ExplicitParams(ExplicitParams), 850 ExplicitResultType(ExplicitResultType), 851 ClosingBrace(ClosingBrace) 852 { 853 assert(CaptureInits.size() == Captures.size() && "Wrong number of arguments"); 854 CXXRecordDecl *Class = getLambdaClass(); 855 CXXRecordDecl::LambdaDefinitionData &Data = Class->getLambdaData(); 856 857 // FIXME: Propagate "has unexpanded parameter pack" bit. 858 859 // Copy captures. 860 ASTContext &Context = Class->getASTContext(); 861 Data.NumCaptures = NumCaptures; 862 Data.NumExplicitCaptures = 0; 863 Data.Captures = (Capture *)Context.Allocate(sizeof(Capture) * NumCaptures); 864 Capture *ToCapture = Data.Captures; 865 for (unsigned I = 0, N = Captures.size(); I != N; ++I) { 866 if (Captures[I].isExplicit()) 867 ++Data.NumExplicitCaptures; 868 869 *ToCapture++ = Captures[I]; 870 } 871 872 // Copy initialization expressions for the non-static data members. 873 Stmt **Stored = getStoredStmts(); 874 for (unsigned I = 0, N = CaptureInits.size(); I != N; ++I) 875 *Stored++ = CaptureInits[I]; 876 877 // Copy the body of the lambda. 878 *Stored++ = getCallOperator()->getBody(); 879 880 // Copy the array index variables, if any. 881 HasArrayIndexVars = !ArrayIndexVars.empty(); 882 if (HasArrayIndexVars) { 883 assert(ArrayIndexStarts.size() == NumCaptures); 884 memcpy(getArrayIndexVars(), ArrayIndexVars.data(), 885 sizeof(VarDecl *) * ArrayIndexVars.size()); 886 memcpy(getArrayIndexStarts(), ArrayIndexStarts.data(), 887 sizeof(unsigned) * Captures.size()); 888 getArrayIndexStarts()[Captures.size()] = ArrayIndexVars.size(); 889 } 890 } 891 892 LambdaExpr *LambdaExpr::Create(ASTContext &Context, 893 CXXRecordDecl *Class, 894 SourceRange IntroducerRange, 895 LambdaCaptureDefault CaptureDefault, 896 ArrayRef<Capture> Captures, 897 bool ExplicitParams, 898 bool ExplicitResultType, 899 ArrayRef<Expr *> CaptureInits, 900 ArrayRef<VarDecl *> ArrayIndexVars, 901 ArrayRef<unsigned> ArrayIndexStarts, 902 SourceLocation ClosingBrace, 903 bool ContainsUnexpandedParameterPack) { 904 // Determine the type of the expression (i.e., the type of the 905 // function object we're creating). 906 QualType T = Context.getTypeDeclType(Class); 907 908 unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (Captures.size() + 1); 909 if (!ArrayIndexVars.empty()) { 910 Size += sizeof(unsigned) * (Captures.size() + 1); 911 // Realign for following VarDecl array. 912 Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<VarDecl*>()); 913 Size += sizeof(VarDecl *) * ArrayIndexVars.size(); 914 } 915 void *Mem = Context.Allocate(Size); 916 return new (Mem) LambdaExpr(T, IntroducerRange, CaptureDefault, 917 Captures, ExplicitParams, ExplicitResultType, 918 CaptureInits, ArrayIndexVars, ArrayIndexStarts, 919 ClosingBrace, ContainsUnexpandedParameterPack); 920 } 921 922 LambdaExpr *LambdaExpr::CreateDeserialized(ASTContext &C, unsigned NumCaptures, 923 unsigned NumArrayIndexVars) { 924 unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (NumCaptures + 1); 925 if (NumArrayIndexVars) 926 Size += sizeof(VarDecl) * NumArrayIndexVars 927 + sizeof(unsigned) * (NumCaptures + 1); 928 void *Mem = C.Allocate(Size); 929 return new (Mem) LambdaExpr(EmptyShell(), NumCaptures, NumArrayIndexVars > 0); 930 } 931 932 LambdaExpr::capture_iterator LambdaExpr::capture_begin() const { 933 return getLambdaClass()->getLambdaData().Captures; 934 } 935 936 LambdaExpr::capture_iterator LambdaExpr::capture_end() const { 937 return capture_begin() + NumCaptures; 938 } 939 940 LambdaExpr::capture_iterator LambdaExpr::explicit_capture_begin() const { 941 return capture_begin(); 942 } 943 944 LambdaExpr::capture_iterator LambdaExpr::explicit_capture_end() const { 945 struct CXXRecordDecl::LambdaDefinitionData &Data 946 = getLambdaClass()->getLambdaData(); 947 return Data.Captures + Data.NumExplicitCaptures; 948 } 949 950 LambdaExpr::capture_iterator LambdaExpr::implicit_capture_begin() const { 951 return explicit_capture_end(); 952 } 953 954 LambdaExpr::capture_iterator LambdaExpr::implicit_capture_end() const { 955 return capture_end(); 956 } 957 958 ArrayRef<VarDecl *> 959 LambdaExpr::getCaptureInitIndexVars(capture_init_iterator Iter) const { 960 assert(HasArrayIndexVars && "No array index-var data?"); 961 962 unsigned Index = Iter - capture_init_begin(); 963 assert(Index < getLambdaClass()->getLambdaData().NumCaptures && 964 "Capture index out-of-range"); 965 VarDecl **IndexVars = getArrayIndexVars(); 966 unsigned *IndexStarts = getArrayIndexStarts(); 967 return ArrayRef<VarDecl *>(IndexVars + IndexStarts[Index], 968 IndexVars + IndexStarts[Index + 1]); 969 } 970 971 CXXRecordDecl *LambdaExpr::getLambdaClass() const { 972 return getType()->getAsCXXRecordDecl(); 973 } 974 975 CXXMethodDecl *LambdaExpr::getCallOperator() const { 976 CXXRecordDecl *Record = getLambdaClass(); 977 DeclarationName Name 978 = Record->getASTContext().DeclarationNames.getCXXOperatorName(OO_Call); 979 DeclContext::lookup_result Calls = Record->lookup(Name); 980 assert(!Calls.empty() && "Missing lambda call operator!"); 981 assert(Calls.size() == 1 && "More than one lambda call operator!"); 982 CXXMethodDecl *Result = cast<CXXMethodDecl>(Calls.front()); 983 return Result; 984 } 985 986 CompoundStmt *LambdaExpr::getBody() const { 987 if (!getStoredStmts()[NumCaptures]) 988 getStoredStmts()[NumCaptures] = getCallOperator()->getBody(); 989 990 return reinterpret_cast<CompoundStmt *>(getStoredStmts()[NumCaptures]); 991 } 992 993 bool LambdaExpr::isMutable() const { 994 return !getCallOperator()->isConst(); 995 } 996 997 ExprWithCleanups::ExprWithCleanups(Expr *subexpr, 998 ArrayRef<CleanupObject> objects) 999 : Expr(ExprWithCleanupsClass, subexpr->getType(), 1000 subexpr->getValueKind(), subexpr->getObjectKind(), 1001 subexpr->isTypeDependent(), subexpr->isValueDependent(), 1002 subexpr->isInstantiationDependent(), 1003 subexpr->containsUnexpandedParameterPack()), 1004 SubExpr(subexpr) { 1005 ExprWithCleanupsBits.NumObjects = objects.size(); 1006 for (unsigned i = 0, e = objects.size(); i != e; ++i) 1007 getObjectsBuffer()[i] = objects[i]; 1008 } 1009 1010 ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, Expr *subexpr, 1011 ArrayRef<CleanupObject> objects) { 1012 size_t size = sizeof(ExprWithCleanups) 1013 + objects.size() * sizeof(CleanupObject); 1014 void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>()); 1015 return new (buffer) ExprWithCleanups(subexpr, objects); 1016 } 1017 1018 ExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects) 1019 : Expr(ExprWithCleanupsClass, empty) { 1020 ExprWithCleanupsBits.NumObjects = numObjects; 1021 } 1022 1023 ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, EmptyShell empty, 1024 unsigned numObjects) { 1025 size_t size = sizeof(ExprWithCleanups) + numObjects * sizeof(CleanupObject); 1026 void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>()); 1027 return new (buffer) ExprWithCleanups(empty, numObjects); 1028 } 1029 1030 CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type, 1031 SourceLocation LParenLoc, 1032 ArrayRef<Expr*> Args, 1033 SourceLocation RParenLoc) 1034 : Expr(CXXUnresolvedConstructExprClass, 1035 Type->getType().getNonReferenceType(), 1036 (Type->getType()->isLValueReferenceType() ? VK_LValue 1037 :Type->getType()->isRValueReferenceType()? VK_XValue 1038 :VK_RValue), 1039 OK_Ordinary, 1040 Type->getType()->isDependentType(), true, true, 1041 Type->getType()->containsUnexpandedParameterPack()), 1042 Type(Type), 1043 LParenLoc(LParenLoc), 1044 RParenLoc(RParenLoc), 1045 NumArgs(Args.size()) { 1046 Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1); 1047 for (unsigned I = 0; I != Args.size(); ++I) { 1048 if (Args[I]->containsUnexpandedParameterPack()) 1049 ExprBits.ContainsUnexpandedParameterPack = true; 1050 1051 StoredArgs[I] = Args[I]; 1052 } 1053 } 1054 1055 CXXUnresolvedConstructExpr * 1056 CXXUnresolvedConstructExpr::Create(ASTContext &C, 1057 TypeSourceInfo *Type, 1058 SourceLocation LParenLoc, 1059 ArrayRef<Expr*> Args, 1060 SourceLocation RParenLoc) { 1061 void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) + 1062 sizeof(Expr *) * Args.size()); 1063 return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc, Args, RParenLoc); 1064 } 1065 1066 CXXUnresolvedConstructExpr * 1067 CXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) { 1068 Stmt::EmptyShell Empty; 1069 void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) + 1070 sizeof(Expr *) * NumArgs); 1071 return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs); 1072 } 1073 1074 SourceLocation CXXUnresolvedConstructExpr::getLocStart() const { 1075 return Type->getTypeLoc().getBeginLoc(); 1076 } 1077 1078 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C, 1079 Expr *Base, QualType BaseType, 1080 bool IsArrow, 1081 SourceLocation OperatorLoc, 1082 NestedNameSpecifierLoc QualifierLoc, 1083 SourceLocation TemplateKWLoc, 1084 NamedDecl *FirstQualifierFoundInScope, 1085 DeclarationNameInfo MemberNameInfo, 1086 const TemplateArgumentListInfo *TemplateArgs) 1087 : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, 1088 VK_LValue, OK_Ordinary, true, true, true, 1089 ((Base && Base->containsUnexpandedParameterPack()) || 1090 (QualifierLoc && 1091 QualifierLoc.getNestedNameSpecifier() 1092 ->containsUnexpandedParameterPack()) || 1093 MemberNameInfo.containsUnexpandedParameterPack())), 1094 Base(Base), BaseType(BaseType), IsArrow(IsArrow), 1095 HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid()), 1096 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 1097 FirstQualifierFoundInScope(FirstQualifierFoundInScope), 1098 MemberNameInfo(MemberNameInfo) { 1099 if (TemplateArgs) { 1100 bool Dependent = true; 1101 bool InstantiationDependent = true; 1102 bool ContainsUnexpandedParameterPack = false; 1103 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, 1104 Dependent, 1105 InstantiationDependent, 1106 ContainsUnexpandedParameterPack); 1107 if (ContainsUnexpandedParameterPack) 1108 ExprBits.ContainsUnexpandedParameterPack = true; 1109 } else if (TemplateKWLoc.isValid()) { 1110 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 1111 } 1112 } 1113 1114 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C, 1115 Expr *Base, QualType BaseType, 1116 bool IsArrow, 1117 SourceLocation OperatorLoc, 1118 NestedNameSpecifierLoc QualifierLoc, 1119 NamedDecl *FirstQualifierFoundInScope, 1120 DeclarationNameInfo MemberNameInfo) 1121 : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, 1122 VK_LValue, OK_Ordinary, true, true, true, 1123 ((Base && Base->containsUnexpandedParameterPack()) || 1124 (QualifierLoc && 1125 QualifierLoc.getNestedNameSpecifier()-> 1126 containsUnexpandedParameterPack()) || 1127 MemberNameInfo.containsUnexpandedParameterPack())), 1128 Base(Base), BaseType(BaseType), IsArrow(IsArrow), 1129 HasTemplateKWAndArgsInfo(false), 1130 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 1131 FirstQualifierFoundInScope(FirstQualifierFoundInScope), 1132 MemberNameInfo(MemberNameInfo) { } 1133 1134 CXXDependentScopeMemberExpr * 1135 CXXDependentScopeMemberExpr::Create(ASTContext &C, 1136 Expr *Base, QualType BaseType, bool IsArrow, 1137 SourceLocation OperatorLoc, 1138 NestedNameSpecifierLoc QualifierLoc, 1139 SourceLocation TemplateKWLoc, 1140 NamedDecl *FirstQualifierFoundInScope, 1141 DeclarationNameInfo MemberNameInfo, 1142 const TemplateArgumentListInfo *TemplateArgs) { 1143 if (!TemplateArgs && !TemplateKWLoc.isValid()) 1144 return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType, 1145 IsArrow, OperatorLoc, 1146 QualifierLoc, 1147 FirstQualifierFoundInScope, 1148 MemberNameInfo); 1149 1150 unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0; 1151 std::size_t size = sizeof(CXXDependentScopeMemberExpr) 1152 + ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1153 1154 void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>()); 1155 return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType, 1156 IsArrow, OperatorLoc, 1157 QualifierLoc, 1158 TemplateKWLoc, 1159 FirstQualifierFoundInScope, 1160 MemberNameInfo, TemplateArgs); 1161 } 1162 1163 CXXDependentScopeMemberExpr * 1164 CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C, 1165 bool HasTemplateKWAndArgsInfo, 1166 unsigned NumTemplateArgs) { 1167 if (!HasTemplateKWAndArgsInfo) 1168 return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(), 1169 0, SourceLocation(), 1170 NestedNameSpecifierLoc(), 0, 1171 DeclarationNameInfo()); 1172 1173 std::size_t size = sizeof(CXXDependentScopeMemberExpr) + 1174 ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1175 void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>()); 1176 CXXDependentScopeMemberExpr *E 1177 = new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(), 1178 0, SourceLocation(), 1179 NestedNameSpecifierLoc(), 1180 SourceLocation(), 0, 1181 DeclarationNameInfo(), 0); 1182 E->HasTemplateKWAndArgsInfo = true; 1183 return E; 1184 } 1185 1186 bool CXXDependentScopeMemberExpr::isImplicitAccess() const { 1187 if (Base == 0) 1188 return true; 1189 1190 return cast<Expr>(Base)->isImplicitCXXThis(); 1191 } 1192 1193 static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin, 1194 UnresolvedSetIterator end) { 1195 do { 1196 NamedDecl *decl = *begin; 1197 if (isa<UnresolvedUsingValueDecl>(decl)) 1198 return false; 1199 if (isa<UsingShadowDecl>(decl)) 1200 decl = cast<UsingShadowDecl>(decl)->getUnderlyingDecl(); 1201 1202 // Unresolved member expressions should only contain methods and 1203 // method templates. 1204 assert(isa<CXXMethodDecl>(decl) || isa<FunctionTemplateDecl>(decl)); 1205 1206 if (isa<FunctionTemplateDecl>(decl)) 1207 decl = cast<FunctionTemplateDecl>(decl)->getTemplatedDecl(); 1208 if (cast<CXXMethodDecl>(decl)->isStatic()) 1209 return false; 1210 } while (++begin != end); 1211 1212 return true; 1213 } 1214 1215 UnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C, 1216 bool HasUnresolvedUsing, 1217 Expr *Base, QualType BaseType, 1218 bool IsArrow, 1219 SourceLocation OperatorLoc, 1220 NestedNameSpecifierLoc QualifierLoc, 1221 SourceLocation TemplateKWLoc, 1222 const DeclarationNameInfo &MemberNameInfo, 1223 const TemplateArgumentListInfo *TemplateArgs, 1224 UnresolvedSetIterator Begin, 1225 UnresolvedSetIterator End) 1226 : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, TemplateKWLoc, 1227 MemberNameInfo, TemplateArgs, Begin, End, 1228 // Dependent 1229 ((Base && Base->isTypeDependent()) || 1230 BaseType->isDependentType()), 1231 ((Base && Base->isInstantiationDependent()) || 1232 BaseType->isInstantiationDependentType()), 1233 // Contains unexpanded parameter pack 1234 ((Base && Base->containsUnexpandedParameterPack()) || 1235 BaseType->containsUnexpandedParameterPack())), 1236 IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing), 1237 Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) { 1238 1239 // Check whether all of the members are non-static member functions, 1240 // and if so, mark give this bound-member type instead of overload type. 1241 if (hasOnlyNonStaticMemberFunctions(Begin, End)) 1242 setType(C.BoundMemberTy); 1243 } 1244 1245 bool UnresolvedMemberExpr::isImplicitAccess() const { 1246 if (Base == 0) 1247 return true; 1248 1249 return cast<Expr>(Base)->isImplicitCXXThis(); 1250 } 1251 1252 UnresolvedMemberExpr * 1253 UnresolvedMemberExpr::Create(ASTContext &C, 1254 bool HasUnresolvedUsing, 1255 Expr *Base, QualType BaseType, bool IsArrow, 1256 SourceLocation OperatorLoc, 1257 NestedNameSpecifierLoc QualifierLoc, 1258 SourceLocation TemplateKWLoc, 1259 const DeclarationNameInfo &MemberNameInfo, 1260 const TemplateArgumentListInfo *TemplateArgs, 1261 UnresolvedSetIterator Begin, 1262 UnresolvedSetIterator End) { 1263 std::size_t size = sizeof(UnresolvedMemberExpr); 1264 if (TemplateArgs) 1265 size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size()); 1266 else if (TemplateKWLoc.isValid()) 1267 size += ASTTemplateKWAndArgsInfo::sizeFor(0); 1268 1269 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>()); 1270 return new (Mem) UnresolvedMemberExpr(C, 1271 HasUnresolvedUsing, Base, BaseType, 1272 IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc, 1273 MemberNameInfo, TemplateArgs, Begin, End); 1274 } 1275 1276 UnresolvedMemberExpr * 1277 UnresolvedMemberExpr::CreateEmpty(ASTContext &C, bool HasTemplateKWAndArgsInfo, 1278 unsigned NumTemplateArgs) { 1279 std::size_t size = sizeof(UnresolvedMemberExpr); 1280 if (HasTemplateKWAndArgsInfo) 1281 size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 1282 1283 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>()); 1284 UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell()); 1285 E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo; 1286 return E; 1287 } 1288 1289 CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const { 1290 // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this. 1291 1292 // If there was a nested name specifier, it names the naming class. 1293 // It can't be dependent: after all, we were actually able to do the 1294 // lookup. 1295 CXXRecordDecl *Record = 0; 1296 if (getQualifier()) { 1297 const Type *T = getQualifier()->getAsType(); 1298 assert(T && "qualifier in member expression does not name type"); 1299 Record = T->getAsCXXRecordDecl(); 1300 assert(Record && "qualifier in member expression does not name record"); 1301 } 1302 // Otherwise the naming class must have been the base class. 1303 else { 1304 QualType BaseType = getBaseType().getNonReferenceType(); 1305 if (isArrow()) { 1306 const PointerType *PT = BaseType->getAs<PointerType>(); 1307 assert(PT && "base of arrow member access is not pointer"); 1308 BaseType = PT->getPointeeType(); 1309 } 1310 1311 Record = BaseType->getAsCXXRecordDecl(); 1312 assert(Record && "base of member expression does not name record"); 1313 } 1314 1315 return Record; 1316 } 1317 1318 SubstNonTypeTemplateParmPackExpr:: 1319 SubstNonTypeTemplateParmPackExpr(QualType T, 1320 NonTypeTemplateParmDecl *Param, 1321 SourceLocation NameLoc, 1322 const TemplateArgument &ArgPack) 1323 : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary, 1324 true, true, true, true), 1325 Param(Param), Arguments(ArgPack.pack_begin()), 1326 NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { } 1327 1328 TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const { 1329 return TemplateArgument(Arguments, NumArguments); 1330 } 1331 1332 FunctionParmPackExpr::FunctionParmPackExpr(QualType T, ParmVarDecl *ParamPack, 1333 SourceLocation NameLoc, 1334 unsigned NumParams, 1335 Decl * const *Params) 1336 : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary, 1337 true, true, true, true), 1338 ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) { 1339 if (Params) 1340 std::uninitialized_copy(Params, Params + NumParams, 1341 reinterpret_cast<Decl**>(this+1)); 1342 } 1343 1344 FunctionParmPackExpr * 1345 FunctionParmPackExpr::Create(ASTContext &Context, QualType T, 1346 ParmVarDecl *ParamPack, SourceLocation NameLoc, 1347 ArrayRef<Decl *> Params) { 1348 return new (Context.Allocate(sizeof(FunctionParmPackExpr) + 1349 sizeof(ParmVarDecl*) * Params.size())) 1350 FunctionParmPackExpr(T, ParamPack, NameLoc, Params.size(), Params.data()); 1351 } 1352 1353 FunctionParmPackExpr * 1354 FunctionParmPackExpr::CreateEmpty(ASTContext &Context, unsigned NumParams) { 1355 return new (Context.Allocate(sizeof(FunctionParmPackExpr) + 1356 sizeof(ParmVarDecl*) * NumParams)) 1357 FunctionParmPackExpr(QualType(), 0, SourceLocation(), 0, 0); 1358 } 1359 1360 TypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind, 1361 ArrayRef<TypeSourceInfo *> Args, 1362 SourceLocation RParenLoc, 1363 bool Value) 1364 : Expr(TypeTraitExprClass, T, VK_RValue, OK_Ordinary, 1365 /*TypeDependent=*/false, 1366 /*ValueDependent=*/false, 1367 /*InstantiationDependent=*/false, 1368 /*ContainsUnexpandedParameterPack=*/false), 1369 Loc(Loc), RParenLoc(RParenLoc) 1370 { 1371 TypeTraitExprBits.Kind = Kind; 1372 TypeTraitExprBits.Value = Value; 1373 TypeTraitExprBits.NumArgs = Args.size(); 1374 1375 TypeSourceInfo **ToArgs = getTypeSourceInfos(); 1376 1377 for (unsigned I = 0, N = Args.size(); I != N; ++I) { 1378 if (Args[I]->getType()->isDependentType()) 1379 setValueDependent(true); 1380 if (Args[I]->getType()->isInstantiationDependentType()) 1381 setInstantiationDependent(true); 1382 if (Args[I]->getType()->containsUnexpandedParameterPack()) 1383 setContainsUnexpandedParameterPack(true); 1384 1385 ToArgs[I] = Args[I]; 1386 } 1387 } 1388 1389 TypeTraitExpr *TypeTraitExpr::Create(ASTContext &C, QualType T, 1390 SourceLocation Loc, 1391 TypeTrait Kind, 1392 ArrayRef<TypeSourceInfo *> Args, 1393 SourceLocation RParenLoc, 1394 bool Value) { 1395 unsigned Size = sizeof(TypeTraitExpr) + sizeof(TypeSourceInfo*) * Args.size(); 1396 void *Mem = C.Allocate(Size); 1397 return new (Mem) TypeTraitExpr(T, Loc, Kind, Args, RParenLoc, Value); 1398 } 1399 1400 TypeTraitExpr *TypeTraitExpr::CreateDeserialized(ASTContext &C, 1401 unsigned NumArgs) { 1402 unsigned Size = sizeof(TypeTraitExpr) + sizeof(TypeSourceInfo*) * NumArgs; 1403 void *Mem = C.Allocate(Size); 1404 return new (Mem) TypeTraitExpr(EmptyShell()); 1405 } 1406 1407 void ArrayTypeTraitExpr::anchor() { } 1408