//===- ExprCXX.cpp - (C++) Expression AST Node Implementation -------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file implements the subclesses of Expr class declared in ExprCXX.h

//

//===----------------------------------------------------------------------===//

#include "clang/AST/ExprCXX.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/Attr.h"

#include "clang/AST/ComputeDependence.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclAccessPair.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/DependenceFlags.h"

#include "clang/AST/Expr.h"

#include "clang/AST/LambdaCapture.h"

#include "clang/AST/NestedNameSpecifier.h"

#include "clang/AST/TemplateBase.h"

#include "clang/AST/Type.h"

#include "clang/AST/TypeLoc.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/OperatorKinds.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/ErrorHandling.h"

#include <cassert>

#include <cstddef>

#include <cstring>

#include <memory>

using namespace clang;

//===----------------------------------------------------------------------===//

//  Child Iterators for iterating over subexpressions/substatements

//===----------------------------------------------------------------------===//

bool CXXOperatorCallExpr::isInfixBinaryOp() const {

  // An infix binary operator is any operator with two arguments other than

  // operator() and operator[]. Note that none of these operators can have

  // default arguments, so it suffices to check the number of argument

  // expressions.

  if (getNumArgs() != 2)

    return false;

  switch (getOperator()) {

  
case OO_Call: 3
case OO_Subscript:

    return false;

  default:

    return true;

  }

}

CXXRewrittenBinaryOperator::DecomposedForm

CXXRewrittenBinaryOperator::getDecomposedForm() const {

  DecomposedForm Result = {};

  const Expr *E = getSemanticForm()->IgnoreImplicit();

  // Remove an outer '!' if it exists (only happens for a '!=' rewrite).

  bool SkippedNot = false;

  if (auto *NotEq = dyn_cast<UnaryOperator>(E)) {

    assert(NotEq->getOpcode() == UO_LNot);

    E = NotEq->getSubExpr()->IgnoreImplicit();

    SkippedNot = true;

  }

  // Decompose the outer binary operator.

  if (auto *BO = dyn_cast<BinaryOperator>(E)) {

    assert(!SkippedNot || BO->getOpcode() == BO_EQ);

    Result.Opcode = SkippedNot ? 
BO_NE0
 : BO->getOpcode();

    Result.LHS = BO->getLHS();

    Result.RHS = BO->getRHS();

    Result.InnerBinOp = BO;

  } else 
if (auto *1.12k
BO1.12k
 = dyn_cast<CXXOperatorCallExpr>(E)) {

    assert(!SkippedNot || BO->getOperator() == OO_EqualEqual);

    assert(BO->isInfixBinaryOp());

    switch (BO->getOperator()) {

    case OO_Less: Result.Opcode = BO_LT; break;

    case OO_LessEqual: Result.Opcode = BO_LE; break;

    case OO_Greater: Result.Opcode = BO_GT; break;

    case OO_GreaterEqual: Result.Opcode = BO_GE; break;

    case OO_Spaceship: Result.Opcode = BO_Cmp; break;

    case OO_EqualEqual: Result.Opcode = SkippedNot ? 
BO_NE771
 : 
BO_EQ59
; break;

    default: llvm_unreachable("unexpected binop in rewritten operator expr");

    }

    Result.LHS = BO->getArg(0);

    Result.RHS = BO->getArg(1);

    Result.InnerBinOp = BO;

  } else {

    llvm_unreachable("unexpected rewritten operator form");

  }

  // Put the operands in the right order for == and !=, and canonicalize the

  // <=> subexpression onto the LHS for all other forms.

  if (isReversed())

    std::swap(Result.LHS, Result.RHS);

  // If this isn't a spaceship rewrite, we're done.

  if (Result.Opcode == BO_EQ || 
Result.Opcode == BO_NE2.29k
)

    return Result;

  // Otherwise, we expect a <=> to now be on the LHS.

  E = Result.LHS->IgnoreImplicitAsWritten();

  if (auto *BO = dyn_cast<BinaryOperator>(E)) {

    assert(BO->getOpcode() == BO_Cmp);

    Result.LHS = BO->getLHS();

    Result.RHS = BO->getRHS();

    Result.InnerBinOp = BO;

  } else if (auto *BO = dyn_cast<CXXOperatorCallExpr>(E)) {

    assert(BO->getOperator() == OO_Spaceship);

    Result.LHS = BO->getArg(0);

    Result.RHS = BO->getArg(1);

    Result.InnerBinOp = BO;

  } else {

    llvm_unreachable("unexpected rewritten operator form");

  }

  // Put the comparison operands in the right order.

  if (isReversed())

    std::swap(Result.LHS, Result.RHS);

  return Result;

}

bool CXXTypeidExpr::isPotentiallyEvaluated() const {

  if (isTypeOperand())

    return false;

  // C++11 [expr.typeid]p3:

  //   When typeid is applied to an expression other than a glvalue of

  //   polymorphic class type, [...] the expression is an unevaluated operand.

  const Expr *E = getExprOperand();

  if (const CXXRecordDecl *RD = E->getType()->getAsCXXRecordDecl())

    if (RD->isPolymorphic() && 
E->isGLValue()245
)

      return true;

  return false;

}

bool CXXTypeidExpr::isMostDerived(ASTContext &Context) const {

  assert(!isTypeOperand() && "Cannot call isMostDerived for typeid(type)");

  const Expr *E = getExprOperand()->IgnoreParenNoopCasts(Context);

  if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {

    QualType Ty = DRE->getDecl()->getType();

    if (!Ty->isPointerType() && !Ty->isReferenceType())

      return true;

  }

  return false;

}

