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