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