QualType CXXTypeidExpr::getTypeOperand(ASTContext &Context) const {

  assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");

  Qualifiers Quals;

  return Context.getUnqualifiedArrayType(

      Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType(), Quals);

}

QualType CXXUuidofExpr::getTypeOperand(ASTContext &Context) const {

  assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)");

  Qualifiers Quals;

  return Context.getUnqualifiedArrayType(

      Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType(), Quals);

}

// CXXScalarValueInitExpr

SourceLocation CXXScalarValueInitExpr::getBeginLoc() const {

  return TypeInfo ? 
TypeInfo->getTypeLoc().getBeginLoc()42.7k
 : 
getRParenLoc()275
;

}

// CXXNewExpr

CXXNewExpr::CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew,

                       FunctionDecl *OperatorDelete, bool ShouldPassAlignment,

                       bool UsualArrayDeleteWantsSize,

                       ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens,

                       Optional<Expr *> ArraySize,

                       InitializationStyle InitializationStyle,

                       Expr *Initializer, QualType Ty,

                       TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,

                       SourceRange DirectInitRange)

    : Expr(CXXNewExprClass, Ty, VK_PRValue, OK_Ordinary),

      OperatorNew(OperatorNew), OperatorDelete(OperatorDelete),

      AllocatedTypeInfo(AllocatedTypeInfo), Range(Range),

      DirectInitRange(DirectInitRange) {

  assert((Initializer != nullptr || InitializationStyle == NoInit) &&

         "Only NoInit can have no initializer!");

  CXXNewExprBits.IsGlobalNew = IsGlobalNew;

  CXXNewExprBits.IsArray = ArraySize.hasValue();

  CXXNewExprBits.ShouldPassAlignment = ShouldPassAlignment;

  CXXNewExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;

  CXXNewExprBits.StoredInitializationStyle =

      Initializer ? 
InitializationStyle + 120.0k
 : 
03.25k
;

  bool IsParenTypeId = TypeIdParens.isValid();

  CXXNewExprBits.IsParenTypeId = IsParenTypeId;

  CXXNewExprBits.NumPlacementArgs = PlacementArgs.size();

  if (ArraySize)

    getTrailingObjects<Stmt *>()[arraySizeOffset()] = *ArraySize;

  if (Initializer)

    getTrailingObjects<Stmt *>()[initExprOffset()] = Initializer;

  for (unsigned I = 0; I != PlacementArgs.size(); 
++I12.5k
)

    getTrailingObjects<Stmt *>()[placementNewArgsOffset() + I] =

        PlacementArgs[I];

  if (IsParenTypeId)

    getTrailingObjects<SourceRange>()[0] = TypeIdParens;

  switch (getInitializationStyle()) {

  case CallInit:

    this->Range.setEnd(DirectInitRange.getEnd());

    break;

  case ListInit:

    this->Range.setEnd(getInitializer()->getSourceRange().getEnd());

    break;

  default:

    if (IsParenTypeId)

      this->Range.setEnd(TypeIdParens.getEnd());

    break;

  }

  setDependence(computeDependence(this));

}

CXXNewExpr::CXXNewExpr(EmptyShell Empty, bool IsArray,

                       unsigned NumPlacementArgs, bool IsParenTypeId)

    : Expr(CXXNewExprClass, Empty) {

  CXXNewExprBits.IsArray = IsArray;

  CXXNewExprBits.NumPlacementArgs = NumPlacementArgs;

  CXXNewExprBits.IsParenTypeId = IsParenTypeId;

}

CXXNewExpr *

CXXNewExpr::Create(const ASTContext &Ctx, bool IsGlobalNew,

                   FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete,

                   bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize,

                   ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens,

                   Optional<Expr *> ArraySize,

                   InitializationStyle InitializationStyle, Expr *Initializer,

                   QualType Ty, TypeSourceInfo *AllocatedTypeInfo,

                   SourceRange Range, SourceRange DirectInitRange) {

  bool IsArray = ArraySize.hasValue();

  bool HasInit = Initializer != nullptr;

  unsigned NumPlacementArgs = PlacementArgs.size();

  bool IsParenTypeId = TypeIdParens.isValid();

  void *Mem =

      Ctx.Allocate(totalSizeToAlloc<Stmt *, SourceRange>(

                       IsArray + HasInit + NumPlacementArgs, IsParenTypeId),

                   alignof(CXXNewExpr));

  return new (Mem)

      CXXNewExpr(IsGlobalNew, OperatorNew, OperatorDelete, ShouldPassAlignment,

                 UsualArrayDeleteWantsSize, PlacementArgs, TypeIdParens,

                 ArraySize, InitializationStyle, Initializer, Ty,

                 AllocatedTypeInfo, Range, DirectInitRange);

}

CXXNewExpr *CXXNewExpr::CreateEmpty(const ASTContext &Ctx, bool IsArray,

                                    bool HasInit, unsigned NumPlacementArgs,

                                    bool IsParenTypeId) {

  void *Mem =

      Ctx.Allocate(totalSizeToAlloc<Stmt *, SourceRange>(

                       IsArray + HasInit + NumPlacementArgs, IsParenTypeId),

                   alignof(CXXNewExpr));

  return new (Mem)

      CXXNewExpr(EmptyShell(), IsArray, NumPlacementArgs, IsParenTypeId);

}

