/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp

Bug Summary

File:	tools/clang/lib/AST/ExprCXX.cpp
Warning:	line 1431, column 31 Access to field 'HasTemplateKWAndArgsInfo' results in a dereference of a null pointer (loaded from variable 'E')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ExprCXX.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-8~svn350071/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn350071/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/clang/lib/AST -fdebug-prefix-map=/build/llvm-toolchain-snapshot-8~svn350071=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-12-27-042839-1215-1 -x c++ /build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp -faddrsig
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//===----------------------------------------------------------------------===//

14#include "clang/AST/ExprCXX.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/Attr.h"
17#include "clang/AST/Decl.h"
18#include "clang/AST/DeclAccessPair.h"
19#include "clang/AST/DeclBase.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclarationName.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/LambdaCapture.h"
24#include "clang/AST/NestedNameSpecifier.h"
25#include "clang/AST/TemplateBase.h"
26#include "clang/AST/Type.h"
27#include "clang/AST/TypeLoc.h"
28#include "clang/Basic/LLVM.h"
29#include "clang/Basic/OperatorKinds.h"
30#include "clang/Basic/SourceLocation.h"
31#include "clang/Basic/Specifiers.h"
32#include "llvm/ADT/ArrayRef.h"
33#include "llvm/Support/Casting.h"
34#include "llvm/Support/ErrorHandling.h"
35#include <cassert>
36#include <cstddef>
37#include <cstring>
38#include <memory>

40using namespace clang;

42//===----------------------------------------------------------------------===//
43//  Child Iterators for iterating over subexpressions/substatements
44//===----------------------------------------------------------------------===//

46bool 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;
}
60}

62bool 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;
75}

77QualType CXXTypeidExpr::getTypeOperand(ASTContext &Context) const {
assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)")((isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)"
) ? static_cast<void> (0) : __assert_fail ("isTypeOperand() && \"Cannot call getTypeOperand for typeid(expr)\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 78, __PRETTY_FUNCTION__));
Qualifiers Quals;
return Context.getUnqualifiedArrayType(
    Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType(), Quals);
82}

84QualType CXXUuidofExpr::getTypeOperand(ASTContext &Context) const {
assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)")((isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)"
) ? static_cast<void> (0) : __assert_fail ("isTypeOperand() && \"Cannot call getTypeOperand for __uuidof(expr)\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 85, __PRETTY_FUNCTION__));
Qualifiers Quals;
return Context.getUnqualifiedArrayType(
    Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType(), Quals);
89}

91// CXXScalarValueInitExpr
92SourceLocation CXXScalarValueInitExpr::getBeginLoc() const {
return TypeInfo ? TypeInfo->getTypeLoc().getBeginLoc() : RParenLoc;
94}

