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/Basic/IdentifierTable.h" 15 #include "clang/AST/DeclCXX.h" 16 #include "clang/AST/DeclTemplate.h" 17 #include "clang/AST/ExprCXX.h" 18 #include "clang/AST/TypeLoc.h" 19 using namespace clang; 20 21 22 //===----------------------------------------------------------------------===// 23 // Child Iterators for iterating over subexpressions/substatements 24 //===----------------------------------------------------------------------===// 25 26 QualType CXXTypeidExpr::getTypeOperand() const { 27 assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)"); 28 return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType() 29 .getUnqualifiedType(); 30 } 31 32 QualType CXXUuidofExpr::getTypeOperand() const { 33 assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)"); 34 return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType() 35 .getUnqualifiedType(); 36 } 37 38 // CXXScalarValueInitExpr 39 SourceRange CXXScalarValueInitExpr::getSourceRange() const { 40 SourceLocation Start = RParenLoc; 41 if (TypeInfo) 42 Start = TypeInfo->getTypeLoc().getBeginLoc(); 43 return SourceRange(Start, RParenLoc); 44 } 45 46 // CXXNewExpr 47 CXXNewExpr::CXXNewExpr(ASTContext &C, bool globalNew, FunctionDecl *operatorNew, 48 Expr **placementArgs, unsigned numPlaceArgs, 49 SourceRange TypeIdParens, Expr *arraySize, 50 CXXConstructorDecl *constructor, bool initializer, 51 Expr **constructorArgs, unsigned numConsArgs, 52 bool HadMultipleCandidates, 53 FunctionDecl *operatorDelete, 54 bool usualArrayDeleteWantsSize, QualType ty, 55 TypeSourceInfo *AllocatedTypeInfo, 56 SourceLocation startLoc, SourceLocation endLoc, 57 SourceLocation constructorLParen, 58 SourceLocation constructorRParen) 59 : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary, 60 ty->isDependentType(), ty->isDependentType(), 61 ty->isInstantiationDependentType(), 62 ty->containsUnexpandedParameterPack()), 63 GlobalNew(globalNew), Initializer(initializer), 64 UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize), 65 HadMultipleCandidates(HadMultipleCandidates), 66 SubExprs(0), OperatorNew(operatorNew), 67 OperatorDelete(operatorDelete), Constructor(constructor), 68 AllocatedTypeInfo(AllocatedTypeInfo), TypeIdParens(TypeIdParens), 69 StartLoc(startLoc), EndLoc(endLoc), ConstructorLParen(constructorLParen), 70 ConstructorRParen(constructorRParen) { 71 AllocateArgsArray(C, arraySize != 0, numPlaceArgs, numConsArgs); 72 unsigned i = 0; 73 if (Array) { 74 if (arraySize->isInstantiationDependent()) 75 ExprBits.InstantiationDependent = true; 76 77 if (arraySize->containsUnexpandedParameterPack()) 78 ExprBits.ContainsUnexpandedParameterPack = true; 79 80 SubExprs[i++] = arraySize; 81 } 82 83 for (unsigned j = 0; j < NumPlacementArgs; ++j) { 84 if (placementArgs[j]->isInstantiationDependent()) 85 ExprBits.InstantiationDependent = true; 86 if (placementArgs[j]->containsUnexpandedParameterPack()) 87 ExprBits.ContainsUnexpandedParameterPack = true; 88 89 SubExprs[i++] = placementArgs[j]; 90 } 91 92 for (unsigned j = 0; j < NumConstructorArgs; ++j) { 93 if (constructorArgs[j]->isInstantiationDependent()) 94 ExprBits.InstantiationDependent = true; 95 if (constructorArgs[j]->containsUnexpandedParameterPack()) 96 ExprBits.ContainsUnexpandedParameterPack = true; 97 98 SubExprs[i++] = constructorArgs[j]; 99 } 100 } 101 102 void CXXNewExpr::AllocateArgsArray(ASTContext &C, bool isArray, 103 unsigned numPlaceArgs, unsigned numConsArgs){ 104 assert(SubExprs == 0 && "SubExprs already allocated"); 105 Array = isArray; 106 NumPlacementArgs = numPlaceArgs; 107 NumConstructorArgs = numConsArgs; 108 109 unsigned TotalSize = Array + NumPlacementArgs + NumConstructorArgs; 110 SubExprs = new (C) Stmt*[TotalSize]; 111 } 112 113 bool CXXNewExpr::shouldNullCheckAllocation(ASTContext &Ctx) const { 114 return getOperatorNew()->getType()-> 115 castAs<FunctionProtoType>()->isNothrow(Ctx); 116 } 117 118 // CXXDeleteExpr 119 QualType CXXDeleteExpr::getDestroyedType() const { 120 const Expr *Arg = getArgument(); 121 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) { 122 if (ICE->getCastKind() != CK_UserDefinedConversion && 123 ICE->getType()->isVoidPointerType()) 124 Arg = ICE->getSubExpr(); 125 else 126 break; 127 } 128 // The type-to-delete may not be a pointer if it's a dependent type. 129 const QualType ArgType = Arg->getType(); 130 131 if (ArgType->isDependentType() && !ArgType->isPointerType()) 132 return QualType(); 133 134 return ArgType->getAs<PointerType>()->getPointeeType(); 135 } 136 137 // CXXPseudoDestructorExpr 138 PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info) 139 : Type(Info) 140 { 141 Location = Info->getTypeLoc().getLocalSourceRange().getBegin(); 142 } 143 144 CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(ASTContext &Context, 145 Expr *Base, bool isArrow, SourceLocation OperatorLoc, 146 NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType, 147 SourceLocation ColonColonLoc, SourceLocation TildeLoc, 148 PseudoDestructorTypeStorage DestroyedType) 149 : Expr(CXXPseudoDestructorExprClass, 150 Context.getPointerType(Context.getFunctionType(Context.VoidTy, 0, 0, 151 FunctionProtoType::ExtProtoInfo())), 152 VK_RValue, OK_Ordinary, 153 /*isTypeDependent=*/(Base->isTypeDependent() || 154 (DestroyedType.getTypeSourceInfo() && 155 DestroyedType.getTypeSourceInfo()->getType()->isDependentType())), 156 /*isValueDependent=*/Base->isValueDependent(), 157 (Base->isInstantiationDependent() || 158 (QualifierLoc && 159 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) || 160 (ScopeType && 161 ScopeType->getType()->isInstantiationDependentType()) || 162 (DestroyedType.getTypeSourceInfo() && 163 DestroyedType.getTypeSourceInfo()->getType() 164 ->isInstantiationDependentType())), 165 // ContainsUnexpandedParameterPack 166 (Base->containsUnexpandedParameterPack() || 167 (QualifierLoc && 168 QualifierLoc.getNestedNameSpecifier() 169 ->containsUnexpandedParameterPack()) || 170 (ScopeType && 171 ScopeType->getType()->containsUnexpandedParameterPack()) || 172 (DestroyedType.getTypeSourceInfo() && 173 DestroyedType.getTypeSourceInfo()->getType() 174 ->containsUnexpandedParameterPack()))), 175 Base(static_cast<Stmt *>(Base)), IsArrow(isArrow), 176 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 177 ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc), 178 DestroyedType(DestroyedType) { } 179 180 QualType CXXPseudoDestructorExpr::getDestroyedType() const { 181 if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) 182 return TInfo->getType(); 183 184 return QualType(); 185 } 186 187 SourceRange CXXPseudoDestructorExpr::getSourceRange() const { 188 SourceLocation End = DestroyedType.getLocation(); 189 if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo()) 190 End = TInfo->getTypeLoc().getLocalSourceRange().getEnd(); 191 return SourceRange(Base->getLocStart(), End); 192 } 193 194 195 // UnresolvedLookupExpr 196 UnresolvedLookupExpr * 197 UnresolvedLookupExpr::Create(ASTContext &C, 198 CXXRecordDecl *NamingClass, 199 NestedNameSpecifierLoc QualifierLoc, 200 const DeclarationNameInfo &NameInfo, 201 bool ADL, 202 const TemplateArgumentListInfo &Args, 203 UnresolvedSetIterator Begin, 204 UnresolvedSetIterator End) 205 { 206 void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) + 207 ASTTemplateArgumentListInfo::sizeFor(Args)); 208 return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc, NameInfo, 209 ADL, /*Overload*/ true, &Args, 210 Begin, End, /*StdIsAssociated=*/false); 211 } 212 213 UnresolvedLookupExpr * 214 UnresolvedLookupExpr::CreateEmpty(ASTContext &C, bool HasExplicitTemplateArgs, 215 unsigned NumTemplateArgs) { 216 std::size_t size = sizeof(UnresolvedLookupExpr); 217 if (HasExplicitTemplateArgs) 218 size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs); 219 220 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>()); 221 UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell()); 222 E->HasExplicitTemplateArgs = HasExplicitTemplateArgs; 223 return E; 224 } 225 226 OverloadExpr::OverloadExpr(StmtClass K, ASTContext &C, 227 NestedNameSpecifierLoc QualifierLoc, 228 const DeclarationNameInfo &NameInfo, 229 const TemplateArgumentListInfo *TemplateArgs, 230 UnresolvedSetIterator Begin, 231 UnresolvedSetIterator End, 232 bool KnownDependent, 233 bool KnownInstantiationDependent, 234 bool KnownContainsUnexpandedParameterPack) 235 : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent, 236 KnownDependent, 237 (KnownInstantiationDependent || 238 NameInfo.isInstantiationDependent() || 239 (QualifierLoc && 240 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), 241 (KnownContainsUnexpandedParameterPack || 242 NameInfo.containsUnexpandedParameterPack() || 243 (QualifierLoc && 244 QualifierLoc.getNestedNameSpecifier() 245 ->containsUnexpandedParameterPack()))), 246 Results(0), NumResults(End - Begin), NameInfo(NameInfo), 247 QualifierLoc(QualifierLoc), HasExplicitTemplateArgs(TemplateArgs != 0) 248 { 249 NumResults = End - Begin; 250 if (NumResults) { 251 // Determine whether this expression is type-dependent. 252 for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) { 253 if ((*I)->getDeclContext()->isDependentContext() || 254 isa<UnresolvedUsingValueDecl>(*I)) { 255 ExprBits.TypeDependent = true; 256 ExprBits.ValueDependent = true; 257 } 258 } 259 260 Results = static_cast<DeclAccessPair *>( 261 C.Allocate(sizeof(DeclAccessPair) * NumResults, 262 llvm::alignOf<DeclAccessPair>())); 263 memcpy(Results, &*Begin.getIterator(), 264 NumResults * sizeof(DeclAccessPair)); 265 } 266 267 // If we have explicit template arguments, check for dependent 268 // template arguments and whether they contain any unexpanded pack 269 // expansions. 270 if (TemplateArgs) { 271 bool Dependent = false; 272 bool InstantiationDependent = false; 273 bool ContainsUnexpandedParameterPack = false; 274 getExplicitTemplateArgs().initializeFrom(*TemplateArgs, Dependent, 275 InstantiationDependent, 276 ContainsUnexpandedParameterPack); 277 278 if (Dependent) { 279 ExprBits.TypeDependent = true; 280 ExprBits.ValueDependent = true; 281 } 282 if (InstantiationDependent) 283 ExprBits.InstantiationDependent = true; 284 if (ContainsUnexpandedParameterPack) 285 ExprBits.ContainsUnexpandedParameterPack = true; 286 } 287 288 if (isTypeDependent()) 289 setType(C.DependentTy); 290 } 291 292 void OverloadExpr::initializeResults(ASTContext &C, 293 UnresolvedSetIterator Begin, 294 UnresolvedSetIterator End) { 295 assert(Results == 0 && "Results already initialized!"); 296 NumResults = End - Begin; 297 if (NumResults) { 298 Results = static_cast<DeclAccessPair *>( 299 C.Allocate(sizeof(DeclAccessPair) * NumResults, 300 301 llvm::alignOf<DeclAccessPair>())); 302 memcpy(Results, &*Begin.getIterator(), 303 NumResults * sizeof(DeclAccessPair)); 304 } 305 } 306 307 CXXRecordDecl *OverloadExpr::getNamingClass() const { 308 if (isa<UnresolvedLookupExpr>(this)) 309 return cast<UnresolvedLookupExpr>(this)->getNamingClass(); 310 else 311 return cast<UnresolvedMemberExpr>(this)->getNamingClass(); 312 } 313 314 // DependentScopeDeclRefExpr 315 DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T, 316 NestedNameSpecifierLoc QualifierLoc, 317 const DeclarationNameInfo &NameInfo, 318 const TemplateArgumentListInfo *Args) 319 : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary, 320 true, true, 321 (NameInfo.isInstantiationDependent() || 322 (QualifierLoc && 323 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())), 324 (NameInfo.containsUnexpandedParameterPack() || 325 (QualifierLoc && 326 QualifierLoc.getNestedNameSpecifier() 327 ->containsUnexpandedParameterPack()))), 328 QualifierLoc(QualifierLoc), NameInfo(NameInfo), 329 HasExplicitTemplateArgs(Args != 0) 330 { 331 if (Args) { 332 bool Dependent = true; 333 bool InstantiationDependent = true; 334 bool ContainsUnexpandedParameterPack 335 = ExprBits.ContainsUnexpandedParameterPack; 336 337 reinterpret_cast<ASTTemplateArgumentListInfo*>(this+1) 338 ->initializeFrom(*Args, Dependent, InstantiationDependent, 339 ContainsUnexpandedParameterPack); 340 341 ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; 342 } 343 } 344 345 DependentScopeDeclRefExpr * 346 DependentScopeDeclRefExpr::Create(ASTContext &C, 347 NestedNameSpecifierLoc QualifierLoc, 348 const DeclarationNameInfo &NameInfo, 349 const TemplateArgumentListInfo *Args) { 350 std::size_t size = sizeof(DependentScopeDeclRefExpr); 351 if (Args) 352 size += ASTTemplateArgumentListInfo::sizeFor(*Args); 353 void *Mem = C.Allocate(size); 354 return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc, 355 NameInfo, Args); 356 } 357 358 DependentScopeDeclRefExpr * 359 DependentScopeDeclRefExpr::CreateEmpty(ASTContext &C, 360 bool HasExplicitTemplateArgs, 361 unsigned NumTemplateArgs) { 362 std::size_t size = sizeof(DependentScopeDeclRefExpr); 363 if (HasExplicitTemplateArgs) 364 size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs); 365 void *Mem = C.Allocate(size); 366 DependentScopeDeclRefExpr *E 367 = new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(), 368 DeclarationNameInfo(), 0); 369 E->HasExplicitTemplateArgs = HasExplicitTemplateArgs; 370 return E; 371 } 372 373 SourceRange CXXConstructExpr::getSourceRange() const { 374 if (isa<CXXTemporaryObjectExpr>(this)) 375 return cast<CXXTemporaryObjectExpr>(this)->getSourceRange(); 376 377 if (ParenRange.isValid()) 378 return SourceRange(Loc, ParenRange.getEnd()); 379 380 SourceLocation End = Loc; 381 for (unsigned I = getNumArgs(); I > 0; --I) { 382 const Expr *Arg = getArg(I-1); 383 if (!Arg->isDefaultArgument()) { 384 SourceLocation NewEnd = Arg->getLocEnd(); 385 if (NewEnd.isValid()) { 386 End = NewEnd; 387 break; 388 } 389 } 390 } 391 392 return SourceRange(Loc, End); 393 } 394 395 SourceRange CXXOperatorCallExpr::getSourceRange() const { 396 OverloadedOperatorKind Kind = getOperator(); 397 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) { 398 if (getNumArgs() == 1) 399 // Prefix operator 400 return SourceRange(getOperatorLoc(), 401 getArg(0)->getSourceRange().getEnd()); 402 else 403 // Postfix operator 404 return SourceRange(getArg(0)->getSourceRange().getBegin(), 405 getOperatorLoc()); 406 } else if (Kind == OO_Arrow) { 407 return getArg(0)->getSourceRange(); 408 } else if (Kind == OO_Call) { 409 return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc()); 410 } else if (Kind == OO_Subscript) { 411 return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc()); 412 } else if (getNumArgs() == 1) { 413 return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd()); 414 } else if (getNumArgs() == 2) { 415 return SourceRange(getArg(0)->getSourceRange().getBegin(), 416 getArg(1)->getSourceRange().getEnd()); 417 } else { 418 return SourceRange(); 419 } 420 } 421 422 Expr *CXXMemberCallExpr::getImplicitObjectArgument() const { 423 if (const MemberExpr *MemExpr = 424 dyn_cast<MemberExpr>(getCallee()->IgnoreParens())) 425 return MemExpr->getBase(); 426 427 // FIXME: Will eventually need to cope with member pointers. 428 return 0; 429 } 430 431 CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const { 432 if (const MemberExpr *MemExpr = 433 dyn_cast<MemberExpr>(getCallee()->IgnoreParens())) 434 return cast<CXXMethodDecl>(MemExpr->getMemberDecl()); 435 436 // FIXME: Will eventually need to cope with member pointers. 437 return 0; 438 } 439 440 441 CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() { 442 Expr* ThisArg = getImplicitObjectArgument(); 443 if (!ThisArg) 444 return 0; 445 446 if (ThisArg->getType()->isAnyPointerType()) 447 return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl(); 448 449 return ThisArg->getType()->getAsCXXRecordDecl(); 450 } 451 452 453 //===----------------------------------------------------------------------===// 454 // Named casts 455 //===----------------------------------------------------------------------===// 456 457 /// getCastName - Get the name of the C++ cast being used, e.g., 458 /// "static_cast", "dynamic_cast", "reinterpret_cast", or 459 /// "const_cast". The returned pointer must not be freed. 460 const char *CXXNamedCastExpr::getCastName() const { 461 switch (getStmtClass()) { 462 case CXXStaticCastExprClass: return "static_cast"; 463 case CXXDynamicCastExprClass: return "dynamic_cast"; 464 case CXXReinterpretCastExprClass: return "reinterpret_cast"; 465 case CXXConstCastExprClass: return "const_cast"; 466 default: return "<invalid cast>"; 467 } 468 } 469 470 CXXStaticCastExpr *CXXStaticCastExpr::Create(ASTContext &C, QualType T, 471 ExprValueKind VK, 472 CastKind K, Expr *Op, 473 const CXXCastPath *BasePath, 474 TypeSourceInfo *WrittenTy, 475 SourceLocation L, 476 SourceLocation RParenLoc) { 477 unsigned PathSize = (BasePath ? BasePath->size() : 0); 478 void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr) 479 + PathSize * sizeof(CXXBaseSpecifier*)); 480 CXXStaticCastExpr *E = 481 new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 482 RParenLoc); 483 if (PathSize) E->setCastPath(*BasePath); 484 return E; 485 } 486 487 CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext &C, 488 unsigned PathSize) { 489 void *Buffer = 490 C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 491 return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize); 492 } 493 494 CXXDynamicCastExpr *CXXDynamicCastExpr::Create(ASTContext &C, QualType T, 495 ExprValueKind VK, 496 CastKind K, Expr *Op, 497 const CXXCastPath *BasePath, 498 TypeSourceInfo *WrittenTy, 499 SourceLocation L, 500 SourceLocation RParenLoc) { 501 unsigned PathSize = (BasePath ? BasePath->size() : 0); 502 void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr) 503 + PathSize * sizeof(CXXBaseSpecifier*)); 504 CXXDynamicCastExpr *E = 505 new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 506 RParenLoc); 507 if (PathSize) E->setCastPath(*BasePath); 508 return E; 509 } 510 511 CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext &C, 512 unsigned PathSize) { 513 void *Buffer = 514 C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 515 return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize); 516 } 517 518 /// isAlwaysNull - Return whether the result of the dynamic_cast is proven 519 /// to always be null. For example: 520 /// 521 /// struct A { }; 522 /// struct B final : A { }; 523 /// struct C { }; 524 /// 525 /// C *f(B* b) { return dynamic_cast<C*>(b); } 526 bool CXXDynamicCastExpr::isAlwaysNull() const 527 { 528 QualType SrcType = getSubExpr()->getType(); 529 QualType DestType = getType(); 530 531 if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) { 532 SrcType = SrcPTy->getPointeeType(); 533 DestType = DestType->castAs<PointerType>()->getPointeeType(); 534 } 535 536 const CXXRecordDecl *SrcRD = 537 cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl()); 538 539 if (!SrcRD->hasAttr<FinalAttr>()) 540 return false; 541 542 const CXXRecordDecl *DestRD = 543 cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl()); 544 545 return !DestRD->isDerivedFrom(SrcRD); 546 } 547 548 CXXReinterpretCastExpr * 549 CXXReinterpretCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK, 550 CastKind K, Expr *Op, 551 const CXXCastPath *BasePath, 552 TypeSourceInfo *WrittenTy, SourceLocation L, 553 SourceLocation RParenLoc) { 554 unsigned PathSize = (BasePath ? BasePath->size() : 0); 555 void *Buffer = 556 C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 557 CXXReinterpretCastExpr *E = 558 new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, 559 RParenLoc); 560 if (PathSize) E->setCastPath(*BasePath); 561 return E; 562 } 563 564 CXXReinterpretCastExpr * 565 CXXReinterpretCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) { 566 void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr) 567 + PathSize * sizeof(CXXBaseSpecifier*)); 568 return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize); 569 } 570 571 CXXConstCastExpr *CXXConstCastExpr::Create(ASTContext &C, QualType T, 572 ExprValueKind VK, Expr *Op, 573 TypeSourceInfo *WrittenTy, 574 SourceLocation L, 575 SourceLocation RParenLoc) { 576 return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc); 577 } 578 579 CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext &C) { 580 return new (C) CXXConstCastExpr(EmptyShell()); 581 } 582 583 CXXFunctionalCastExpr * 584 CXXFunctionalCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK, 585 TypeSourceInfo *Written, SourceLocation L, 586 CastKind K, Expr *Op, const CXXCastPath *BasePath, 587 SourceLocation R) { 588 unsigned PathSize = (BasePath ? BasePath->size() : 0); 589 void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr) 590 + PathSize * sizeof(CXXBaseSpecifier*)); 591 CXXFunctionalCastExpr *E = 592 new (Buffer) CXXFunctionalCastExpr(T, VK, Written, L, K, Op, PathSize, R); 593 if (PathSize) E->setCastPath(*BasePath); 594 return E; 595 } 596 597 CXXFunctionalCastExpr * 598 CXXFunctionalCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) { 599 void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr) 600 + PathSize * sizeof(CXXBaseSpecifier*)); 601 return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize); 602 } 603 604 605 CXXDefaultArgExpr * 606 CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc, 607 ParmVarDecl *Param, Expr *SubExpr) { 608 void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *)); 609 return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, 610 SubExpr); 611 } 612 613 CXXTemporary *CXXTemporary::Create(ASTContext &C, 614 const CXXDestructorDecl *Destructor) { 615 return new (C) CXXTemporary(Destructor); 616 } 617 618 CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C, 619 CXXTemporary *Temp, 620 Expr* SubExpr) { 621 assert(SubExpr->getType()->isRecordType() && 622 "Expression bound to a temporary must have record type!"); 623 624 return new (C) CXXBindTemporaryExpr(Temp, SubExpr); 625 } 626 627 CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C, 628 CXXConstructorDecl *Cons, 629 TypeSourceInfo *Type, 630 Expr **Args, 631 unsigned NumArgs, 632 SourceRange parenRange, 633 bool HadMultipleCandidates, 634 bool ZeroInitialization) 635 : CXXConstructExpr(C, CXXTemporaryObjectExprClass, 636 Type->getType().getNonReferenceType(), 637 Type->getTypeLoc().getBeginLoc(), 638 Cons, false, Args, NumArgs, 639 HadMultipleCandidates, ZeroInitialization, 640 CXXConstructExpr::CK_Complete, parenRange), 641 Type(Type) { 642 } 643 644 SourceRange CXXTemporaryObjectExpr::getSourceRange() const { 645 return SourceRange(Type->getTypeLoc().getBeginLoc(), 646 getParenRange().getEnd()); 647 } 648 649 CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T, 650 SourceLocation Loc, 651 CXXConstructorDecl *D, bool Elidable, 652 Expr **Args, unsigned NumArgs, 653 bool HadMultipleCandidates, 654 bool ZeroInitialization, 655 ConstructionKind ConstructKind, 656 SourceRange ParenRange) { 657 return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D, 658 Elidable, Args, NumArgs, 659 HadMultipleCandidates, ZeroInitialization, 660 ConstructKind, ParenRange); 661 } 662 663 CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T, 664 SourceLocation Loc, 665 CXXConstructorDecl *D, bool elidable, 666 Expr **args, unsigned numargs, 667 bool HadMultipleCandidates, 668 bool ZeroInitialization, 669 ConstructionKind ConstructKind, 670 SourceRange ParenRange) 671 : Expr(SC, T, VK_RValue, OK_Ordinary, 672 T->isDependentType(), T->isDependentType(), 673 T->isInstantiationDependentType(), 674 T->containsUnexpandedParameterPack()), 675 Constructor(D), Loc(Loc), ParenRange(ParenRange), NumArgs(numargs), 676 Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates), 677 ZeroInitialization(ZeroInitialization), 678 ConstructKind(ConstructKind), Args(0) 679 { 680 if (NumArgs) { 681 Args = new (C) Stmt*[NumArgs]; 682 683 for (unsigned i = 0; i != NumArgs; ++i) { 684 assert(args[i] && "NULL argument in CXXConstructExpr"); 685 686 if (args[i]->isValueDependent()) 687 ExprBits.ValueDependent = true; 688 if (args[i]->isInstantiationDependent()) 689 ExprBits.InstantiationDependent = true; 690 if (args[i]->containsUnexpandedParameterPack()) 691 ExprBits.ContainsUnexpandedParameterPack = true; 692 693 Args[i] = args[i]; 694 } 695 } 696 } 697 698 ExprWithCleanups::ExprWithCleanups(ASTContext &C, 699 Expr *subexpr, 700 CXXTemporary **temps, 701 unsigned numtemps) 702 : Expr(ExprWithCleanupsClass, subexpr->getType(), 703 subexpr->getValueKind(), subexpr->getObjectKind(), 704 subexpr->isTypeDependent(), subexpr->isValueDependent(), 705 subexpr->isInstantiationDependent(), 706 subexpr->containsUnexpandedParameterPack()), 707 SubExpr(subexpr), Temps(0), NumTemps(0) { 708 if (numtemps) { 709 setNumTemporaries(C, numtemps); 710 for (unsigned i = 0; i != numtemps; ++i) 711 Temps[i] = temps[i]; 712 } 713 } 714 715 void ExprWithCleanups::setNumTemporaries(ASTContext &C, unsigned N) { 716 assert(Temps == 0 && "Cannot resize with this"); 717 NumTemps = N; 718 Temps = new (C) CXXTemporary*[NumTemps]; 719 } 720 721 722 ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, 723 Expr *SubExpr, 724 CXXTemporary **Temps, 725 unsigned NumTemps) { 726 return new (C) ExprWithCleanups(C, SubExpr, Temps, NumTemps); 727 } 728 729 CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type, 730 SourceLocation LParenLoc, 731 Expr **Args, 732 unsigned NumArgs, 733 SourceLocation RParenLoc) 734 : Expr(CXXUnresolvedConstructExprClass, 735 Type->getType().getNonReferenceType(), 736 (Type->getType()->isLValueReferenceType() ? VK_LValue 737 :Type->getType()->isRValueReferenceType()? VK_XValue 738 :VK_RValue), 739 OK_Ordinary, 740 Type->getType()->isDependentType(), true, true, 741 Type->getType()->containsUnexpandedParameterPack()), 742 Type(Type), 743 LParenLoc(LParenLoc), 744 RParenLoc(RParenLoc), 745 NumArgs(NumArgs) { 746 Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1); 747 for (unsigned I = 0; I != NumArgs; ++I) { 748 if (Args[I]->containsUnexpandedParameterPack()) 749 ExprBits.ContainsUnexpandedParameterPack = true; 750 751 StoredArgs[I] = Args[I]; 752 } 753 } 754 755 CXXUnresolvedConstructExpr * 756 CXXUnresolvedConstructExpr::Create(ASTContext &C, 757 TypeSourceInfo *Type, 758 SourceLocation LParenLoc, 759 Expr **Args, 760 unsigned NumArgs, 761 SourceLocation RParenLoc) { 762 void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) + 763 sizeof(Expr *) * NumArgs); 764 return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc, 765 Args, NumArgs, RParenLoc); 766 } 767 768 CXXUnresolvedConstructExpr * 769 CXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) { 770 Stmt::EmptyShell Empty; 771 void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) + 772 sizeof(Expr *) * NumArgs); 773 return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs); 774 } 775 776 SourceRange CXXUnresolvedConstructExpr::getSourceRange() const { 777 return SourceRange(Type->getTypeLoc().getBeginLoc(), RParenLoc); 778 } 779 780 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C, 781 Expr *Base, QualType BaseType, 782 bool IsArrow, 783 SourceLocation OperatorLoc, 784 NestedNameSpecifierLoc QualifierLoc, 785 NamedDecl *FirstQualifierFoundInScope, 786 DeclarationNameInfo MemberNameInfo, 787 const TemplateArgumentListInfo *TemplateArgs) 788 : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, 789 VK_LValue, OK_Ordinary, true, true, true, 790 ((Base && Base->containsUnexpandedParameterPack()) || 791 (QualifierLoc && 792 QualifierLoc.getNestedNameSpecifier() 793 ->containsUnexpandedParameterPack()) || 794 MemberNameInfo.containsUnexpandedParameterPack())), 795 Base(Base), BaseType(BaseType), IsArrow(IsArrow), 796 HasExplicitTemplateArgs(TemplateArgs != 0), 797 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc), 798 FirstQualifierFoundInScope(FirstQualifierFoundInScope), 799 MemberNameInfo(MemberNameInfo) { 800 if (TemplateArgs) { 801 bool Dependent = true; 802 bool InstantiationDependent = true; 803 bool ContainsUnexpandedParameterPack = false; 804 getExplicitTemplateArgs().initializeFrom(*TemplateArgs, Dependent, 805 InstantiationDependent, 806 ContainsUnexpandedParameterPack); 807 if (ContainsUnexpandedParameterPack) 808 ExprBits.ContainsUnexpandedParameterPack = true; 809 } 810 } 811 812 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C, 813 Expr *Base, QualType BaseType, 814 bool IsArrow, 815 SourceLocation OperatorLoc, 816 NestedNameSpecifierLoc QualifierLoc, 817 NamedDecl *FirstQualifierFoundInScope, 818 DeclarationNameInfo MemberNameInfo) 819 : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, 820 VK_LValue, OK_Ordinary, true, true, true, 821 ((Base && Base->containsUnexpandedParameterPack()) || 822 (QualifierLoc && 823 QualifierLoc.getNestedNameSpecifier()-> 824 containsUnexpandedParameterPack()) || 825 MemberNameInfo.containsUnexpandedParameterPack())), 826 Base(Base), BaseType(BaseType), IsArrow(IsArrow), 827 HasExplicitTemplateArgs(false), OperatorLoc(OperatorLoc), 828 QualifierLoc(QualifierLoc), 829 FirstQualifierFoundInScope(FirstQualifierFoundInScope), 830 MemberNameInfo(MemberNameInfo) { } 831 832 CXXDependentScopeMemberExpr * 833 CXXDependentScopeMemberExpr::Create(ASTContext &C, 834 Expr *Base, QualType BaseType, bool IsArrow, 835 SourceLocation OperatorLoc, 836 NestedNameSpecifierLoc QualifierLoc, 837 NamedDecl *FirstQualifierFoundInScope, 838 DeclarationNameInfo MemberNameInfo, 839 const TemplateArgumentListInfo *TemplateArgs) { 840 if (!TemplateArgs) 841 return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType, 842 IsArrow, OperatorLoc, 843 QualifierLoc, 844 FirstQualifierFoundInScope, 845 MemberNameInfo); 846 847 std::size_t size = sizeof(CXXDependentScopeMemberExpr); 848 if (TemplateArgs) 849 size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs); 850 851 void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>()); 852 return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType, 853 IsArrow, OperatorLoc, 854 QualifierLoc, 855 FirstQualifierFoundInScope, 856 MemberNameInfo, TemplateArgs); 857 } 858 859 CXXDependentScopeMemberExpr * 860 CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C, 861 bool HasExplicitTemplateArgs, 862 unsigned NumTemplateArgs) { 863 if (!HasExplicitTemplateArgs) 864 return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(), 865 0, SourceLocation(), 866 NestedNameSpecifierLoc(), 0, 867 DeclarationNameInfo()); 868 869 std::size_t size = sizeof(CXXDependentScopeMemberExpr) + 870 ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs); 871 void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>()); 872 CXXDependentScopeMemberExpr *E 873 = new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(), 874 0, SourceLocation(), 875 NestedNameSpecifierLoc(), 0, 876 DeclarationNameInfo(), 0); 877 E->HasExplicitTemplateArgs = true; 878 return E; 879 } 880 881 bool CXXDependentScopeMemberExpr::isImplicitAccess() const { 882 if (Base == 0) 883 return true; 884 885 return cast<Expr>(Base)->isImplicitCXXThis(); 886 } 887 888 static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin, 889 UnresolvedSetIterator end) { 890 do { 891 NamedDecl *decl = *begin; 892 if (isa<UnresolvedUsingValueDecl>(decl)) 893 return false; 894 if (isa<UsingShadowDecl>(decl)) 895 decl = cast<UsingShadowDecl>(decl)->getUnderlyingDecl(); 896 897 // Unresolved member expressions should only contain methods and 898 // method templates. 899 assert(isa<CXXMethodDecl>(decl) || isa<FunctionTemplateDecl>(decl)); 900 901 if (isa<FunctionTemplateDecl>(decl)) 902 decl = cast<FunctionTemplateDecl>(decl)->getTemplatedDecl(); 903 if (cast<CXXMethodDecl>(decl)->isStatic()) 904 return false; 905 } while (++begin != end); 906 907 return true; 908 } 909 910 UnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C, 911 bool HasUnresolvedUsing, 912 Expr *Base, QualType BaseType, 913 bool IsArrow, 914 SourceLocation OperatorLoc, 915 NestedNameSpecifierLoc QualifierLoc, 916 const DeclarationNameInfo &MemberNameInfo, 917 const TemplateArgumentListInfo *TemplateArgs, 918 UnresolvedSetIterator Begin, 919 UnresolvedSetIterator End) 920 : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, MemberNameInfo, 921 TemplateArgs, Begin, End, 922 // Dependent 923 ((Base && Base->isTypeDependent()) || 924 BaseType->isDependentType()), 925 ((Base && Base->isInstantiationDependent()) || 926 BaseType->isInstantiationDependentType()), 927 // Contains unexpanded parameter pack 928 ((Base && Base->containsUnexpandedParameterPack()) || 929 BaseType->containsUnexpandedParameterPack())), 930 IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing), 931 Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) { 932 933 // Check whether all of the members are non-static member functions, 934 // and if so, mark give this bound-member type instead of overload type. 935 if (hasOnlyNonStaticMemberFunctions(Begin, End)) 936 setType(C.BoundMemberTy); 937 } 938 939 bool UnresolvedMemberExpr::isImplicitAccess() const { 940 if (Base == 0) 941 return true; 942 943 return cast<Expr>(Base)->isImplicitCXXThis(); 944 } 945 946 UnresolvedMemberExpr * 947 UnresolvedMemberExpr::Create(ASTContext &C, 948 bool HasUnresolvedUsing, 949 Expr *Base, QualType BaseType, bool IsArrow, 950 SourceLocation OperatorLoc, 951 NestedNameSpecifierLoc QualifierLoc, 952 const DeclarationNameInfo &MemberNameInfo, 953 const TemplateArgumentListInfo *TemplateArgs, 954 UnresolvedSetIterator Begin, 955 UnresolvedSetIterator End) { 956 std::size_t size = sizeof(UnresolvedMemberExpr); 957 if (TemplateArgs) 958 size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs); 959 960 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>()); 961 return new (Mem) UnresolvedMemberExpr(C, 962 HasUnresolvedUsing, Base, BaseType, 963 IsArrow, OperatorLoc, QualifierLoc, 964 MemberNameInfo, TemplateArgs, Begin, End); 965 } 966 967 UnresolvedMemberExpr * 968 UnresolvedMemberExpr::CreateEmpty(ASTContext &C, bool HasExplicitTemplateArgs, 969 unsigned NumTemplateArgs) { 970 std::size_t size = sizeof(UnresolvedMemberExpr); 971 if (HasExplicitTemplateArgs) 972 size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs); 973 974 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>()); 975 UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell()); 976 E->HasExplicitTemplateArgs = HasExplicitTemplateArgs; 977 return E; 978 } 979 980 CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const { 981 // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this. 982 983 // If there was a nested name specifier, it names the naming class. 984 // It can't be dependent: after all, we were actually able to do the 985 // lookup. 986 CXXRecordDecl *Record = 0; 987 if (getQualifier()) { 988 const Type *T = getQualifier()->getAsType(); 989 assert(T && "qualifier in member expression does not name type"); 990 Record = T->getAsCXXRecordDecl(); 991 assert(Record && "qualifier in member expression does not name record"); 992 } 993 // Otherwise the naming class must have been the base class. 994 else { 995 QualType BaseType = getBaseType().getNonReferenceType(); 996 if (isArrow()) { 997 const PointerType *PT = BaseType->getAs<PointerType>(); 998 assert(PT && "base of arrow member access is not pointer"); 999 BaseType = PT->getPointeeType(); 1000 } 1001 1002 Record = BaseType->getAsCXXRecordDecl(); 1003 assert(Record && "base of member expression does not name record"); 1004 } 1005 1006 return Record; 1007 } 1008 1009 SubstNonTypeTemplateParmPackExpr:: 1010 SubstNonTypeTemplateParmPackExpr(QualType T, 1011 NonTypeTemplateParmDecl *Param, 1012 SourceLocation NameLoc, 1013 const TemplateArgument &ArgPack) 1014 : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary, 1015 true, true, true, true), 1016 Param(Param), Arguments(ArgPack.pack_begin()), 1017 NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { } 1018 1019 TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const { 1020 return TemplateArgument(Arguments, NumArguments); 1021 } 1022 1023 1024