bool CXXNewExpr::shouldNullCheckAllocation() const {

  return !getOperatorNew()->hasAttr<ReturnsNonNullAttr>() &&

         getOperatorNew()

             ->getType()

             ->castAs<FunctionProtoType>()

             ->isNothrow() &&

         
!getOperatorNew()->isReservedGlobalPlacementOperator()653
;

}

// CXXDeleteExpr

QualType CXXDeleteExpr::getDestroyedType() const {

  const Expr *Arg = getArgument();

  // For a destroying operator delete, we may have implicitly converted the

  // pointer type to the type of the parameter of the 'operator delete'

  // function.

  while (const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {

    if (ICE->getCastKind() == CK_DerivedToBase ||

        
ICE->getCastKind() == CK_UncheckedDerivedToBase1.98k
 ||

        
ICE->getCastKind() == CK_NoOp1.98k
) {

      assert((ICE->getCastKind() == CK_NoOp ||

              getOperatorDelete()->isDestroyingOperatorDelete()) &&

             "only a destroying operator delete can have a converted arg");

      Arg = ICE->getSubExpr();

    } else

      break;

  }

  // The type-to-delete may not be a pointer if it's a dependent type.

  const QualType ArgType = Arg->getType();

  if (ArgType->isDependentType() && 
!ArgType->isPointerType()3
)

    return QualType();

  return ArgType->castAs<PointerType>()->getPointeeType();

}

// CXXPseudoDestructorExpr

PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)

    : Type(Info) {

  Location = Info->getTypeLoc().getLocalSourceRange().getBegin();

}

CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(

    const ASTContext &Context, Expr *Base, bool isArrow,

    SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,

    TypeSourceInfo *ScopeType, SourceLocation ColonColonLoc,

    SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)

    : Expr(CXXPseudoDestructorExprClass, Context.BoundMemberTy, VK_PRValue,

           OK_Ordinary),

      Base(static_cast<Stmt *>(Base)), IsArrow(isArrow),

      OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),

      ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),

      DestroyedType(DestroyedType) {

  setDependence(computeDependence(this));

}

QualType CXXPseudoDestructorExpr::getDestroyedType() const {

  if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())

    return TInfo->getType();

  return QualType();

}

SourceLocation CXXPseudoDestructorExpr::getEndLoc() const {

  SourceLocation End = DestroyedType.getLocation();

  if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())

    End = TInfo->getTypeLoc().getLocalSourceRange().getEnd();

  return End;

}

// UnresolvedLookupExpr

UnresolvedLookupExpr::UnresolvedLookupExpr(

    const ASTContext &Context, CXXRecordDecl *NamingClass,

    NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,

    const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded,

    const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin,

    UnresolvedSetIterator End)

    : OverloadExpr(UnresolvedLookupExprClass, Context, QualifierLoc,

                   TemplateKWLoc, NameInfo, TemplateArgs, Begin, End, false,

                   false, false),

      NamingClass(NamingClass) {

  UnresolvedLookupExprBits.RequiresADL = RequiresADL;

  UnresolvedLookupExprBits.Overloaded = Overloaded;

}

UnresolvedLookupExpr::UnresolvedLookupExpr(EmptyShell Empty,

                                           unsigned NumResults,

                                           bool HasTemplateKWAndArgsInfo)

    : OverloadExpr(UnresolvedLookupExprClass, Empty, NumResults,

                   HasTemplateKWAndArgsInfo) {}

UnresolvedLookupExpr *UnresolvedLookupExpr::Create(

    const ASTContext &Context, CXXRecordDecl *NamingClass,

    NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,

    bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin,

    UnresolvedSetIterator End) {

  unsigned NumResults = End - Begin;

  unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo,

                                   TemplateArgumentLoc>(NumResults, 0, 0);

  void *Mem = Context.Allocate(Size, alignof(UnresolvedLookupExpr));

  return new (Mem) UnresolvedLookupExpr(Context, NamingClass, QualifierLoc,

                                        SourceLocation(), NameInfo, RequiresADL,

                                        Overloaded, nullptr, Begin, End);

}

UnresolvedLookupExpr *UnresolvedLookupExpr::Create(

    const ASTContext &Context, CXXRecordDecl *NamingClass,

    NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,

    const DeclarationNameInfo &NameInfo, bool RequiresADL,

    const TemplateArgumentListInfo *Args, UnresolvedSetIterator Begin,

    UnresolvedSetIterator End) {

  assert(Args || TemplateKWLoc.isValid());

  unsigned NumResults = End - Begin;

  unsigned NumTemplateArgs = Args ? 
Args->size()402k
 : 
014
;

  unsigned Size =

      totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo,

                       TemplateArgumentLoc>(NumResults, 1, NumTemplateArgs);

  void *Mem = Context.Allocate(Size, alignof(UnresolvedLookupExpr));

  return new (Mem) UnresolvedLookupExpr(Context, NamingClass, QualifierLoc,

                                        TemplateKWLoc, NameInfo, RequiresADL,

                                        /*Overloaded*/ true, Args, Begin, End);

}

UnresolvedLookupExpr *UnresolvedLookupExpr::CreateEmpty(

    const ASTContext &Context, unsigned NumResults,

    bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs) {

  assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);

  unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo,

                                   TemplateArgumentLoc>(

      NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);

  void *Mem = Context.Allocate(Size, alignof(UnresolvedLookupExpr));

  return new (Mem)

      UnresolvedLookupExpr(EmptyShell(), NumResults, HasTemplateKWAndArgsInfo);

}