96// CXXNewExpr
97CXXNewExpr::CXXNewExpr(const ASTContext &C, bool globalNew,
                     FunctionDecl *operatorNew, FunctionDecl *operatorDelete,
                     bool PassAlignment, bool usualArrayDeleteWantsSize,
                     ArrayRef<Expr*> placementArgs,
                     SourceRange typeIdParens, Expr *arraySize,
                     InitializationStyle initializationStyle,
                     Expr *initializer, QualType ty,
                     TypeSourceInfo *allocatedTypeInfo,
                     SourceRange Range, SourceRange directInitRange)
  : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary, ty->isDependentType(),
         ty->isDependentType(), ty->isInstantiationDependentType(),
         ty->containsUnexpandedParameterPack()),
    OperatorNew(operatorNew), OperatorDelete(operatorDelete),
    AllocatedTypeInfo(allocatedTypeInfo), TypeIdParens(typeIdParens),
    Range(Range), DirectInitRange(directInitRange), GlobalNew(globalNew),
    PassAlignment(PassAlignment),
    UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) {
assert((initializer != nullptr || initializationStyle == NoInit) &&(((initializer != nullptr || initializationStyle == NoInit) &&
 "Only NoInit can have no initializer.") ? static_cast<void
> (0) : __assert_fail ("(initializer != nullptr || initializationStyle == NoInit) && \"Only NoInit can have no initializer.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 115, __PRETTY_FUNCTION__))
       "Only NoInit can have no initializer.")(((initializer != nullptr || initializationStyle == NoInit) &&
 "Only NoInit can have no initializer.") ? static_cast<void
> (0) : __assert_fail ("(initializer != nullptr || initializationStyle == NoInit) && \"Only NoInit can have no initializer.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 115, __PRETTY_FUNCTION__));
StoredInitializationStyle = initializer ? initializationStyle + 1 : 0;
AllocateArgsArray(C, arraySize != nullptr, placementArgs.size(),
                  initializer != nullptr);
unsigned i = 0;
if (Array) {
  if (arraySize->isInstantiationDependent())
    ExprBits.InstantiationDependent = true;

  if (arraySize->containsUnexpandedParameterPack())
    ExprBits.ContainsUnexpandedParameterPack = true;

  SubExprs[i++] = arraySize;
}

if (initializer) {
  if (initializer->isInstantiationDependent())
    ExprBits.InstantiationDependent = true;

  if (initializer->containsUnexpandedParameterPack())
    ExprBits.ContainsUnexpandedParameterPack = true;

  SubExprs[i++] = initializer;
}

for (unsigned j = 0; j != placementArgs.size(); ++j) {
  if (placementArgs[j]->isInstantiationDependent())
    ExprBits.InstantiationDependent = true;
  if (placementArgs[j]->containsUnexpandedParameterPack())
    ExprBits.ContainsUnexpandedParameterPack = true;

  SubExprs[i++] = placementArgs[j];
}

switch (getInitializationStyle()) {
case CallInit:
  this->Range.setEnd(DirectInitRange.getEnd()); break;
case ListInit:
  this->Range.setEnd(getInitializer()->getSourceRange().getEnd()); break;
default:
  if (TypeIdParens.isValid())
    this->Range.setEnd(TypeIdParens.getEnd());
  break;
}
159}

161void CXXNewExpr::AllocateArgsArray(const ASTContext &C, bool isArray,
                                 unsigned numPlaceArgs, bool hasInitializer){
assert(SubExprs == nullptr && "SubExprs already allocated")((SubExprs == nullptr && "SubExprs already allocated"
) ? static_cast<void> (0) : __assert_fail ("SubExprs == nullptr && \"SubExprs already allocated\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 163, __PRETTY_FUNCTION__));
Array = isArray;
NumPlacementArgs = numPlaceArgs;

unsigned TotalSize = Array + hasInitializer + NumPlacementArgs;
SubExprs = new (C) Stmt*[TotalSize];
169}

171bool CXXNewExpr::shouldNullCheckAllocation(const ASTContext &Ctx) const {
return getOperatorNew()->getType()->castAs<FunctionProtoType>()
                                        ->isNothrow() &&
       !getOperatorNew()->isReservedGlobalPlacementOperator();
175}

177// CXXDeleteExpr
178QualType 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 ||(((ICE->getCastKind() == CK_NoOp || getOperatorDelete()->
isDestroyingOperatorDelete()) && "only a destroying operator delete can have a converted arg"
) ? static_cast<void> (0) : __assert_fail ("(ICE->getCastKind() == CK_NoOp || getOperatorDelete()->isDestroyingOperatorDelete()) && \"only a destroying operator delete can have a converted arg\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 190, __PRETTY_FUNCTION__))
            getOperatorDelete()->isDestroyingOperatorDelete()) &&(((ICE->getCastKind() == CK_NoOp || getOperatorDelete()->
isDestroyingOperatorDelete()) && "only a destroying operator delete can have a converted arg"
) ? static_cast<void> (0) : __assert_fail ("(ICE->getCastKind() == CK_NoOp || getOperatorDelete()->isDestroyingOperatorDelete()) && \"only a destroying operator delete can have a converted arg\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 190, __PRETTY_FUNCTION__))
           "only a destroying operator delete can have a converted arg")(((ICE->getCastKind() == CK_NoOp || getOperatorDelete()->
isDestroyingOperatorDelete()) && "only a destroying operator delete can have a converted arg"
) ? static_cast<void> (0) : __assert_fail ("(ICE->getCastKind() == CK_NoOp || getOperatorDelete()->isDestroyingOperatorDelete()) && \"only a destroying operator delete can have a converted arg\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 190, __PRETTY_FUNCTION__));
    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->getAs<PointerType>()->getPointeeType();
203}

205// CXXPseudoDestructorExpr
206PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)
  : Type(Info) {
Location = Info->getTypeLoc().getLocalSourceRange().getBegin();
209}

211CXXPseudoDestructorExpr::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_RValue, OK_Ordinary,
       /*isTypeDependent=*/(Base->isTypeDependent() ||
         (DestroyedType.getTypeSourceInfo() &&
          DestroyedType.getTypeSourceInfo()->getType()->isDependentType())),
       /*isValueDependent=*/Base->isValueDependent(),
       (Base->isInstantiationDependent() ||
        (QualifierLoc &&
         QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) ||
        (ScopeType &&
         ScopeType->getType()->isInstantiationDependentType()) ||
        (DestroyedType.getTypeSourceInfo() &&
         DestroyedType.getTypeSourceInfo()->getType()
                                           ->isInstantiationDependentType())),
       // ContainsUnexpandedParameterPack
       (Base->containsUnexpandedParameterPack() ||
        (QualifierLoc &&
         QualifierLoc.getNestedNameSpecifier()
                                      ->containsUnexpandedParameterPack()) ||
        (ScopeType &&
         ScopeType->getType()->containsUnexpandedParameterPack()) ||
        (DestroyedType.getTypeSourceInfo() &&
         DestroyedType.getTypeSourceInfo()->getType()
                                 ->containsUnexpandedParameterPack()))),
  Base(static_cast<Stmt *>(Base)), IsArrow(isArrow),
  OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
  ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),
  DestroyedType(DestroyedType) {}

246QualType CXXPseudoDestructorExpr::getDestroyedType() const {
if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
  return TInfo->getType();

return QualType();
251}

253SourceLocation CXXPseudoDestructorExpr::getEndLoc() const {
SourceLocation End = DestroyedType.getLocation();
if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
  End = TInfo->getTypeLoc().getLocalSourceRange().getEnd();
return End;
258}

260// UnresolvedLookupExpr
261UnresolvedLookupExpr *
262UnresolvedLookupExpr::Create(const ASTContext &C,
                           CXXRecordDecl *NamingClass,
                           NestedNameSpecifierLoc QualifierLoc,
                           SourceLocation TemplateKWLoc,
                           const DeclarationNameInfo &NameInfo,
                           bool ADL,
                           const TemplateArgumentListInfo *Args,
                           UnresolvedSetIterator Begin,
                           UnresolvedSetIterator End) {
assert(Args || TemplateKWLoc.isValid())((Args || TemplateKWLoc.isValid()) ? static_cast<void> (
0) : __assert_fail ("Args || TemplateKWLoc.isValid()", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 271, __PRETTY_FUNCTION__));
unsigned num_args = Args ? Args->size() : 0;

std::size_t Size =
    totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(1,
                                                                    num_args);
void *Mem = C.Allocate(Size, alignof(UnresolvedLookupExpr));
return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc,
                                      TemplateKWLoc, NameInfo,
                                      ADL, /*Overload*/ true, Args,
                                      Begin, End);
282}

284UnresolvedLookupExpr *
285UnresolvedLookupExpr::CreateEmpty(const ASTContext &C,
                                bool HasTemplateKWAndArgsInfo,
                                unsigned NumTemplateArgs) {
assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo)((NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo) ? static_cast
<void> (0) : __assert_fail ("NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 288, __PRETTY_FUNCTION__));
std::size_t Size =
    totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
        HasTemplateKWAndArgsInfo, NumTemplateArgs);
void *Mem = C.Allocate(Size, alignof(UnresolvedLookupExpr));
auto *E = new (Mem) UnresolvedLookupExpr(EmptyShell());
E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
return E;
296}

298OverloadExpr::OverloadExpr(StmtClass K, const ASTContext &C,
                         NestedNameSpecifierLoc QualifierLoc,
                         SourceLocation TemplateKWLoc,
                         const DeclarationNameInfo &NameInfo,
                         const TemplateArgumentListInfo *TemplateArgs,
                         UnresolvedSetIterator Begin,
                         UnresolvedSetIterator End,
                         bool KnownDependent,
                         bool KnownInstantiationDependent,
                         bool KnownContainsUnexpandedParameterPack)
  : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent,
         KnownDependent,
         (KnownInstantiationDependent ||
          NameInfo.isInstantiationDependent() ||
          (QualifierLoc &&
          QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
         (KnownContainsUnexpandedParameterPack ||
          NameInfo.containsUnexpandedParameterPack() ||
          (QualifierLoc &&
           QualifierLoc.getNestedNameSpecifier()
                                      ->containsUnexpandedParameterPack()))),
    NameInfo(NameInfo), QualifierLoc(QualifierLoc), NumResults(End - Begin),
    HasTemplateKWAndArgsInfo(TemplateArgs != nullptr ||
                             TemplateKWLoc.isValid()) {
NumResults = End - Begin;
if (NumResults) {
  // Determine whether this expression is type-dependent.
  for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) {
    if ((*I)->getDeclContext()->isDependentContext() ||
        isa<UnresolvedUsingValueDecl>(*I)) {
      ExprBits.TypeDependent = true;
      ExprBits.ValueDependent = true;
      ExprBits.InstantiationDependent = true;
    }
  }

  Results = static_cast<DeclAccessPair *>(C.Allocate(
      sizeof(DeclAccessPair) * NumResults, alignof(DeclAccessPair)));
  memcpy(Results, Begin.I, NumResults * sizeof(DeclAccessPair));
}

// If we have explicit template arguments, check for dependent
// template arguments and whether they contain any unexpanded pack
// expansions.
if (TemplateArgs) {
  bool Dependent = false;
  bool InstantiationDependent = false;
  bool ContainsUnexpandedParameterPack = false;
  getTrailingASTTemplateKWAndArgsInfo()->initializeFrom(
      TemplateKWLoc, *TemplateArgs, getTrailingTemplateArgumentLoc(),
      Dependent, InstantiationDependent, ContainsUnexpandedParameterPack);

  if (Dependent) {
    ExprBits.TypeDependent = true;
    ExprBits.ValueDependent = true;
  }
  if (InstantiationDependent)
    ExprBits.InstantiationDependent = true;
  if (ContainsUnexpandedParameterPack)
    ExprBits.ContainsUnexpandedParameterPack = true;
} else if (TemplateKWLoc.isValid()) {
  getTrailingASTTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
}

if (isTypeDependent())
  setType(C.DependentTy);
364}

366void OverloadExpr::initializeResults(const ASTContext &C,
                                   UnresolvedSetIterator Begin,
                                   UnresolvedSetIterator End) {
assert(!Results && "Results already initialized!")((!Results && "Results already initialized!") ? static_cast
<void> (0) : __assert_fail ("!Results && \"Results already initialized!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 369, __PRETTY_FUNCTION__));
NumResults = End - Begin;
if (NumResults) {
  Results = static_cast<DeclAccessPair *>(
      C.Allocate(sizeof(DeclAccessPair) * NumResults,

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

380CXXRecordDecl *OverloadExpr::getNamingClass() const {
if (isa<UnresolvedLookupExpr>(this))
  return cast<UnresolvedLookupExpr>(this)->getNamingClass();
else
  return cast<UnresolvedMemberExpr>(this)->getNamingClass();
385}

387// DependentScopeDeclRefExpr
388DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T,
                          NestedNameSpecifierLoc QualifierLoc,
                          SourceLocation TemplateKWLoc,
                          const DeclarationNameInfo &NameInfo,
                          const TemplateArgumentListInfo *Args)
: Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary,
       true, true,
       (NameInfo.isInstantiationDependent() ||
        (QualifierLoc &&
         QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
       (NameInfo.containsUnexpandedParameterPack() ||
        (QualifierLoc &&
         QualifierLoc.getNestedNameSpecifier()
                          ->containsUnexpandedParameterPack()))),
  QualifierLoc(QualifierLoc), NameInfo(NameInfo),
  HasTemplateKWAndArgsInfo(Args != nullptr || TemplateKWLoc.isValid())
404{
if (Args) {
  bool Dependent = true;
  bool InstantiationDependent = true;
  bool ContainsUnexpandedParameterPack
    = ExprBits.ContainsUnexpandedParameterPack;
  getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
      TemplateKWLoc, *Args, getTrailingObjects<TemplateArgumentLoc>(),
      Dependent, InstantiationDependent, ContainsUnexpandedParameterPack);
  ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
} else if (TemplateKWLoc.isValid()) {
  getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
      TemplateKWLoc);
}
418}

420DependentScopeDeclRefExpr *
421DependentScopeDeclRefExpr::Create(const ASTContext &C,
                                NestedNameSpecifierLoc QualifierLoc,
                                SourceLocation TemplateKWLoc,
                                const DeclarationNameInfo &NameInfo,
                                const TemplateArgumentListInfo *Args) {
assert(QualifierLoc && "should be created for dependent qualifiers")((QualifierLoc && "should be created for dependent qualifiers"
) ? static_cast<void> (0) : __assert_fail ("QualifierLoc && \"should be created for dependent qualifiers\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 426, __PRETTY_FUNCTION__));
bool HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.isValid();
std::size_t Size =
    totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
        HasTemplateKWAndArgsInfo, Args ? Args->size() : 0);
void *Mem = C.Allocate(Size);
return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc,
                                           TemplateKWLoc, NameInfo, Args);
434}

436DependentScopeDeclRefExpr *
437DependentScopeDeclRefExpr::CreateEmpty(const ASTContext &C,
                                     bool HasTemplateKWAndArgsInfo,
                                     unsigned NumTemplateArgs) {
assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo)((NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo) ? static_cast
<void> (0) : __assert_fail ("NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 440, __PRETTY_FUNCTION__));
std::size_t Size =
    totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
        HasTemplateKWAndArgsInfo, NumTemplateArgs);
void *Mem = C.Allocate(Size);
auto *E =
    new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(),
                                        SourceLocation(),
                                        DeclarationNameInfo(), nullptr);
E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
return E;
451}

453SourceLocation CXXConstructExpr::getBeginLoc() const {
if (isa<CXXTemporaryObjectExpr>(this))
  return cast<CXXTemporaryObjectExpr>(this)->getBeginLoc();
return getLocation();
457}

459SourceLocation 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;
479}

481CXXOperatorCallExpr::CXXOperatorCallExpr(OverloadedOperatorKind OpKind,
                                       Expr *Fn, ArrayRef<Expr *> Args,
                                       QualType Ty, ExprValueKind VK,
                                       SourceLocation OperatorLoc,
                                       FPOptions FPFeatures,
                                       ADLCallKind UsesADL)
  : CallExpr(CXXOperatorCallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK,
             OperatorLoc, /*MinNumArgs=*/0, UsesADL) {
CXXOperatorCallExprBits.OperatorKind = OpKind;
CXXOperatorCallExprBits.FPFeatures = FPFeatures.getInt();
assert((((CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned
>(OpKind)) && "OperatorKind overflow!") ? static_cast
<void> (0) : __assert_fail ("(CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) && \"OperatorKind overflow!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 493, __PRETTY_FUNCTION__))
    (CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) &&(((CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned
>(OpKind)) && "OperatorKind overflow!") ? static_cast
<void> (0) : __assert_fail ("(CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) && \"OperatorKind overflow!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 493, __PRETTY_FUNCTION__))
    "OperatorKind overflow!")(((CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned
>(OpKind)) && "OperatorKind overflow!") ? static_cast
<void> (0) : __assert_fail ("(CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) && \"OperatorKind overflow!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 493, __PRETTY_FUNCTION__));
assert((CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt()) &&(((CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt())
 && "FPFeatures overflow!") ? static_cast<void>
 (0) : __assert_fail ("(CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt()) && \"FPFeatures overflow!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 495, __PRETTY_FUNCTION__))
       "FPFeatures overflow!")(((CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt())
 && "FPFeatures overflow!") ? static_cast<void>
 (0) : __assert_fail ("(CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt()) && \"FPFeatures overflow!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 495, __PRETTY_FUNCTION__));
Range = getSourceRangeImpl();
497}

499CXXOperatorCallExpr::CXXOperatorCallExpr(unsigned NumArgs, EmptyShell Empty)
  : CallExpr(CXXOperatorCallExprClass, /*NumPreArgs=*/0, NumArgs, Empty) {}

502CXXOperatorCallExpr *CXXOperatorCallExpr::Create(
  const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn,
  ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
  SourceLocation OperatorLoc, FPOptions FPFeatures, ADLCallKind UsesADL) {
// Allocate storage for the trailing objects of CallExpr.
unsigned NumArgs = Args.size();
unsigned SizeOfTrailingObjects =
    CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
void *Mem = Ctx.Allocate(sizeof(CXXOperatorCallExpr) + SizeOfTrailingObjects,
                         alignof(CXXOperatorCallExpr));
return new (Mem) CXXOperatorCallExpr(OpKind, Fn, Args, Ty, VK, OperatorLoc,
                                     FPFeatures, UsesADL);
514}

516CXXOperatorCallExpr *CXXOperatorCallExpr::CreateEmpty(const ASTContext &Ctx,
                                                    unsigned NumArgs,
                                                    EmptyShell Empty) {
// Allocate storage for the trailing objects of CallExpr.
unsigned SizeOfTrailingObjects =
    CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
void *Mem = Ctx.Allocate(sizeof(CXXOperatorCallExpr) + SizeOfTrailingObjects,
                         alignof(CXXOperatorCallExpr));
return new (Mem) CXXOperatorCallExpr(NumArgs, Empty);
525}

527SourceRange 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 getArg(0)->getSourceRange();
} 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();
}
549}

551CXXMemberCallExpr::CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args,
                                   QualType Ty, ExprValueKind VK,
                                   SourceLocation RP, unsigned MinNumArgs)
  : CallExpr(CXXMemberCallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK, RP,
             MinNumArgs, NotADL) {}

557CXXMemberCallExpr::CXXMemberCallExpr(unsigned NumArgs, EmptyShell Empty)
  : CallExpr(CXXMemberCallExprClass, /*NumPreArgs=*/0, NumArgs, Empty) {}

560CXXMemberCallExpr *CXXMemberCallExpr::Create(const ASTContext &Ctx, Expr *Fn,
                                           ArrayRef<Expr *> Args, QualType Ty,
                                           ExprValueKind VK,
                                           SourceLocation RP,
                                           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);
void *Mem = Ctx.Allocate(sizeof(CXXMemberCallExpr) + SizeOfTrailingObjects,
                         alignof(CXXMemberCallExpr));
return new (Mem) CXXMemberCallExpr(Fn, Args, Ty, VK, RP, MinNumArgs);
572}

574CXXMemberCallExpr *CXXMemberCallExpr::CreateEmpty(const ASTContext &Ctx,
                                                unsigned NumArgs,
                                                EmptyShell Empty) {
// Allocate storage for the trailing objects of CallExpr.
unsigned SizeOfTrailingObjects =
    CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
void *Mem = Ctx.Allocate(sizeof(CXXMemberCallExpr) + SizeOfTrailingObjects,
                         alignof(CXXMemberCallExpr));
return new (Mem) CXXMemberCallExpr(NumArgs, Empty);
583}

585Expr *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;
595}

597CXXMethodDecl *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.
return nullptr;
603}

605CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() const {
Expr* ThisArg = getImplicitObjectArgument();
if (!ThisArg)
  return nullptr;

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

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

616//===----------------------------------------------------------------------===//
617//  Named casts
618//===----------------------------------------------------------------------===//

620/// getCastName - Get the name of the C++ cast being used, e.g.,
621/// "static_cast", "dynamic_cast", "reinterpret_cast", or
622/// "const_cast". The returned pointer must not be freed.
623const 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";
default:                          return "<invalid cast>";
}
631}

633CXXStaticCastExpr *CXXStaticCastExpr::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<CastExpr::BasePathSizeTy, CXXBaseSpecifier *>(
        PathSize ? 1 : 0, PathSize));
auto *E =
    new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
                                   RParenLoc, AngleBrackets);
if (PathSize)
  std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
                            E->getTrailingObjects<CXXBaseSpecifier *>());
return E;
652}

654CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(const ASTContext &C,
                                                unsigned PathSize) {
void *Buffer =
    C.Allocate(totalSizeToAlloc<CastExpr::BasePathSizeTy, CXXBaseSpecifier *>(
        PathSize ? 1 : 0, PathSize));
return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize);
660}

662CXXDynamicCastExpr *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<CastExpr::BasePathSizeTy, CXXBaseSpecifier *>(
        PathSize ? 1 : 0, 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;
681}

683CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(const ASTContext &C,
                                                  unsigned PathSize) {
void *Buffer =
    C.Allocate(totalSizeToAlloc<CastExpr::BasePathSizeTy, CXXBaseSpecifier *>(
        PathSize ? 1 : 0, PathSize));
return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);
689}

691/// isAlwaysNull - Return whether the result of the dynamic_cast is proven
692/// to always be null. For example:
693///
694/// struct A { };
695/// struct B final : A { };
696/// struct C { };
697///
698/// C *f(B* b) { return dynamic_cast<C*>(b); }
699bool CXXDynamicCastExpr::isAlwaysNull() const
700{
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);
722}

724CXXReinterpretCastExpr *
725CXXReinterpretCastExpr::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<CastExpr::BasePathSizeTy, CXXBaseSpecifier *>(
        PathSize ? 1 : 0, 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;
742}

744CXXReinterpretCastExpr *
745CXXReinterpretCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) {
void *Buffer =
    C.Allocate(totalSizeToAlloc<CastExpr::BasePathSizeTy, CXXBaseSpecifier *>(
        PathSize ? 1 : 0, PathSize));
return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);
750}

