//===- 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>

#include <optional>

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: 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_NE : BO->getOpcode();

    Result.LHS = BO->getLHS();

    Result.RHS = BO->getRHS();

    Result.InnerBinOp = BO;

  } else if (auto *BO = 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_NE : BO_EQ; 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_NE)

    return Result;

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

  E = Result.LHS->IgnoreUnlessSpelledInSource();

  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())

      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() : getRParenLoc();

}

// CXXNewExpr

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

                       FunctionDecl *OperatorDelete, bool ShouldPassAlignment,

                       bool UsualArrayDeleteWantsSize,

                       ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens,

                       std::optional<Expr *> ArraySize,

                       CXXNewInitializationStyle 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 == CXXNewInitializationStyle::None ||

          InitializationStyle == CXXNewInitializationStyle::Implicit) &&

         "Only NoInit can have no initializer!");

  CXXNewExprBits.IsGlobalNew = IsGlobalNew;

  CXXNewExprBits.IsArray = ArraySize.has_value();

  CXXNewExprBits.ShouldPassAlignment = ShouldPassAlignment;

  CXXNewExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;

  CXXNewExprBits.StoredInitializationStyle =

      llvm::to_underlying(InitializationStyle);

  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(); ++I)

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

        PlacementArgs[I];

  if (IsParenTypeId)

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

  switch (getInitializationStyle()) {

  case CXXNewInitializationStyle::Call:

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

    break;

  case CXXNewInitializationStyle::List:

    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, std::optional<Expr *> ArraySize,

    CXXNewInitializationStyle InitializationStyle, Expr *Initializer,

    QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,

    SourceRange DirectInitRange) {

  bool IsArray = ArraySize.has_value();

  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 {

  if (getOperatorNew()->getLangOpts().CheckNew)

    return true;

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

         getOperatorNew()

             ->getType()

             ->castAs<FunctionProtoType>()

             ->isNothrow() &&

         !getOperatorNew()->isReservedGlobalPlacementOperator();

}

// 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_UncheckedDerivedToBase ||

        ICE->getCastKind() == CK_NoOp) {

      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())

    return QualType();

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

}

// CXXPseudoDestructorExpr

PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)

    : Type(Info) {

  Location = Info->getTypeLoc().getBeginLoc();

}

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().getSourceRange().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, bool KnownDependent)

    : OverloadExpr(UnresolvedLookupExprClass, Context, QualifierLoc,

                   TemplateKWLoc, NameInfo, TemplateArgs, Begin, End,

                   KnownDependent, 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, false);

}

UnresolvedLookupExpr *UnresolvedLookupExpr::Create(

    const ASTContext &Context, CXXRecordDecl *NamingClass,

    NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,

    const DeclarationNameInfo &NameInfo, bool RequiresADL,

    const TemplateArgumentListInfo *Args, UnresolvedSetIterator Begin,

    UnresolvedSetIterator End, bool KnownDependent) {

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

  unsigned NumResults = End - Begin;

  unsigned NumTemplateArgs = Args ? Args->size() : 0;

  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, KnownDependent);

}

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();

  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();

  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();

  std::size_t Size =

      totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(

          HasTemplateKWAndArgsInfo, Args ? Args->size() : 0);

  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; --I) {

    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_MinusMinus) {

    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_PtrMemI)

      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() : 0);

  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() : 0);

  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 {

  if (isValueDependent() || getCastKind() != CK_Dynamic)

    return false;

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

  QualType DestType = getType();

  if (DestType->isVoidPointerType())

    return false;

  if (DestType->isPointerType()) {

    SrcType = SrcType->getPointeeType();

    DestType = DestType->getPointeeType();

  }

  const auto *SrcRD = SrcType->getAsCXXRecordDecl();

  const auto *DestRD = DestType->getAsCXXRecordDecl();

  assert(SrcRD && DestRD);

  if (SrcRD->isEffectivelyFinal()) {

    assert(!SrcRD->isDerivedFrom(DestRD) &&

           "upcasts should not use CK_Dynamic");

    return true;

  }

  if (DestRD->isEffectivelyFinal() && !DestRD->isDerivedFrom(SrcRD))

    return true;

  return false;

}

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() : 0);

  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() : 0);

  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() ? RParenLoc : getSubExpr()->getEndLoc();

}

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;