OverloadExpr::OverloadExpr(StmtClass SC, const ASTContext &Context,

                           NestedNameSpecifierLoc QualifierLoc,

                           SourceLocation TemplateKWLoc,

                           const DeclarationNameInfo &NameInfo,

                           const TemplateArgumentListInfo *TemplateArgs,

                           UnresolvedSetIterator Begin,

                           UnresolvedSetIterator End, bool KnownDependent,

                           bool KnownInstantiationDependent,

                           bool KnownContainsUnexpandedParameterPack)

    : Expr(SC, Context.OverloadTy, VK_LValue, OK_Ordinary), NameInfo(NameInfo),

      QualifierLoc(QualifierLoc) {

  unsigned NumResults = End - Begin;

  OverloadExprBits.NumResults = NumResults;

  OverloadExprBits.HasTemplateKWAndArgsInfo =

      (TemplateArgs != nullptr ) || 
TemplateKWLoc.isValid()2.74M
;

  if (NumResults) {

    // Copy the results to the trailing array past UnresolvedLookupExpr

    // or UnresolvedMemberExpr.

    DeclAccessPair *Results = getTrailingResults();

    memcpy(Results, Begin.I, NumResults * sizeof(DeclAccessPair));

  }

  if (TemplateArgs) {

    auto Deps = TemplateArgumentDependence::None;

    getTrailingASTTemplateKWAndArgsInfo()->initializeFrom(

        TemplateKWLoc, *TemplateArgs, getTrailingTemplateArgumentLoc(), Deps);

  } else if (TemplateKWLoc.isValid()) {

    getTrailingASTTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);

  }

  setDependence(computeDependence(this, KnownDependent,

                                  KnownInstantiationDependent,

                                  KnownContainsUnexpandedParameterPack));

  if (isTypeDependent())

    setType(Context.DependentTy);

}

OverloadExpr::OverloadExpr(StmtClass SC, EmptyShell Empty, unsigned NumResults,

                           bool HasTemplateKWAndArgsInfo)

    : Expr(SC, Empty) {

  OverloadExprBits.NumResults = NumResults;

  OverloadExprBits.HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;

}

// DependentScopeDeclRefExpr

DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(

    QualType Ty, NestedNameSpecifierLoc QualifierLoc,

    SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo,

    const TemplateArgumentListInfo *Args)

    : Expr(DependentScopeDeclRefExprClass, Ty, VK_LValue, OK_Ordinary),

      QualifierLoc(QualifierLoc), NameInfo(NameInfo) {

  DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo =

      (Args != nullptr) || 
TemplateKWLoc.isValid()1.83M
;

  if (Args) {

    auto Deps = TemplateArgumentDependence::None;

    getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

        TemplateKWLoc, *Args, getTrailingObjects<TemplateArgumentLoc>(), Deps);

  } else if (TemplateKWLoc.isValid()) {

    getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

        TemplateKWLoc);

  }

  setDependence(computeDependence(this));

}

DependentScopeDeclRefExpr *DependentScopeDeclRefExpr::Create(

    const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,

    SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo,

    const TemplateArgumentListInfo *Args) {

  assert(QualifierLoc && "should be created for dependent qualifiers");

  bool HasTemplateKWAndArgsInfo = Args || 
TemplateKWLoc.isValid()1.18M
;

  std::size_t Size =

      totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(

          HasTemplateKWAndArgsInfo, Args ? 
Args->size()22.9k
 : 
01.18M
);

  void *Mem = Context.Allocate(Size);

  return new (Mem) DependentScopeDeclRefExpr(Context.DependentTy, QualifierLoc,

                                             TemplateKWLoc, NameInfo, Args);

}

DependentScopeDeclRefExpr *

DependentScopeDeclRefExpr::CreateEmpty(const ASTContext &Context,

                                       bool HasTemplateKWAndArgsInfo,

                                       unsigned NumTemplateArgs) {

  assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);

  std::size_t Size =

      totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(

          HasTemplateKWAndArgsInfo, NumTemplateArgs);

  void *Mem = Context.Allocate(Size);

  auto *E = new (Mem) DependentScopeDeclRefExpr(

      QualType(), NestedNameSpecifierLoc(), SourceLocation(),

      DeclarationNameInfo(), nullptr);

  E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo =

      HasTemplateKWAndArgsInfo;

  return E;

}

SourceLocation CXXConstructExpr::getBeginLoc() const {

  if (isa<CXXTemporaryObjectExpr>(this))

    return cast<CXXTemporaryObjectExpr>(this)->getBeginLoc();

  return getLocation();

}

SourceLocation CXXConstructExpr::getEndLoc() const {

  if (isa<CXXTemporaryObjectExpr>(this))

    return cast<CXXTemporaryObjectExpr>(this)->getEndLoc();

  if (ParenOrBraceRange.isValid())

    return ParenOrBraceRange.getEnd();

  SourceLocation End = getLocation();

  for (unsigned I = getNumArgs(); I > 0; 
--I7.62k
) {

    const Expr *Arg = getArg(I-1);

    if (!Arg->isDefaultArgument()) {

      SourceLocation NewEnd = Arg->getEndLoc();

      if (NewEnd.isValid()) {

        End = NewEnd;

        break;

      }

    }

  }

  return End;

}