752CXXConstCastExpr *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);
759}

761CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(const ASTContext &C) {
return new (C) CXXConstCastExpr(EmptyShell());
763}

765CXXFunctionalCastExpr *
766CXXFunctionalCastExpr::Create(const ASTContext &C, QualType T, ExprValueKind VK,
                            TypeSourceInfo *Written, CastKind K, Expr *Op,
                            const CXXCastPath *BasePath,
                            SourceLocation L, SourceLocation R) {
unsigned PathSize = (BasePath ? BasePath->size() : 0);
void *Buffer =
    C.Allocate(totalSizeToAlloc<CastExpr::BasePathSizeTy, CXXBaseSpecifier *>(
        PathSize ? 1 : 0, PathSize));
auto *E =
    new (Buffer) CXXFunctionalCastExpr(T, VK, Written, K, Op, PathSize, L, R);
if (PathSize)
  std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
                            E->getTrailingObjects<CXXBaseSpecifier *>());
return E;
780}

782CXXFunctionalCastExpr *
783CXXFunctionalCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) {
void *Buffer =
    C.Allocate(totalSizeToAlloc<CastExpr::BasePathSizeTy, CXXBaseSpecifier *>(
        PathSize ? 1 : 0, PathSize));
return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize);
788}

790SourceLocation CXXFunctionalCastExpr::getBeginLoc() const {
return getTypeInfoAsWritten()->getTypeLoc().getBeginLoc();
792}

