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