CXXOperatorCallExpr::CXXOperatorCallExpr(OverloadedOperatorKind OpKind,

                                         Expr *Fn, ArrayRef<Expr *> Args,

                                         QualType Ty, ExprValueKind VK,

                                         SourceLocation OperatorLoc,

                                         FPOptionsOverride FPFeatures,

                                         ADLCallKind UsesADL)

    : CallExpr(CXXOperatorCallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK,

               OperatorLoc, FPFeatures, /*MinNumArgs=*/0, UsesADL) {

  CXXOperatorCallExprBits.OperatorKind = OpKind;

  assert(

      (CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) &&

      "OperatorKind overflow!");

  Range = getSourceRangeImpl();

}

CXXOperatorCallExpr::CXXOperatorCallExpr(unsigned NumArgs, bool HasFPFeatures,

                                         EmptyShell Empty)

    : CallExpr(CXXOperatorCallExprClass, /*NumPreArgs=*/0, NumArgs,

               HasFPFeatures, Empty) {}

CXXOperatorCallExpr *

CXXOperatorCallExpr::Create(const ASTContext &Ctx,

                            OverloadedOperatorKind OpKind, Expr *Fn,

                            ArrayRef<Expr *> Args, QualType Ty,

                            ExprValueKind VK, SourceLocation OperatorLoc,

                            FPOptionsOverride FPFeatures, ADLCallKind UsesADL) {

  // Allocate storage for the trailing objects of CallExpr.

  unsigned NumArgs = Args.size();

  unsigned SizeOfTrailingObjects = CallExpr::sizeOfTrailingObjects(

      /*NumPreArgs=*/0, NumArgs, FPFeatures.requiresTrailingStorage());

  void *Mem = Ctx.Allocate(sizeof(CXXOperatorCallExpr) + SizeOfTrailingObjects,

                           alignof(CXXOperatorCallExpr));

  return new (Mem) CXXOperatorCallExpr(OpKind, Fn, Args, Ty, VK, OperatorLoc,

                                       FPFeatures, UsesADL);

}

CXXOperatorCallExpr *CXXOperatorCallExpr::CreateEmpty(const ASTContext &Ctx,

                                                      unsigned NumArgs,

                                                      bool HasFPFeatures,

                                                      EmptyShell Empty) {

  // Allocate storage for the trailing objects of CallExpr.

  unsigned SizeOfTrailingObjects =

      CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs, HasFPFeatures);

  void *Mem = Ctx.Allocate(sizeof(CXXOperatorCallExpr) + SizeOfTrailingObjects,

                           alignof(CXXOperatorCallExpr));

  return new (Mem) CXXOperatorCallExpr(NumArgs, HasFPFeatures, Empty);

}

SourceRange CXXOperatorCallExpr::getSourceRangeImpl() const {

  OverloadedOperatorKind Kind = getOperator();

  if (Kind == OO_PlusPlus || 
Kind == OO_MinusMinus1.05M
) {

    if (getNumArgs() == 1)

      // Prefix operator

      return SourceRange(getOperatorLoc(), getArg(0)->getEndLoc());

    else

      // Postfix operator

      return SourceRange(getArg(0)->getBeginLoc(), getOperatorLoc());

  } else if (Kind == OO_Arrow) {

    return SourceRange(getArg(0)->getBeginLoc(), getOperatorLoc());

  } else if (Kind == OO_Call) {

    return SourceRange(getArg(0)->getBeginLoc(), getRParenLoc());

  } else if (Kind == OO_Subscript) {

    return SourceRange(getArg(0)->getBeginLoc(), getRParenLoc());

  } else if (getNumArgs() == 1) {

    return SourceRange(getOperatorLoc(), getArg(0)->getEndLoc());

  } else if (getNumArgs() == 2) {

    return SourceRange(getArg(0)->getBeginLoc(), getArg(1)->getEndLoc());

  } else {

    return getOperatorLoc();

  }

}

CXXMemberCallExpr::CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args,

                                     QualType Ty, ExprValueKind VK,

                                     SourceLocation RP,

                                     FPOptionsOverride FPOptions,

                                     unsigned MinNumArgs)

    : CallExpr(CXXMemberCallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK, RP,

               FPOptions, MinNumArgs, NotADL) {}

CXXMemberCallExpr::CXXMemberCallExpr(unsigned NumArgs, bool HasFPFeatures,

                                     EmptyShell Empty)

    : CallExpr(CXXMemberCallExprClass, /*NumPreArgs=*/0, NumArgs, HasFPFeatures,

               Empty) {}

CXXMemberCallExpr *CXXMemberCallExpr::Create(const ASTContext &Ctx, Expr *Fn,

                                             ArrayRef<Expr *> Args, QualType Ty,

                                             ExprValueKind VK,

                                             SourceLocation RP,

                                             FPOptionsOverride FPFeatures,

                                             unsigned MinNumArgs) {

  // Allocate storage for the trailing objects of CallExpr.

  unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);

  unsigned SizeOfTrailingObjects = CallExpr::sizeOfTrailingObjects(

      /*NumPreArgs=*/0, NumArgs, FPFeatures.requiresTrailingStorage());

  void *Mem = Ctx.Allocate(sizeof(CXXMemberCallExpr) + SizeOfTrailingObjects,

                           alignof(CXXMemberCallExpr));

  return new (Mem)

      CXXMemberCallExpr(Fn, Args, Ty, VK, RP, FPFeatures, MinNumArgs);

}