794SourceLocation CXXFunctionalCastExpr::getEndLoc() const {
return RParenLoc.isValid() ? RParenLoc : getSubExpr()->getEndLoc();
796}

798UserDefinedLiteral::UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args,
                                     QualType Ty, ExprValueKind VK,
                                     SourceLocation LitEndLoc,
                                     SourceLocation SuffixLoc)
  : CallExpr(UserDefinedLiteralClass, Fn, /*PreArgs=*/{}, Args, Ty, VK,
             LitEndLoc, /*MinNumArgs=*/0, NotADL),
    UDSuffixLoc(SuffixLoc) {}

806UserDefinedLiteral::UserDefinedLiteral(unsigned NumArgs, EmptyShell Empty)
  : CallExpr(UserDefinedLiteralClass, /*NumPreArgs=*/0, NumArgs, Empty) {}

809UserDefinedLiteral *UserDefinedLiteral::Create(const ASTContext &Ctx, Expr *Fn,
                                             ArrayRef<Expr *> Args,
                                             QualType Ty, ExprValueKind VK,
                                             SourceLocation LitEndLoc,
                                             SourceLocation SuffixLoc) {
// Allocate storage for the trailing objects of CallExpr.
unsigned NumArgs = Args.size();
unsigned SizeOfTrailingObjects =
    CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
void *Mem = Ctx.Allocate(sizeof(UserDefinedLiteral) + SizeOfTrailingObjects,
                         alignof(UserDefinedLiteral));
return new (Mem) UserDefinedLiteral(Fn, Args, Ty, VK, LitEndLoc, SuffixLoc);
821}

823UserDefinedLiteral *UserDefinedLiteral::CreateEmpty(const ASTContext &Ctx,
                                                  unsigned NumArgs,
                                                  EmptyShell Empty) {
// Allocate storage for the trailing objects of CallExpr.
unsigned SizeOfTrailingObjects =
    CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
void *Mem = Ctx.Allocate(sizeof(UserDefinedLiteral) + SizeOfTrailingObjects,
                         alignof(UserDefinedLiteral));
return new (Mem) UserDefinedLiteral(NumArgs, Empty);
832}

