contrib/llvm/tools/clang/lib/AST/ExprCXX.cpp

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