CXXMemberCallExpr *CXXMemberCallExpr::CreateEmpty(const ASTContext &Ctx,

                                                  unsigned NumArgs,

                                                  bool HasFPFeatures,

                                                  EmptyShell Empty) {

  // Allocate storage for the trailing objects of CallExpr.

  unsigned SizeOfTrailingObjects =

      CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs, HasFPFeatures);

  void *Mem = Ctx.Allocate(sizeof(CXXMemberCallExpr) + SizeOfTrailingObjects,

                           alignof(CXXMemberCallExpr));

  return new (Mem) CXXMemberCallExpr(NumArgs, HasFPFeatures, Empty);

}

Expr *CXXMemberCallExpr::getImplicitObjectArgument() const {

  const Expr *Callee = getCallee()->IgnoreParens();

  if (const auto *MemExpr = dyn_cast<MemberExpr>(Callee))

    return MemExpr->getBase();

  if (const auto *BO = dyn_cast<BinaryOperator>(Callee))

    if (BO->getOpcode() == BO_PtrMemD || 
BO->getOpcode() == BO_PtrMemI52
)

      return BO->getLHS();

  // FIXME: Will eventually need to cope with member pointers.

  return nullptr;

}

QualType CXXMemberCallExpr::getObjectType() const {

  QualType Ty = getImplicitObjectArgument()->getType();

  if (Ty->isPointerType())

    Ty = Ty->getPointeeType();

  return Ty;

}

CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const {

  if (const auto *MemExpr = dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))

    return cast<CXXMethodDecl>(MemExpr->getMemberDecl());

  // FIXME: Will eventually need to cope with member pointers.

  // NOTE: Update makeTailCallIfSwiftAsync on fixing this.

  return nullptr;

}

CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() const {

  Expr* ThisArg = getImplicitObjectArgument();

  if (!ThisArg)

    return nullptr;

  if (ThisArg->getType()->isAnyPointerType())

    return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl();

  return ThisArg->getType()->getAsCXXRecordDecl();

}

//===----------------------------------------------------------------------===//

//  Named casts

//===----------------------------------------------------------------------===//

/// getCastName - Get the name of the C++ cast being used, e.g.,

/// "static_cast", "dynamic_cast", "reinterpret_cast", or

/// "const_cast". The returned pointer must not be freed.

const char *CXXNamedCastExpr::getCastName() const {

  switch (getStmtClass()) {

  case CXXStaticCastExprClass:      return "static_cast";

  case CXXDynamicCastExprClass:     return "dynamic_cast";

  case CXXReinterpretCastExprClass: return "reinterpret_cast";

  case CXXConstCastExprClass:       return "const_cast";

  case CXXAddrspaceCastExprClass:   return "addrspace_cast";

  default:                          return "<invalid cast>";

  }

}

CXXStaticCastExpr *

CXXStaticCastExpr::Create(const ASTContext &C, QualType T, ExprValueKind VK,

                          CastKind K, Expr *Op, const CXXCastPath *BasePath,

                          TypeSourceInfo *WrittenTy, FPOptionsOverride FPO,

                          SourceLocation L, SourceLocation RParenLoc,

                          SourceRange AngleBrackets) {

  unsigned PathSize = (BasePath ? 
BasePath->size()282k
 : 
0118
);

  void *Buffer =

      C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

          PathSize, FPO.requiresTrailingStorage()));

  auto *E = new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy,

                                           FPO, L, RParenLoc, AngleBrackets);

  if (PathSize)

    std::uninitialized_copy_n(BasePath->data(), BasePath->size(),

                              E->getTrailingObjects<CXXBaseSpecifier *>());

  return E;

}

CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(const ASTContext &C,

                                                  unsigned PathSize,

                                                  bool HasFPFeatures) {

  void *Buffer =

      C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

          PathSize, HasFPFeatures));

  return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize, HasFPFeatures);

}

CXXDynamicCastExpr *CXXDynamicCastExpr::Create(const ASTContext &C, QualType T,

                                               ExprValueKind VK,

                                               CastKind K, Expr *Op,

                                               const CXXCastPath *BasePath,

                                               TypeSourceInfo *WrittenTy,

                                               SourceLocation L,

                                               SourceLocation RParenLoc,

                                               SourceRange AngleBrackets) {

  unsigned PathSize = (BasePath ? BasePath->size() : 
00
);

  void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));

  auto *E =

      new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,

                                      RParenLoc, AngleBrackets);

  if (PathSize)

    std::uninitialized_copy_n(BasePath->data(), BasePath->size(),

                              E->getTrailingObjects<CXXBaseSpecifier *>());

  return E;

}

CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(const ASTContext &C,

                                                    unsigned PathSize) {

  void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));

  return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);

}

/// isAlwaysNull - Return whether the result of the dynamic_cast is proven

/// to always be null. For example:

///

/// struct A { };

/// struct B final : A { };

/// struct C { };

///

/// C *f(B* b) { return dynamic_cast<C*>(b); }

bool CXXDynamicCastExpr::isAlwaysNull() const

{

  QualType SrcType = getSubExpr()->getType();

  QualType DestType = getType();

  if (const auto *SrcPTy = SrcType->getAs<PointerType>()) {

    SrcType = SrcPTy->getPointeeType();

    DestType = DestType->castAs<PointerType>()->getPointeeType();

  }

  if (DestType->isVoidType())

    return false;

  const auto *SrcRD =

      cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl());

  if (!SrcRD->hasAttr<FinalAttr>())

    return false;

  const auto *DestRD =

      cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl());

  return !DestRD->isDerivedFrom(SrcRD);

}