834UserDefinedLiteral::LiteralOperatorKind
835UserDefinedLiteral::getLiteralOperatorKind() const {
if (getNumArgs() == 0)
  return LOK_Template;
if (getNumArgs() == 2)
  return LOK_String;

assert(getNumArgs() == 1 && "unexpected #args in literal operator call")((getNumArgs() == 1 && "unexpected #args in literal operator call"
) ? static_cast<void> (0) : __assert_fail ("getNumArgs() == 1 && \"unexpected #args in literal operator call\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 841, __PRETTY_FUNCTION__));
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")::llvm::llvm_unreachable_internal("unknown kind of literal operator"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 853);
854}

856Expr *UserDefinedLiteral::getCookedLiteral() {
857#ifndef NDEBUG
LiteralOperatorKind LOK = getLiteralOperatorKind();
assert(LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal")((LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal"
) ? static_cast<void> (0) : __assert_fail ("LOK != LOK_Template && LOK != LOK_Raw && \"not a cooked literal\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 859, __PRETTY_FUNCTION__));
860#endif
return getArg(0);
862}

864const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const {
return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier();
866}

868CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx, SourceLocation Loc,
                                     FieldDecl *Field, QualType Ty)
  : Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
         Ty->isLValueReferenceType() ? VK_LValue : Ty->isRValueReferenceType()
                                                      ? VK_XValue
                                                      : VK_RValue,
         /*FIXME*/ OK_Ordinary, false, false, false, false),
    Field(Field) {
CXXDefaultInitExprBits.Loc = Loc;
assert(Field->hasInClassInitializer())((Field->hasInClassInitializer()) ? static_cast<void>
 (0) : __assert_fail ("Field->hasInClassInitializer()", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 877, __PRETTY_FUNCTION__));
878}

880CXXTemporary *CXXTemporary::Create(const ASTContext &C,
                                 const CXXDestructorDecl *Destructor) {
return new (C) CXXTemporary(Destructor);
883}

885CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(const ASTContext &C,
                                                 CXXTemporary *Temp,
                                                 Expr* SubExpr) {
assert((SubExpr->getType()->isRecordType() ||(((SubExpr->getType()->isRecordType() || SubExpr->getType
()->isArrayType()) && "Expression bound to a temporary must have record or array type!"
) ? static_cast<void> (0) : __assert_fail ("(SubExpr->getType()->isRecordType() || SubExpr->getType()->isArrayType()) && \"Expression bound to a temporary must have record or array type!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 890, __PRETTY_FUNCTION__))
        SubExpr->getType()->isArrayType()) &&(((SubExpr->getType()->isRecordType() || SubExpr->getType
()->isArrayType()) && "Expression bound to a temporary must have record or array type!"
) ? static_cast<void> (0) : __assert_fail ("(SubExpr->getType()->isRecordType() || SubExpr->getType()->isArrayType()) && \"Expression bound to a temporary must have record or array type!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 890, __PRETTY_FUNCTION__))
       "Expression bound to a temporary must have record or array type!")(((SubExpr->getType()->isRecordType() || SubExpr->getType
()->isArrayType()) && "Expression bound to a temporary must have record or array type!"
) ? static_cast<void> (0) : __assert_fail ("(SubExpr->getType()->isRecordType() || SubExpr->getType()->isArrayType()) && \"Expression bound to a temporary must have record or array type!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 890, __PRETTY_FUNCTION__));

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

895CXXTemporaryObjectExpr::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) {}

907CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(EmptyShell Empty,
                                             unsigned NumArgs)
  : CXXConstructExpr(CXXTemporaryObjectExprClass, Empty, NumArgs) {}

911CXXTemporaryObjectExpr *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);
923}

925CXXTemporaryObjectExpr *
926CXXTemporaryObjectExpr::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);
932}

934SourceLocation CXXTemporaryObjectExpr::getBeginLoc() const {
return getTypeSourceInfo()->getTypeLoc().getBeginLoc();
936}

938SourceLocation CXXTemporaryObjectExpr::getEndLoc() const {
SourceLocation Loc = getParenOrBraceRange().getEnd();
if (Loc.isInvalid() && getNumArgs())
  Loc = getArg(getNumArgs() - 1)->getEndLoc();
return Loc;
943}

945CXXConstructExpr *CXXConstructExpr::Create(
  const ASTContext &Ctx, QualType Ty, SourceLocation Loc,
  CXXConstructorDecl *Ctor, bool Elidable, ArrayRef<Expr *> Args,
  bool HadMultipleCandidates, bool ListInitialization,
  bool StdInitListInitialization, bool ZeroInitialization,
  ConstructionKind ConstructKind, SourceRange ParenOrBraceRange) {
unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(Args.size());
void *Mem = Ctx.Allocate(sizeof(CXXConstructExpr) + SizeOfTrailingObjects,
                         alignof(CXXConstructExpr));
return new (Mem) CXXConstructExpr(
    CXXConstructExprClass, Ty, Loc, Ctor, Elidable, Args,
    HadMultipleCandidates, ListInitialization, StdInitListInitialization,
    ZeroInitialization, ConstructKind, ParenOrBraceRange);
958}

960CXXConstructExpr *CXXConstructExpr::CreateEmpty(const ASTContext &Ctx,
                                              unsigned NumArgs) {
unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(NumArgs);
void *Mem = Ctx.Allocate(sizeof(CXXConstructExpr) + SizeOfTrailingObjects,
                         alignof(CXXConstructExpr));
return new (Mem)
    CXXConstructExpr(CXXConstructExprClass, EmptyShell(), NumArgs);
967}

969CXXConstructExpr::CXXConstructExpr(
  StmtClass SC, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor,
  bool Elidable, ArrayRef<Expr *> Args, bool HadMultipleCandidates,
  bool ListInitialization, bool StdInitListInitialization,
  bool ZeroInitialization, ConstructionKind ConstructKind,
  SourceRange ParenOrBraceRange)
  : Expr(SC, Ty, VK_RValue, OK_Ordinary, Ty->isDependentType(),
         Ty->isDependentType(), Ty->isInstantiationDependentType(),
         Ty->containsUnexpandedParameterPack()),
    Constructor(Ctor), ParenOrBraceRange(ParenOrBraceRange),
    NumArgs(Args.size()) {
CXXConstructExprBits.Elidable = Elidable;
CXXConstructExprBits.HadMultipleCandidates = HadMultipleCandidates;
CXXConstructExprBits.ListInitialization = ListInitialization;
CXXConstructExprBits.StdInitListInitialization = StdInitListInitialization;
CXXConstructExprBits.ZeroInitialization = ZeroInitialization;
CXXConstructExprBits.ConstructionKind = ConstructKind;
CXXConstructExprBits.Loc = Loc;

Stmt **TrailingArgs = getTrailingArgs();
for (unsigned I = 0, N = Args.size(); I != N; ++I) {
  assert(Args[I] && "NULL argument in CXXConstructExpr!")((Args[I] && "NULL argument in CXXConstructExpr!") ? static_cast
<void> (0) : __assert_fail ("Args[I] && \"NULL argument in CXXConstructExpr!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 990, __PRETTY_FUNCTION__));

  if (Args[I]->isValueDependent())
    ExprBits.ValueDependent = true;
  if (Args[I]->isInstantiationDependent())
    ExprBits.InstantiationDependent = true;
  if (Args[I]->containsUnexpandedParameterPack())
    ExprBits.ContainsUnexpandedParameterPack = true;

  TrailingArgs[I] = Args[I];
}
1001}

1003CXXConstructExpr::CXXConstructExpr(StmtClass SC, EmptyShell Empty,
                                 unsigned NumArgs)
  : Expr(SC, Empty), NumArgs(NumArgs) {}

1007LambdaCapture::LambdaCapture(SourceLocation Loc, bool Implicit,
                           LambdaCaptureKind Kind, VarDecl *Var,
                           SourceLocation EllipsisLoc)
  : DeclAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc) {
unsigned Bits = 0;
if (Implicit)
  Bits |= Capture_Implicit;

switch (Kind) {
case LCK_StarThis:
  Bits |= Capture_ByCopy;
  LLVM_FALLTHROUGH[[clang::fallthrough]];
case LCK_This:
  assert(!Var && "'this' capture cannot have a variable!")((!Var && "'this' capture cannot have a variable!") ?
 static_cast<void> (0) : __assert_fail ("!Var && \"'this' capture cannot have a variable!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 1020, __PRETTY_FUNCTION__));
  Bits |= Capture_This;
  break;

case LCK_ByCopy:
  Bits |= Capture_ByCopy;
  LLVM_FALLTHROUGH[[clang::fallthrough]];
case LCK_ByRef:
  assert(Var && "capture must have a variable!")((Var && "capture must have a variable!") ? static_cast
<void> (0) : __assert_fail ("Var && \"capture must have a variable!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 1028, __PRETTY_FUNCTION__));
  break;
case LCK_VLAType:
  assert(!Var && "VLA type capture cannot have a variable!")((!Var && "VLA type capture cannot have a variable!")
 ? static_cast<void> (0) : __assert_fail ("!Var && \"VLA type capture cannot have a variable!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 1031, __PRETTY_FUNCTION__));
  break;
}
DeclAndBits.setInt(Bits);
1035}

1037LambdaCaptureKind LambdaCapture::getCaptureKind() const {
if (capturesVLAType())
  return LCK_VLAType;
bool CapByCopy = DeclAndBits.getInt() & Capture_ByCopy;
if (capturesThis())
  return CapByCopy ? LCK_StarThis : LCK_This;
return CapByCopy ? LCK_ByCopy : LCK_ByRef;
1044}

1046LambdaExpr::LambdaExpr(QualType T, SourceRange IntroducerRange,
                     LambdaCaptureDefault CaptureDefault,
                     SourceLocation CaptureDefaultLoc,
                     ArrayRef<LambdaCapture> Captures, bool ExplicitParams,
                     bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
                     SourceLocation ClosingBrace,
                     bool ContainsUnexpandedParameterPack)
  : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary, T->isDependentType(),
         T->isDependentType(), T->isDependentType(),
         ContainsUnexpandedParameterPack),
    IntroducerRange(IntroducerRange), CaptureDefaultLoc(CaptureDefaultLoc),
    NumCaptures(Captures.size()), CaptureDefault(CaptureDefault),
    ExplicitParams(ExplicitParams), ExplicitResultType(ExplicitResultType),
    ClosingBrace(ClosingBrace) {
assert(CaptureInits.size() == Captures.size() && "Wrong number of arguments")((CaptureInits.size() == Captures.size() && "Wrong number of arguments"
) ? static_cast<void> (0) : __assert_fail ("CaptureInits.size() == Captures.size() && \"Wrong number of arguments\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 1060, __PRETTY_FUNCTION__));
CXXRecordDecl *Class = getLambdaClass();
CXXRecordDecl::LambdaDefinitionData &Data = Class->getLambdaData();

// FIXME: Propagate "has unexpanded parameter pack" bit.

// Copy captures.
const ASTContext &Context = Class->getASTContext();
Data.NumCaptures = NumCaptures;
Data.NumExplicitCaptures = 0;
Data.Captures =
    (LambdaCapture *)Context.Allocate(sizeof(LambdaCapture) * NumCaptures);
LambdaCapture *ToCapture = Data.Captures;
for (unsigned I = 0, N = Captures.size(); I != N; ++I) {
  if (Captures[I].isExplicit())
    ++Data.NumExplicitCaptures;

  *ToCapture++ = Captures[I];
}

// Copy initialization expressions for the non-static data members.
Stmt **Stored = getStoredStmts();
for (unsigned I = 0, N = CaptureInits.size(); I != N; ++I)
  *Stored++ = CaptureInits[I];

// Copy the body of the lambda.
*Stored++ = getCallOperator()->getBody();
1087}

1089LambdaExpr *LambdaExpr::Create(
  const ASTContext &Context, CXXRecordDecl *Class,
  SourceRange IntroducerRange, LambdaCaptureDefault CaptureDefault,
  SourceLocation CaptureDefaultLoc, ArrayRef<LambdaCapture> Captures,
  bool ExplicitParams, bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
  SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack) {
// Determine the type of the expression (i.e., the type of the
// function object we're creating).
QualType T = Context.getTypeDeclType(Class);

unsigned Size = totalSizeToAlloc<Stmt *>(Captures.size() + 1);
void *Mem = Context.Allocate(Size);
return new (Mem)
    LambdaExpr(T, IntroducerRange, CaptureDefault, CaptureDefaultLoc,
               Captures, ExplicitParams, ExplicitResultType, CaptureInits,
               ClosingBrace, ContainsUnexpandedParameterPack);
1105}

1107LambdaExpr *LambdaExpr::CreateDeserialized(const ASTContext &C,
                                         unsigned NumCaptures) {
unsigned Size = totalSizeToAlloc<Stmt *>(NumCaptures + 1);
void *Mem = C.Allocate(Size);
return new (Mem) LambdaExpr(EmptyShell(), NumCaptures);
1112}

1114bool LambdaExpr::isInitCapture(const LambdaCapture *C) const {
return (C->capturesVariable() && C->getCapturedVar()->isInitCapture() &&
        (getCallOperator() == C->getCapturedVar()->getDeclContext()));
1117}

1119LambdaExpr::capture_iterator LambdaExpr::capture_begin() const {
return getLambdaClass()->getLambdaData().Captures;
1121}

1123LambdaExpr::capture_iterator LambdaExpr::capture_end() const {
return capture_begin() + NumCaptures;
1125}

1127LambdaExpr::capture_range LambdaExpr::captures() const {
return capture_range(capture_begin(), capture_end());
1129}

1131LambdaExpr::capture_iterator LambdaExpr::explicit_capture_begin() const {
return capture_begin();
1133}

1135LambdaExpr::capture_iterator LambdaExpr::explicit_capture_end() const {
struct CXXRecordDecl::LambdaDefinitionData &Data
  = getLambdaClass()->getLambdaData();
return Data.Captures + Data.NumExplicitCaptures;
1139}

1141LambdaExpr::capture_range LambdaExpr::explicit_captures() const {
return capture_range(explicit_capture_begin(), explicit_capture_end());
1143}

1145LambdaExpr::capture_iterator LambdaExpr::implicit_capture_begin() const {
return explicit_capture_end();
1147}

1149LambdaExpr::capture_iterator LambdaExpr::implicit_capture_end() const {
return capture_end();
1151}

1153LambdaExpr::capture_range LambdaExpr::implicit_captures() const {
return capture_range(implicit_capture_begin(), implicit_capture_end());
1155}

1157CXXRecordDecl *LambdaExpr::getLambdaClass() const {
return getType()->getAsCXXRecordDecl();
1159}

1161CXXMethodDecl *LambdaExpr::getCallOperator() const {
CXXRecordDecl *Record = getLambdaClass();
return Record->getLambdaCallOperator();
1164}

1166TemplateParameterList *LambdaExpr::getTemplateParameterList() const {
CXXRecordDecl *Record = getLambdaClass();
return Record->getGenericLambdaTemplateParameterList();

1170}

1172CompoundStmt *LambdaExpr::getBody() const {
// FIXME: this mutation in getBody is bogus. It should be
// initialized in ASTStmtReader::VisitLambdaExpr, but for reasons I
// don't understand, that doesn't work.
if (!getStoredStmts()[NumCaptures])
  *const_cast<Stmt **>(&getStoredStmts()[NumCaptures]) =
      getCallOperator()->getBody();

return static_cast<CompoundStmt *>(getStoredStmts()[NumCaptures]);
1181}

1183bool LambdaExpr::isMutable() const {
return !getCallOperator()->isConst();
1185}

1187ExprWithCleanups::ExprWithCleanups(Expr *subexpr,
                                 bool CleanupsHaveSideEffects,
                                 ArrayRef<CleanupObject> objects)
  : FullExpr(ExprWithCleanupsClass, subexpr) {
ExprWithCleanupsBits.CleanupsHaveSideEffects = CleanupsHaveSideEffects;
ExprWithCleanupsBits.NumObjects = objects.size();
for (unsigned i = 0, e = objects.size(); i != e; ++i)
  getTrailingObjects<CleanupObject>()[i] = objects[i];
1195}

1197ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, Expr *subexpr,
                                         bool CleanupsHaveSideEffects,
                                         ArrayRef<CleanupObject> objects) {
void *buffer = C.Allocate(totalSizeToAlloc<CleanupObject>(objects.size()),
                          alignof(ExprWithCleanups));
return new (buffer)
    ExprWithCleanups(subexpr, CleanupsHaveSideEffects, objects);
1204}

1206ExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects)
  : FullExpr(ExprWithCleanupsClass, empty) {
ExprWithCleanupsBits.NumObjects = numObjects;
1209}

1211ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C,
                                         EmptyShell empty,
                                         unsigned numObjects) {
void *buffer = C.Allocate(totalSizeToAlloc<CleanupObject>(numObjects),
                          alignof(ExprWithCleanups));
return new (buffer) ExprWithCleanups(empty, numObjects);
1217}

1219CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
                                               SourceLocation LParenLoc,
                                               ArrayRef<Expr*> Args,
                                               SourceLocation RParenLoc)
  : Expr(CXXUnresolvedConstructExprClass,
         Type->getType().getNonReferenceType(),
         (Type->getType()->isLValueReferenceType()
              ? VK_LValue
              : Type->getType()->isRValueReferenceType() ? VK_XValue
                                                         : VK_RValue),
         OK_Ordinary,
         Type->getType()->isDependentType() ||
             Type->getType()->getContainedDeducedType(),
         true, true, Type->getType()->containsUnexpandedParameterPack()),
    Type(Type), LParenLoc(LParenLoc), RParenLoc(RParenLoc),
    NumArgs(Args.size()) {
auto **StoredArgs = getTrailingObjects<Expr *>();
for (unsigned I = 0; I != Args.size(); ++I) {
  if (Args[I]->containsUnexpandedParameterPack())
    ExprBits.ContainsUnexpandedParameterPack = true;

  StoredArgs[I] = Args[I];
}
1242}

1244CXXUnresolvedConstructExpr *
1245CXXUnresolvedConstructExpr::Create(const ASTContext &C,
                                 TypeSourceInfo *Type,
                                 SourceLocation LParenLoc,
                                 ArrayRef<Expr*> Args,
                                 SourceLocation RParenLoc) {
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(Args.size()));
return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc, Args, RParenLoc);
1252}

1254CXXUnresolvedConstructExpr *
1255CXXUnresolvedConstructExpr::CreateEmpty(const ASTContext &C, unsigned NumArgs) {
Stmt::EmptyShell Empty;
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumArgs));
return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs);
1259}

1261SourceLocation CXXUnresolvedConstructExpr::getBeginLoc() const {
return Type->getTypeLoc().getBeginLoc();
1263}

1265CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
  const ASTContext &C, Expr *Base, QualType BaseType, bool IsArrow,
  SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
  SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
  DeclarationNameInfo MemberNameInfo,
  const TemplateArgumentListInfo *TemplateArgs)
  : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, VK_LValue,
         OK_Ordinary, true, true, true,
         ((Base && Base->containsUnexpandedParameterPack()) ||
          (QualifierLoc &&
           QualifierLoc.getNestedNameSpecifier()
               ->containsUnexpandedParameterPack()) ||
          MemberNameInfo.containsUnexpandedParameterPack())),
    Base(Base), BaseType(BaseType), IsArrow(IsArrow),
    HasTemplateKWAndArgsInfo(TemplateArgs != nullptr ||
                             TemplateKWLoc.isValid()),
    OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
    FirstQualifierFoundInScope(FirstQualifierFoundInScope),
    MemberNameInfo(MemberNameInfo) {
if (TemplateArgs) {
  bool Dependent = true;
  bool InstantiationDependent = true;
  bool ContainsUnexpandedParameterPack = false;
  getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
      TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
      Dependent, InstantiationDependent, ContainsUnexpandedParameterPack);
  if (ContainsUnexpandedParameterPack)
    ExprBits.ContainsUnexpandedParameterPack = true;
} else if (TemplateKWLoc.isValid()) {
  getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
      TemplateKWLoc);
}
1297}

1299CXXDependentScopeMemberExpr *
1300CXXDependentScopeMemberExpr::Create(const ASTContext &C,
                              Expr *Base, QualType BaseType, bool IsArrow,
                              SourceLocation OperatorLoc,
                              NestedNameSpecifierLoc QualifierLoc,
                              SourceLocation TemplateKWLoc,
                              NamedDecl *FirstQualifierFoundInScope,
                              DeclarationNameInfo MemberNameInfo,
                              const TemplateArgumentListInfo *TemplateArgs) {
bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid();
unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0;
std::size_t Size =
    totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
        HasTemplateKWAndArgsInfo, NumTemplateArgs);

void *Mem = C.Allocate(Size, alignof(CXXDependentScopeMemberExpr));
return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
                                             IsArrow, OperatorLoc,
                                             QualifierLoc,
                                             TemplateKWLoc,
                                             FirstQualifierFoundInScope,
                                             MemberNameInfo, TemplateArgs);
1321}

1323CXXDependentScopeMemberExpr *
1324CXXDependentScopeMemberExpr::CreateEmpty(const ASTContext &C,
                                       bool HasTemplateKWAndArgsInfo,
                                       unsigned NumTemplateArgs) {
assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo)((NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo) ? static_cast
<void> (0) : __assert_fail ("NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 1327, __PRETTY_FUNCTION__));
std::size_t Size =
    totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
        HasTemplateKWAndArgsInfo, NumTemplateArgs);
void *Mem = C.Allocate(Size, alignof(CXXDependentScopeMemberExpr));
auto *E =
    new (Mem) CXXDependentScopeMemberExpr(C, nullptr, QualType(),
                                          false, SourceLocation(),
                                          NestedNameSpecifierLoc(),
                                          SourceLocation(), nullptr,
                                          DeclarationNameInfo(), nullptr);
E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
return E;
1340}