CXXReinterpretCastExpr *

CXXReinterpretCastExpr::Create(const ASTContext &C, QualType T,

                               ExprValueKind VK, CastKind K, Expr *Op,

                               const CXXCastPath *BasePath,

                               TypeSourceInfo *WrittenTy, SourceLocation L,

                               SourceLocation RParenLoc,

                               SourceRange AngleBrackets) {

  unsigned PathSize = (BasePath ? 
BasePath->size()570
 : 
06.40k
);

  void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));

  auto *E =

      new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,

                                          RParenLoc, AngleBrackets);

  if (PathSize)

    std::uninitialized_copy_n(BasePath->data(), BasePath->size(),

                              E->getTrailingObjects<CXXBaseSpecifier *>());

  return E;

}

CXXReinterpretCastExpr *

CXXReinterpretCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) {

  void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));

  return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);

}

CXXConstCastExpr *CXXConstCastExpr::Create(const ASTContext &C, QualType T,

                                           ExprValueKind VK, Expr *Op,

                                           TypeSourceInfo *WrittenTy,

                                           SourceLocation L,

                                           SourceLocation RParenLoc,

                                           SourceRange AngleBrackets) {

  return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets);

}

CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(const ASTContext &C) {

  return new (C) CXXConstCastExpr(EmptyShell());

}

CXXAddrspaceCastExpr *

CXXAddrspaceCastExpr::Create(const ASTContext &C, QualType T, ExprValueKind VK,

                             CastKind K, Expr *Op, TypeSourceInfo *WrittenTy,

                             SourceLocation L, SourceLocation RParenLoc,

                             SourceRange AngleBrackets) {

  return new (C) CXXAddrspaceCastExpr(T, VK, K, Op, WrittenTy, L, RParenLoc,

                                      AngleBrackets);

}

CXXAddrspaceCastExpr *CXXAddrspaceCastExpr::CreateEmpty(const ASTContext &C) {

  return new (C) CXXAddrspaceCastExpr(EmptyShell());

}

CXXFunctionalCastExpr *CXXFunctionalCastExpr::Create(

    const ASTContext &C, QualType T, ExprValueKind VK, TypeSourceInfo *Written,

    CastKind K, Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO,

    SourceLocation L, SourceLocation R) {

  unsigned PathSize = (BasePath ? 
BasePath->size()67.2k
 : 
04.64k
);

  void *Buffer =

      C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

          PathSize, FPO.requiresTrailingStorage()));

  auto *E = new (Buffer)

      CXXFunctionalCastExpr(T, VK, Written, K, Op, PathSize, FPO, L, R);

  if (PathSize)

    std::uninitialized_copy_n(BasePath->data(), BasePath->size(),

                              E->getTrailingObjects<CXXBaseSpecifier *>());

  return E;

}

CXXFunctionalCastExpr *CXXFunctionalCastExpr::CreateEmpty(const ASTContext &C,

                                                          unsigned PathSize,

                                                          bool HasFPFeatures) {

  void *Buffer =

      C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

          PathSize, HasFPFeatures));

  return new (Buffer)

      CXXFunctionalCastExpr(EmptyShell(), PathSize, HasFPFeatures);

}

SourceLocation CXXFunctionalCastExpr::getBeginLoc() const {

  return getTypeInfoAsWritten()->getTypeLoc().getBeginLoc();

}

SourceLocation CXXFunctionalCastExpr::getEndLoc() const {

  return RParenLoc.isValid() ? 
RParenLoc95.2k
 : 
getSubExpr()->getEndLoc()10.5k
;

}

UserDefinedLiteral::UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args,

                                       QualType Ty, ExprValueKind VK,

                                       SourceLocation LitEndLoc,

                                       SourceLocation SuffixLoc,

                                       FPOptionsOverride FPFeatures)

    : CallExpr(UserDefinedLiteralClass, Fn, /*PreArgs=*/{}, Args, Ty, VK,

               LitEndLoc, FPFeatures, /*MinNumArgs=*/0, NotADL),

      UDSuffixLoc(SuffixLoc) {}

UserDefinedLiteral::UserDefinedLiteral(unsigned NumArgs, bool HasFPFeatures,

                                       EmptyShell Empty)

    : CallExpr(UserDefinedLiteralClass, /*NumPreArgs=*/0, NumArgs,

               HasFPFeatures, Empty) {}

UserDefinedLiteral *UserDefinedLiteral::Create(const ASTContext &Ctx, Expr *Fn,

                                               ArrayRef<Expr *> Args,

                                               QualType Ty, ExprValueKind VK,

                                               SourceLocation LitEndLoc,

                                               SourceLocation SuffixLoc,

                                               FPOptionsOverride FPFeatures) {

  // Allocate storage for the trailing objects of CallExpr.

  unsigned NumArgs = Args.size();

  unsigned SizeOfTrailingObjects = CallExpr::sizeOfTrailingObjects(

      /*NumPreArgs=*/0, NumArgs, FPFeatures.requiresTrailingStorage());

  void *Mem = Ctx.Allocate(sizeof(UserDefinedLiteral) + SizeOfTrailingObjects,

                           alignof(UserDefinedLiteral));

  return new (Mem)

      UserDefinedLiteral(Fn, Args, Ty, VK, LitEndLoc, SuffixLoc, FPFeatures);

}

UserDefinedLiteral *UserDefinedLiteral::CreateEmpty(const ASTContext &Ctx,

                                                    unsigned NumArgs,

                                                    bool HasFPOptions,

                                                    EmptyShell Empty) {

  // Allocate storage for the trailing objects of CallExpr.

  unsigned SizeOfTrailingObjects =

      CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs, HasFPOptions);

  void *Mem = Ctx.Allocate(sizeof(UserDefinedLiteral) + SizeOfTrailingObjects,

                           alignof(UserDefinedLiteral));

  return new (Mem) UserDefinedLiteral(NumArgs, HasFPOptions, Empty);

}

UserDefinedLiteral::LiteralOperatorKind

UserDefinedLiteral::getLiteralOperatorKind() const {

  if (getNumArgs() == 0)

    return LOK_Template;

  if (getNumArgs() == 2)

    return LOK_String;

  assert(getNumArgs() == 1 && "unexpected #args in literal operator call");

  QualType ParamTy =

    cast<FunctionDecl>(getCalleeDecl())->getParamDecl(0)->getType();

  if (ParamTy->isPointerType())

    return LOK_Raw;

  if (ParamTy->isAnyCharacterType())

    return LOK_Character;

  if (ParamTy->isIntegerType())

    return LOK_Integer;

  if (ParamTy->isFloatingType())

    return LOK_Floating;

  llvm_unreachable("unknown kind of literal operator");

}

Expr *UserDefinedLiteral::getCookedLiteral() {

#ifndef NDEBUG

  LiteralOperatorKind LOK = getLiteralOperatorKind();

  assert(LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal");

#endif

  return getArg(0);

}

const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const {

  return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier();

}

CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx,

                                       SourceLocation Loc, FieldDecl *Field,

                                       QualType Ty, DeclContext *UsedContext)

    : Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),

           Ty->isLValueReferenceType()   ? VK_LValue

           : Ty->isRValueReferenceType() ? VK_XValue

                                         : VK_PRValue,

           /*FIXME*/ OK_Ordinary),

      Field(Field), UsedContext(UsedContext) {

  CXXDefaultInitExprBits.Loc = Loc;

  assert(Field->hasInClassInitializer());

  setDependence(computeDependence(this));

}

CXXTemporary *CXXTemporary::Create(const ASTContext &C,

                                   const CXXDestructorDecl *Destructor) {

  return new (C) CXXTemporary(Destructor);

}

CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(const ASTContext &C,

                                                   CXXTemporary *Temp,

                                                   Expr* SubExpr) {

  assert((SubExpr->getType()->isRecordType() ||

          SubExpr->getType()->isArrayType()) &&

         "Expression bound to a temporary must have record or array type!");

  return new (C) CXXBindTemporaryExpr(Temp, SubExpr);

}

CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(

    CXXConstructorDecl *Cons, QualType Ty, TypeSourceInfo *TSI,

    ArrayRef<Expr *> Args, SourceRange ParenOrBraceRange,

    bool HadMultipleCandidates, bool ListInitialization,

    bool StdInitListInitialization, bool ZeroInitialization)

    : CXXConstructExpr(

          CXXTemporaryObjectExprClass, Ty, TSI->getTypeLoc().getBeginLoc(),

          Cons, /* Elidable=*/false, Args, HadMultipleCandidates,

          ListInitialization, StdInitListInitialization, ZeroInitialization,

          CXXConstructExpr::CK_Complete, ParenOrBraceRange),

      TSI(TSI) {

  setDependence(computeDependence(this));

}

CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(EmptyShell Empty,

                                               unsigned NumArgs)

    : CXXConstructExpr(CXXTemporaryObjectExprClass, Empty, NumArgs) {}

CXXTemporaryObjectExpr *CXXTemporaryObjectExpr::Create(

    const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty,

    TypeSourceInfo *TSI, ArrayRef<Expr *> Args, SourceRange ParenOrBraceRange,

    bool HadMultipleCandidates, bool ListInitialization,

    bool StdInitListInitialization, bool ZeroInitialization) {

  unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(Args.size());

  void *Mem =

      Ctx.Allocate(sizeof(CXXTemporaryObjectExpr) + SizeOfTrailingObjects,

                   alignof(CXXTemporaryObjectExpr));

  return new (Mem) CXXTemporaryObjectExpr(

      Cons, Ty, TSI, Args, ParenOrBraceRange, HadMultipleCandidates,

      ListInitialization, StdInitListInitialization, ZeroInitialization);

}

CXXTemporaryObjectExpr *

CXXTemporaryObjectExpr::CreateEmpty(const ASTContext &Ctx, unsigned NumArgs) {

  unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(NumArgs);

  void *Mem =

      Ctx.Allocate(sizeof(CXXTemporaryObjectExpr) + SizeOfTrailingObjects,

                   alignof(CXXTemporaryObjectExpr));

  return new (Mem) CXXTemporaryObjectExpr(EmptyShell(), NumArgs);

}

SourceLocation CXXTemporaryObjectExpr::getBeginLoc() const {

  return getTypeSourceInfo()->getTypeLoc().getBeginLoc();

}

SourceLocation CXXTemporaryObjectExpr::getEndLoc() const {

  SourceLocation Loc = getParenOrBraceRange().getEnd();

  if (Loc.isInvalid() && 
getNumArgs()0
)

    Loc = getArg(getNumArgs() - 1)->getEndLoc();

  return Loc;

}

CXXConstructExpr *CXXConstructExpr::Create(