1342bool CXXDependentScopeMemberExpr::isImplicitAccess() const {
if (!Base)
  return true;

return cast<Expr>(Base)->isImplicitCXXThis();
1347}

1349static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin,
                                          UnresolvedSetIterator end) {
do {
  NamedDecl *decl = *begin;
  if (isa<UnresolvedUsingValueDecl>(decl))
    return false;

  // Unresolved member expressions should only contain methods and
  // method templates.
  if (cast<CXXMethodDecl>(decl->getUnderlyingDecl()->getAsFunction())
          ->isStatic())
    return false;
} while (++begin != end);

return true;
1364}

1366UnresolvedMemberExpr::UnresolvedMemberExpr(const ASTContext &C,
                                         bool HasUnresolvedUsing,
                                         Expr *Base, QualType BaseType,
                                         bool IsArrow,
                                         SourceLocation OperatorLoc,
                                         NestedNameSpecifierLoc QualifierLoc,
                                         SourceLocation TemplateKWLoc,
                                 const DeclarationNameInfo &MemberNameInfo,
                                 const TemplateArgumentListInfo *TemplateArgs,
                                         UnresolvedSetIterator Begin,
                                         UnresolvedSetIterator End)
  : OverloadExpr(
        UnresolvedMemberExprClass, C, QualifierLoc, TemplateKWLoc,
        MemberNameInfo, TemplateArgs, Begin, End,
        // Dependent
        ((Base && Base->isTypeDependent()) || BaseType->isDependentType()),
        ((Base && Base->isInstantiationDependent()) ||
         BaseType->isInstantiationDependentType()),
        // Contains unexpanded parameter pack
        ((Base && Base->containsUnexpandedParameterPack()) ||
         BaseType->containsUnexpandedParameterPack())),
    IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing), Base(Base),
    BaseType(BaseType), OperatorLoc(OperatorLoc) {
// Check whether all of the members are non-static member functions,
// and if so, mark give this bound-member type instead of overload type.
if (hasOnlyNonStaticMemberFunctions(Begin, End))
  setType(C.BoundMemberTy);
1393}

1395bool UnresolvedMemberExpr::isImplicitAccess() const {
if (!Base)
  return true;

return cast<Expr>(Base)->isImplicitCXXThis();
1400}

1402UnresolvedMemberExpr *UnresolvedMemberExpr::Create(
  const ASTContext &C, bool HasUnresolvedUsing, Expr *Base, QualType BaseType,
  bool IsArrow, SourceLocation OperatorLoc,
  NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
  const DeclarationNameInfo &MemberNameInfo,
  const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin,
  UnresolvedSetIterator End) {
bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid();
std::size_t Size =
    totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
        HasTemplateKWAndArgsInfo, TemplateArgs ? TemplateArgs->size() : 0);

void *Mem = C.Allocate(Size, alignof(UnresolvedMemberExpr));
return new (Mem) UnresolvedMemberExpr(
    C, HasUnresolvedUsing, Base, BaseType, IsArrow, OperatorLoc, QualifierLoc,
    TemplateKWLoc, MemberNameInfo, TemplateArgs, Begin, End);
1418}

1420UnresolvedMemberExpr *
1421UnresolvedMemberExpr::CreateEmpty(const ASTContext &C,
                                bool HasTemplateKWAndArgsInfo,
                                unsigned NumTemplateArgs) {
assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo)((NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo) ? static_cast
<void> (0) : __assert_fail ("NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 1424, __PRETTY_FUNCTION__));
1
Assuming 'NumTemplateArgs' is equal to 0→
std::size_t Size =
    totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
        HasTemplateKWAndArgsInfo, NumTemplateArgs);

void *Mem = C.Allocate(Size, alignof(UnresolvedMemberExpr));
auto *E = new (Mem) UnresolvedMemberExpr(EmptyShell());
2
←
'E' initialized to a null pointer value→
E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
3
←
Access to field 'HasTemplateKWAndArgsInfo' results in a dereference of a null pointer (loaded from variable 'E')
return E;
1433}

1435CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
// Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.

// If there was a nested name specifier, it names the naming class.
// It can't be dependent: after all, we were actually able to do the
// lookup.
CXXRecordDecl *Record = nullptr;
auto *NNS = getQualifier();
if (NNS && NNS->getKind() != NestedNameSpecifier::Super) {
  const Type *T = getQualifier()->getAsType();
  assert(T && "qualifier in member expression does not name type")((T && "qualifier in member expression does not name type"
) ? static_cast<void> (0) : __assert_fail ("T && \"qualifier in member expression does not name type\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 1445, __PRETTY_FUNCTION__));
  Record = T->getAsCXXRecordDecl();
  assert(Record && "qualifier in member expression does not name record")((Record && "qualifier in member expression does not name record"
) ? static_cast<void> (0) : __assert_fail ("Record && \"qualifier in member expression does not name record\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 1447, __PRETTY_FUNCTION__));
}
// Otherwise the naming class must have been the base class.
else {
  QualType BaseType = getBaseType().getNonReferenceType();
  if (isArrow()) {
    const auto *PT = BaseType->getAs<PointerType>();
    assert(PT && "base of arrow member access is not pointer")((PT && "base of arrow member access is not pointer")
 ? static_cast<void> (0) : __assert_fail ("PT && \"base of arrow member access is not pointer\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 1454, __PRETTY_FUNCTION__));
    BaseType = PT->getPointeeType();
  }

  Record = BaseType->getAsCXXRecordDecl();
  assert(Record && "base of member expression does not name record")((Record && "base of member expression does not name record"
) ? static_cast<void> (0) : __assert_fail ("Record && \"base of member expression does not name record\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/AST/ExprCXX.cpp"
, 1459, __PRETTY_FUNCTION__));
}

return Record;
1463}

1465SizeOfPackExpr *
1466SizeOfPackExpr::Create(ASTContext &Context, SourceLocation OperatorLoc,
                     NamedDecl *Pack, SourceLocation PackLoc,
                     SourceLocation RParenLoc,
                     Optional<unsigned> Length,
                     ArrayRef<TemplateArgument> PartialArgs) {
void *Storage =
    Context.Allocate(totalSizeToAlloc<TemplateArgument>(PartialArgs.size()));
return new (Storage) SizeOfPackExpr(Context.getSizeType(), OperatorLoc, Pack,
                                    PackLoc, RParenLoc, Length, PartialArgs);
1475}

1477SizeOfPackExpr *SizeOfPackExpr::CreateDeserialized(ASTContext &Context,
                                                 unsigned NumPartialArgs) {
void *Storage =
    Context.Allocate(totalSizeToAlloc<TemplateArgument>(NumPartialArgs));
return new (Storage) SizeOfPackExpr(EmptyShell(), NumPartialArgs);
1482}

1484SubstNonTypeTemplateParmPackExpr::
1485SubstNonTypeTemplateParmPackExpr(QualType T,
                               ExprValueKind ValueKind,
                               NonTypeTemplateParmDecl *Param,
                               SourceLocation NameLoc,
                               const TemplateArgument &ArgPack)
  : Expr(SubstNonTypeTemplateParmPackExprClass, T, ValueKind, OK_Ordinary,
         true, true, true, true),
    Param(Param), Arguments(ArgPack.pack_begin()),
    NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) {}

1495TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
return TemplateArgument(llvm::makeArrayRef(Arguments, NumArguments));
1497}

1499FunctionParmPackExpr::FunctionParmPackExpr(QualType T, ParmVarDecl *ParamPack,
                                         SourceLocation NameLoc,
                                         unsigned NumParams,
                                         ParmVarDecl *const *Params)
  : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary, true, true,
         true, true),
    ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) {
if (Params)
  std::uninitialized_copy(Params, Params + NumParams,
                          getTrailingObjects<ParmVarDecl *>());
1509}

1511FunctionParmPackExpr *
1512FunctionParmPackExpr::Create(const ASTContext &Context, QualType T,
                           ParmVarDecl *ParamPack, SourceLocation NameLoc,
                           ArrayRef<ParmVarDecl *> Params) {
return new (Context.Allocate(totalSizeToAlloc<ParmVarDecl *>(Params.size())))
    FunctionParmPackExpr(T, ParamPack, NameLoc, Params.size(), Params.data());
1517}

1519FunctionParmPackExpr *
1520FunctionParmPackExpr::CreateEmpty(const ASTContext &Context,
                                unsigned NumParams) {
return new (Context.Allocate(totalSizeToAlloc<ParmVarDecl *>(NumParams)))
    FunctionParmPackExpr(QualType(), nullptr, SourceLocation(), 0, nullptr);
1524}

1526void MaterializeTemporaryExpr::setExtendingDecl(const ValueDecl *ExtendedBy,
                                              unsigned ManglingNumber) {
// We only need extra state if we have to remember more than just the Stmt.
if (!ExtendedBy)
  return;

// We may need to allocate extra storage for the mangling number and the
// extended-by ValueDecl.
if (!State.is<ExtraState *>()) {
  auto *ES = new (ExtendedBy->getASTContext()) ExtraState;
  ES->Temporary = State.get<Stmt *>();
  State = ES;
}

auto ES = State.get<ExtraState *>();
ES->ExtendingDecl = ExtendedBy;
ES->ManglingNumber = ManglingNumber;
1543}

1545TypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
                           ArrayRef<TypeSourceInfo *> Args,
                           SourceLocation RParenLoc,
                           bool Value)
  : Expr(TypeTraitExprClass, T, VK_RValue, OK_Ordinary,
         /*TypeDependent=*/false,
         /*ValueDependent=*/false,
         /*InstantiationDependent=*/false,
         /*ContainsUnexpandedParameterPack=*/false),
    Loc(Loc), RParenLoc(RParenLoc) {
TypeTraitExprBits.Kind = Kind;
TypeTraitExprBits.Value = Value;
TypeTraitExprBits.NumArgs = Args.size();

auto **ToArgs = getTrailingObjects<TypeSourceInfo *>();

for (unsigned I = 0, N = Args.size(); I != N; ++I) {
  if (Args[I]->getType()->isDependentType())
    setValueDependent(true);
  if (Args[I]->getType()->isInstantiationDependentType())
    setInstantiationDependent(true);
  if (Args[I]->getType()->containsUnexpandedParameterPack())
    setContainsUnexpandedParameterPack(true);

  ToArgs[I] = Args[I];
}
1571}

1573TypeTraitExpr *TypeTraitExpr::Create(const ASTContext &C, QualType T,
                                   SourceLocation Loc,
                                   TypeTrait Kind,
                                   ArrayRef<TypeSourceInfo *> Args,
                                   SourceLocation RParenLoc,
                                   bool Value) {
void *Mem = C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(Args.size()));
return new (Mem) TypeTraitExpr(T, Loc, Kind, Args, RParenLoc, Value);
1581}

1583TypeTraitExpr *TypeTraitExpr::CreateDeserialized(const ASTContext &C,
                                               unsigned NumArgs) {
void *Mem = C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(NumArgs));
return new (Mem) TypeTraitExpr(EmptyShell());
1587}

1589CUDAKernelCallExpr::CUDAKernelCallExpr(Expr *Fn, CallExpr *Config,
                                     ArrayRef<Expr *> Args, QualType Ty,
                                     ExprValueKind VK, SourceLocation RP,
                                     unsigned MinNumArgs)
  : CallExpr(CUDAKernelCallExprClass, Fn, /*PreArgs=*/Config, Args, Ty, VK,
             RP, MinNumArgs, NotADL) {}

1596CUDAKernelCallExpr::CUDAKernelCallExpr(unsigned NumArgs, EmptyShell Empty)
  : CallExpr(CUDAKernelCallExprClass, /*NumPreArgs=*/END_PREARG, NumArgs,
             Empty) {}

1600CUDAKernelCallExpr *
1601CUDAKernelCallExpr::Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config,
                         ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
                         SourceLocation RP, unsigned MinNumArgs) {
// Allocate storage for the trailing objects of CallExpr.
unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
unsigned SizeOfTrailingObjects =
    CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/END_PREARG, NumArgs);
void *Mem = Ctx.Allocate(sizeof(CUDAKernelCallExpr) + SizeOfTrailingObjects,
                         alignof(CUDAKernelCallExpr));
return new (Mem) CUDAKernelCallExpr(Fn, Config, Args, Ty, VK, RP, MinNumArgs);
1611}

1613CUDAKernelCallExpr *CUDAKernelCallExpr::CreateEmpty(const ASTContext &Ctx,
                                                  unsigned NumArgs,
                                                  EmptyShell Empty) {
// Allocate storage for the trailing objects of CallExpr.
unsigned SizeOfTrailingObjects =
    CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/END_PREARG, NumArgs);
void *Mem = Ctx.Allocate(sizeof(CUDAKernelCallExpr) + SizeOfTrailingObjects,
                         alignof(CUDAKernelCallExpr));
return new (Mem) CUDAKernelCallExpr(NumArgs, Empty);
1622}