/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h

Bug Summary

File:	tools/clang/include/clang/AST/Expr.h
Warning:	line 4591, column 48 Called C++ object pointer is null

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 ASTImporter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -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-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/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-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/AST -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -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-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp -faddrsig

/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp

→

1//===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===//
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 defines the ASTImporter class which imports AST nodes from one
11//  context into another context.
12//
13//===----------------------------------------------------------------------===//

15#include "clang/AST/ASTImporter.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/ASTDiagnostic.h"
18#include "clang/AST/ASTStructuralEquivalence.h"
19#include "clang/AST/Attr.h"
20#include "clang/AST/Decl.h"
21#include "clang/AST/DeclAccessPair.h"
22#include "clang/AST/DeclBase.h"
23#include "clang/AST/DeclCXX.h"
24#include "clang/AST/DeclFriend.h"
25#include "clang/AST/DeclGroup.h"
26#include "clang/AST/DeclObjC.h"
27#include "clang/AST/DeclTemplate.h"
28#include "clang/AST/DeclVisitor.h"
29#include "clang/AST/DeclarationName.h"
30#include "clang/AST/Expr.h"
31#include "clang/AST/ExprCXX.h"
32#include "clang/AST/ExprObjC.h"
33#include "clang/AST/ExternalASTSource.h"
34#include "clang/AST/LambdaCapture.h"
35#include "clang/AST/NestedNameSpecifier.h"
36#include "clang/AST/OperationKinds.h"
37#include "clang/AST/Stmt.h"
38#include "clang/AST/StmtCXX.h"
39#include "clang/AST/StmtObjC.h"
40#include "clang/AST/StmtVisitor.h"
41#include "clang/AST/TemplateBase.h"
42#include "clang/AST/TemplateName.h"
43#include "clang/AST/Type.h"
44#include "clang/AST/TypeLoc.h"
45#include "clang/AST/TypeVisitor.h"
46#include "clang/AST/UnresolvedSet.h"
47#include "clang/Basic/ExceptionSpecificationType.h"
48#include "clang/Basic/FileManager.h"
49#include "clang/Basic/IdentifierTable.h"
50#include "clang/Basic/LLVM.h"
51#include "clang/Basic/LangOptions.h"
52#include "clang/Basic/SourceLocation.h"
53#include "clang/Basic/SourceManager.h"
54#include "clang/Basic/Specifiers.h"
55#include "llvm/ADT/APSInt.h"
56#include "llvm/ADT/ArrayRef.h"
57#include "llvm/ADT/DenseMap.h"
58#include "llvm/ADT/None.h"
59#include "llvm/ADT/Optional.h"
60#include "llvm/ADT/STLExtras.h"
61#include "llvm/ADT/SmallVector.h"
62#include "llvm/Support/Casting.h"
63#include "llvm/Support/ErrorHandling.h"
64#include "llvm/Support/MemoryBuffer.h"
65#include <algorithm>
66#include <cassert>
67#include <cstddef>
68#include <memory>
69#include <type_traits>
70#include <utility>

72namespace clang {

template <class T>
SmallVector<Decl*, 2>
getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
  SmallVector<Decl*, 2> Redecls;
  for (auto *R : D->getFirstDecl()->redecls()) {
    if (R != D->getFirstDecl())
      Redecls.push_back(R);
  }
  Redecls.push_back(D->getFirstDecl());
  std::reverse(Redecls.begin(), Redecls.end());
  return Redecls;
}

SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
  // Currently only FunctionDecl is supported
  auto FD = cast<FunctionDecl>(D);
  return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
}

void updateFlags(const Decl *From, Decl *To) {
  // Check if some flags or attrs are new in 'From' and copy into 'To'.
  // FIXME: Other flags or attrs?
  if (From->isUsed(false) && !To->isUsed(false))
    To->setIsUsed();
}

class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
                        public DeclVisitor<ASTNodeImporter, Decl *>,
                        public StmtVisitor<ASTNodeImporter, Stmt *> {
  ASTImporter &Importer;

  // Wrapper for an overload set.
  template <typename ToDeclT> struct CallOverloadedCreateFun {
    template <typename... Args>
    auto operator()(Args &&... args)
        -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
      return ToDeclT::Create(std::forward<Args>(args)...);
    }
  };

  // Always use these functions to create a Decl during import. There are
  // certain tasks which must be done after the Decl was created, e.g. we
  // must immediately register that as an imported Decl.  The parameter `ToD`
  // will be set to the newly created Decl or if had been imported before
  // then to the already imported Decl.  Returns a bool value set to true if
  // the `FromD` had been imported before.
  template <typename ToDeclT, typename FromDeclT, typename... Args>
  LLVM_NODISCARD[[clang::warn_unused_result]] bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
                                              Args &&... args) {
    // There may be several overloads of ToDeclT::Create. We must make sure
    // to call the one which would be chosen by the arguments, thus we use a
    // wrapper for the overload set.
    CallOverloadedCreateFun<ToDeclT> OC;
    return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
                                          std::forward<Args>(args)...);
  }
  // Use this overload if a special Type is needed to be created.  E.g if we
  // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
  // then:
  // TypedefNameDecl *ToTypedef;
  // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
  template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
            typename... Args>
  LLVM_NODISCARD[[clang::warn_unused_result]] bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
                                              Args &&... args) {
    CallOverloadedCreateFun<NewDeclT> OC;
    return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
                                          std::forward<Args>(args)...);
  }
  // Use this version if a special create function must be
  // used, e.g. CXXRecordDecl::CreateLambda .
  template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
            typename... Args>
  LLVM_NODISCARD[[clang::warn_unused_result]] bool
  GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
                                 FromDeclT *FromD, Args &&... args) {
    ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
    if (ToD)
      return true; // Already imported.
    ToD = CreateFun(std::forward<Args>(args)...);
    InitializeImportedDecl(FromD, ToD);
    return false; // A new Decl is created.
  }

  void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
    Importer.MapImported(FromD, ToD);
    ToD->IdentifierNamespace = FromD->IdentifierNamespace;
    if (FromD->hasAttrs())
      for (const Attr *FromAttr : FromD->getAttrs())
        ToD->addAttr(Importer.Import(FromAttr));
    if (FromD->isUsed())
      ToD->setIsUsed();
    if (FromD->isImplicit())
      ToD->setImplicit();
  }

public:
  explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}

  using TypeVisitor<ASTNodeImporter, QualType>::Visit;
  using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
  using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;

  // Importing types
  QualType VisitType(const Type *T);
  QualType VisitAtomicType(const AtomicType *T);
  QualType VisitBuiltinType(const BuiltinType *T);
  QualType VisitDecayedType(const DecayedType *T);
  QualType VisitComplexType(const ComplexType *T);
  QualType VisitPointerType(const PointerType *T);
  QualType VisitBlockPointerType(const BlockPointerType *T);
  QualType VisitLValueReferenceType(const LValueReferenceType *T);
  QualType VisitRValueReferenceType(const RValueReferenceType *T);
  QualType VisitMemberPointerType(const MemberPointerType *T);
  QualType VisitConstantArrayType(const ConstantArrayType *T);
  QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
  QualType VisitVariableArrayType(const VariableArrayType *T);
  QualType VisitDependentSizedArrayType(const DependentSizedArrayType *T);
  // FIXME: DependentSizedExtVectorType
  QualType VisitVectorType(const VectorType *T);
  QualType VisitExtVectorType(const ExtVectorType *T);
  QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
  QualType VisitFunctionProtoType(const FunctionProtoType *T);
  QualType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
  QualType VisitParenType(const ParenType *T);
  QualType VisitTypedefType(const TypedefType *T);
  QualType VisitTypeOfExprType(const TypeOfExprType *T);
  // FIXME: DependentTypeOfExprType
  QualType VisitTypeOfType(const TypeOfType *T);
  QualType VisitDecltypeType(const DecltypeType *T);
  QualType VisitUnaryTransformType(const UnaryTransformType *T);
  QualType VisitAutoType(const AutoType *T);
  QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
  // FIXME: DependentDecltypeType
  QualType VisitRecordType(const RecordType *T);
  QualType VisitEnumType(const EnumType *T);
  QualType VisitAttributedType(const AttributedType *T);
  QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
  QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T);
  QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
  QualType VisitElaboratedType(const ElaboratedType *T);
  QualType VisitDependentNameType(const DependentNameType *T);
  QualType VisitPackExpansionType(const PackExpansionType *T);
  QualType VisitDependentTemplateSpecializationType(
      const DependentTemplateSpecializationType *T);
  QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
  QualType VisitObjCObjectType(const ObjCObjectType *T);
  QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);

  // Importing declarations
  bool ImportDeclParts(NamedDecl *D, DeclContext *&DC, 
                       DeclContext *&LexicalDC, DeclarationName &Name, 
                       NamedDecl *&ToD, SourceLocation &Loc);
  void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
  void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
                                DeclarationNameInfo& To);
  void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
  void ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);

  bool ImportCastPath(CastExpr *E, CXXCastPath &Path);

  using Designator = DesignatedInitExpr::Designator;

  Designator ImportDesignator(const Designator &D);

  Optional<LambdaCapture> ImportLambdaCapture(const LambdaCapture &From);
                      
  /// What we should import from the definition.
  enum ImportDefinitionKind { 
    /// Import the default subset of the definition, which might be
    /// nothing (if minimal import is set) or might be everything (if minimal
    /// import is not set).
    IDK_Default,

    /// Import everything.
    IDK_Everything,

    /// Import only the bare bones needed to establish a valid
    /// DeclContext.
    IDK_Basic
  };

  bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
    return IDK == IDK_Everything ||
           (IDK == IDK_Default && !Importer.isMinimalImport());
  }

  bool ImportDefinition(RecordDecl *From, RecordDecl *To, 
                        ImportDefinitionKind Kind = IDK_Default);
  bool ImportDefinition(VarDecl *From, VarDecl *To,
                        ImportDefinitionKind Kind = IDK_Default);
  bool ImportDefinition(EnumDecl *From, EnumDecl *To,
                        ImportDefinitionKind Kind = IDK_Default);
  bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
                        ImportDefinitionKind Kind = IDK_Default);
  bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
                        ImportDefinitionKind Kind = IDK_Default);
  TemplateParameterList *ImportTemplateParameterList(
      TemplateParameterList *Params);
  TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
  Optional<TemplateArgumentLoc> ImportTemplateArgumentLoc(
      const TemplateArgumentLoc &TALoc);
  bool ImportTemplateArguments(const TemplateArgument *FromArgs,
                               unsigned NumFromArgs,
                               SmallVectorImpl<TemplateArgument> &ToArgs);

  template <typename InContainerTy>
  bool ImportTemplateArgumentListInfo(const InContainerTy &Container,
                                      TemplateArgumentListInfo &ToTAInfo);

  template<typename InContainerTy>
  bool ImportTemplateArgumentListInfo(SourceLocation FromLAngleLoc,
                                      SourceLocation FromRAngleLoc,
                                      const InContainerTy &Container,
                                      TemplateArgumentListInfo &Result);

  using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
  using OptionalTemplateArgsTy = Optional<TemplateArgsTy>;
  std::tuple<FunctionTemplateDecl *, OptionalTemplateArgsTy>
  ImportFunctionTemplateWithTemplateArgsFromSpecialization(
      FunctionDecl *FromFD);

  bool ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD);

  bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
  bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
                         bool Complain = true);
  bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
                         bool Complain = true);
  bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
  bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
  bool IsStructuralMatch(FunctionTemplateDecl *From,
                         FunctionTemplateDecl *To);
  bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
  bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
  bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
  Decl *VisitDecl(Decl *D);
  Decl *VisitEmptyDecl(EmptyDecl *D);
  Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
  Decl *VisitStaticAssertDecl(StaticAssertDecl *D);
  Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
  Decl *VisitNamespaceDecl(NamespaceDecl *D);
  Decl *VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
  Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
  Decl *VisitTypedefDecl(TypedefDecl *D);
  Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
  Decl *VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
  Decl *VisitLabelDecl(LabelDecl *D);
  Decl *VisitEnumDecl(EnumDecl *D);
  Decl *VisitRecordDecl(RecordDecl *D);
  Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
  Decl *VisitFunctionDecl(FunctionDecl *D);
  Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
  Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
  Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
  Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
  Decl *VisitFieldDecl(FieldDecl *D);
  Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
  Decl *VisitFriendDecl(FriendDecl *D);
  Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
  Decl *VisitVarDecl(VarDecl *D);
  Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
  Decl *VisitParmVarDecl(ParmVarDecl *D);
  Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
  Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
  Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
  Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
  Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
  Decl *VisitUsingDecl(UsingDecl *D);
  Decl *VisitUsingShadowDecl(UsingShadowDecl *D);
  Decl *VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
  Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
  Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);

  ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
  Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
  Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
  Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
  Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
  Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
  Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
  Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
  Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
  Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
  Decl *VisitClassTemplateSpecializationDecl(
                                          ClassTemplateSpecializationDecl *D);
  Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
  Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
  Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *D);

  // Importing statements
  DeclGroupRef ImportDeclGroup(DeclGroupRef DG);

  Stmt *VisitStmt(Stmt *S);
  Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
  Stmt *VisitDeclStmt(DeclStmt *S);
  Stmt *VisitNullStmt(NullStmt *S);
  Stmt *VisitCompoundStmt(CompoundStmt *S);
  Stmt *VisitCaseStmt(CaseStmt *S);
  Stmt *VisitDefaultStmt(DefaultStmt *S);
  Stmt *VisitLabelStmt(LabelStmt *S);
  Stmt *VisitAttributedStmt(AttributedStmt *S);
  Stmt *VisitIfStmt(IfStmt *S);
  Stmt *VisitSwitchStmt(SwitchStmt *S);
  Stmt *VisitWhileStmt(WhileStmt *S);
  Stmt *VisitDoStmt(DoStmt *S);
  Stmt *VisitForStmt(ForStmt *S);
  Stmt *VisitGotoStmt(GotoStmt *S);
  Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
  Stmt *VisitContinueStmt(ContinueStmt *S);
  Stmt *VisitBreakStmt(BreakStmt *S);
  Stmt *VisitReturnStmt(ReturnStmt *S);
  // FIXME: MSAsmStmt
  // FIXME: SEHExceptStmt
  // FIXME: SEHFinallyStmt
  // FIXME: SEHTryStmt
  // FIXME: SEHLeaveStmt
  // FIXME: CapturedStmt
  Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
  Stmt *VisitCXXTryStmt(CXXTryStmt *S);
  Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
  // FIXME: MSDependentExistsStmt
  Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
  Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
  Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
  Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
  Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
  Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
  Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);

  // Importing expressions
  Expr *VisitExpr(Expr *E);
  Expr *VisitVAArgExpr(VAArgExpr *E);
  Expr *VisitGNUNullExpr(GNUNullExpr *E);
  Expr *VisitPredefinedExpr(PredefinedExpr *E);
  Expr *VisitDeclRefExpr(DeclRefExpr *E);
  Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE);
  Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
  Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
  Expr *VisitIntegerLiteral(IntegerLiteral *E);
  Expr *VisitFloatingLiteral(FloatingLiteral *E);
  Expr *VisitCharacterLiteral(CharacterLiteral *E);
  Expr *VisitStringLiteral(StringLiteral *E);
  Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
  Expr *VisitAtomicExpr(AtomicExpr *E);
  Expr *VisitAddrLabelExpr(AddrLabelExpr *E);
  Expr *VisitParenExpr(ParenExpr *E);
  Expr *VisitParenListExpr(ParenListExpr *E);
  Expr *VisitStmtExpr(StmtExpr *E);
  Expr *VisitUnaryOperator(UnaryOperator *E);
  Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
  Expr *VisitBinaryOperator(BinaryOperator *E);
  Expr *VisitConditionalOperator(ConditionalOperator *E);
  Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
  Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
  Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
  Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E);
  Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
  Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
  Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
  Expr *VisitExplicitCastExpr(ExplicitCastExpr *E);
  Expr *VisitOffsetOfExpr(OffsetOfExpr *OE);
  Expr *VisitCXXThrowExpr(CXXThrowExpr *E);
  Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
  Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
  Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
  Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
  Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE);
  Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
  Expr *VisitPackExpansionExpr(PackExpansionExpr *E);
  Expr *VisitSizeOfPackExpr(SizeOfPackExpr *E);
  Expr *VisitCXXNewExpr(CXXNewExpr *CE);
  Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
  Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
  Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
  Expr *VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
  Expr *VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
  Expr *VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *CE);
  Expr *VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
  Expr *VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
  Expr *VisitExprWithCleanups(ExprWithCleanups *EWC);
  Expr *VisitCXXThisExpr(CXXThisExpr *E);
  Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
  Expr *VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
  Expr *VisitMemberExpr(MemberExpr *E);
  Expr *VisitCallExpr(CallExpr *E);
  Expr *VisitLambdaExpr(LambdaExpr *LE);
  Expr *VisitInitListExpr(InitListExpr *E);
  Expr *VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
  Expr *VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E);
  Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
  Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
  Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
  Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
  Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
  Expr *VisitTypeTraitExpr(TypeTraitExpr *E);
  Expr *VisitCXXTypeidExpr(CXXTypeidExpr *E);

  template<typename IIter, typename OIter>
  void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
    using ItemT = typename std::remove_reference<decltype(*Obegin)>::type;

    ASTImporter &ImporterRef = Importer;
    std::transform(Ibegin, Iend, Obegin,
                   [&ImporterRef](ItemT From) -> ItemT {
                     return ImporterRef.Import(From);
                   });
  }

  template<typename IIter, typename OIter>
  bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
    using ItemT = typename std::remove_reference<decltype(**Obegin)>::type;

    ASTImporter &ImporterRef = Importer;
    bool Failed = false;
    std::transform(Ibegin, Iend, Obegin,
                   [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
                     auto *To = cast_or_null<ItemT>(ImporterRef.Import(From));
                     if (!To && From)
                       Failed = true;
                     return To;
                   });
    return Failed;
  }

  template<typename InContainerTy, typename OutContainerTy>
  bool ImportContainerChecked(const InContainerTy &InContainer,
                              OutContainerTy &OutContainer) {
    return ImportArrayChecked(InContainer.begin(), InContainer.end(),
                              OutContainer.begin());
  }

  template<typename InContainerTy, typename OIter>
  bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
    return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
  }

  // Importing overrides.
  void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod);

  FunctionDecl *FindFunctionTemplateSpecialization(FunctionDecl *FromFD);
};

517template <typename InContainerTy>
518bool ASTNodeImporter::ImportTemplateArgumentListInfo(
  SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
  const InContainerTy &Container, TemplateArgumentListInfo &Result) {
TemplateArgumentListInfo ToTAInfo(Importer.Import(FromLAngleLoc),
                                  Importer.Import(FromRAngleLoc));
if (ImportTemplateArgumentListInfo(Container, ToTAInfo))
  return true;
Result = ToTAInfo;
return false;
527}

529template <>
530bool ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
  const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
return ImportTemplateArgumentListInfo(
    From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
534}

536template <>
537bool ASTNodeImporter::ImportTemplateArgumentListInfo<
  ASTTemplateArgumentListInfo>(const ASTTemplateArgumentListInfo &From,
                               TemplateArgumentListInfo &Result) {
return ImportTemplateArgumentListInfo(From.LAngleLoc, From.RAngleLoc,
                                      From.arguments(), Result);
542}

544std::tuple<FunctionTemplateDecl *, ASTNodeImporter::OptionalTemplateArgsTy>
545ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
  FunctionDecl *FromFD) {
assert(FromFD->getTemplatedKind() ==(static_cast <bool> (FromFD->getTemplatedKind() == FunctionDecl
::TK_FunctionTemplateSpecialization) ? void (0) : __assert_fail
 ("FromFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplateSpecialization"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 548, __extension__ __PRETTY_FUNCTION__))
       FunctionDecl::TK_FunctionTemplateSpecialization)(static_cast <bool> (FromFD->getTemplatedKind() == FunctionDecl
::TK_FunctionTemplateSpecialization) ? void (0) : __assert_fail
 ("FromFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplateSpecialization"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 548, __extension__ __PRETTY_FUNCTION__));
auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
auto *Template = cast_or_null<FunctionTemplateDecl>(
    Importer.Import(FTSInfo->getTemplate()));

// Import template arguments.
auto TemplArgs = FTSInfo->TemplateArguments->asArray();
TemplateArgsTy ToTemplArgs;
if (ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
                            ToTemplArgs)) // Error during import.
  return std::make_tuple(Template, OptionalTemplateArgsTy());

return std::make_tuple(Template, ToTemplArgs);
561}

563} // namespace clang

565//----------------------------------------------------------------------------
566// Import Types
567//----------------------------------------------------------------------------

569using namespace clang;

571QualType ASTNodeImporter::VisitType(const Type *T) {
Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
  << T->getTypeClassName();
return {};
575}

577QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
QualType UnderlyingType = Importer.Import(T->getValueType());
if(UnderlyingType.isNull())
  return {};

return Importer.getToContext().getAtomicType(UnderlyingType);
583}

585QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
switch (T->getKind()) {
587#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id: \
  return Importer.getToContext().SingletonId;
590#include "clang/Basic/OpenCLImageTypes.def"
591#define SHARED_SINGLETON_TYPE(Expansion)
592#define BUILTIN_TYPE(Id, SingletonId) \
case BuiltinType::Id: return Importer.getToContext().SingletonId;
594#include "clang/AST/BuiltinTypes.def"

// FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
// context supports C++.

// FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
// context supports ObjC.

case BuiltinType::Char_U:
  // The context we're importing from has an unsigned 'char'. If we're 
  // importing into a context with a signed 'char', translate to 
  // 'unsigned char' instead.
  if (Importer.getToContext().getLangOpts().CharIsSigned)
    return Importer.getToContext().UnsignedCharTy;
  
  return Importer.getToContext().CharTy;

case BuiltinType::Char_S:
  // The context we're importing from has an unsigned 'char'. If we're 
  // importing into a context with a signed 'char', translate to 
  // 'unsigned char' instead.
  if (!Importer.getToContext().getLangOpts().CharIsSigned)
    return Importer.getToContext().SignedCharTy;
  
  return Importer.getToContext().CharTy;

case BuiltinType::WChar_S:
case BuiltinType::WChar_U:
  // FIXME: If not in C++, shall we translate to the C equivalent of
  // wchar_t?
  return Importer.getToContext().WCharTy;
}

llvm_unreachable("Invalid BuiltinType Kind!")::llvm::llvm_unreachable_internal("Invalid BuiltinType Kind!"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 627);
628}

630QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
QualType OrigT = Importer.Import(T->getOriginalType());
if (OrigT.isNull())
  return {};

return Importer.getToContext().getDecayedType(OrigT);
636}

638QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
  return {};

return Importer.getToContext().getComplexType(ToElementType);
644}

646QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
QualType ToPointeeType = Importer.Import(T->getPointeeType());
if (ToPointeeType.isNull())
  return {};

return Importer.getToContext().getPointerType(ToPointeeType);
652}

654QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
// FIXME: Check for blocks support in "to" context.
QualType ToPointeeType = Importer.Import(T->getPointeeType());
if (ToPointeeType.isNull())
  return {};

return Importer.getToContext().getBlockPointerType(ToPointeeType);
661}

663QualType
664ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
// FIXME: Check for C++ support in "to" context.
QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
if (ToPointeeType.isNull())
  return {};

return Importer.getToContext().getLValueReferenceType(ToPointeeType);
671}

673QualType
674ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
// FIXME: Check for C++0x support in "to" context.
QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
if (ToPointeeType.isNull())
  return {};

return Importer.getToContext().getRValueReferenceType(ToPointeeType);  
681}

683QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
// FIXME: Check for C++ support in "to" context.
QualType ToPointeeType = Importer.Import(T->getPointeeType());
if (ToPointeeType.isNull())
  return {};

QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
return Importer.getToContext().getMemberPointerType(ToPointeeType, 
                                                    ClassType.getTypePtr());
692}

694QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
  return {};

return Importer.getToContext().getConstantArrayType(ToElementType, 
                                                    T->getSize(),
                                                    T->getSizeModifier(),
                                             T->getIndexTypeCVRQualifiers());
703}

705QualType
706ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
  return {};

return Importer.getToContext().getIncompleteArrayType(ToElementType, 
                                                      T->getSizeModifier(),
                                              T->getIndexTypeCVRQualifiers());
714}

716QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
  return {};

Expr *Size = Importer.Import(T->getSizeExpr());
if (!Size)
  return {};

SourceRange Brackets = Importer.Import(T->getBracketsRange());
return Importer.getToContext().getVariableArrayType(ToElementType, Size,
                                                    T->getSizeModifier(),
                                              T->getIndexTypeCVRQualifiers(),
                                                    Brackets);
730}

732QualType ASTNodeImporter::VisitDependentSizedArrayType(
  const DependentSizedArrayType *T) {
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
  return {};

// SizeExpr may be null if size is not specified directly.
// For example, 'int a[]'.
Expr *Size = Importer.Import(T->getSizeExpr());
if (!Size && T->getSizeExpr())
  return {};

SourceRange Brackets = Importer.Import(T->getBracketsRange());
return Importer.getToContext().getDependentSizedArrayType(
    ToElementType, Size, T->getSizeModifier(), T->getIndexTypeCVRQualifiers(),
    Brackets);
748}

750QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
  return {};

return Importer.getToContext().getVectorType(ToElementType, 
                                             T->getNumElements(),
                                             T->getVectorKind());
758}

760QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
QualType ToElementType = Importer.Import(T->getElementType());
if (ToElementType.isNull())
  return {};

return Importer.getToContext().getExtVectorType(ToElementType, 
                                                T->getNumElements());
767}

769QualType
770ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
// FIXME: What happens if we're importing a function without a prototype 
// into C++? Should we make it variadic?
QualType ToResultType = Importer.Import(T->getReturnType());
if (ToResultType.isNull())
  return {};

return Importer.getToContext().getFunctionNoProtoType(ToResultType,
                                                      T->getExtInfo());
779}

781QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
QualType ToResultType = Importer.Import(T->getReturnType());
if (ToResultType.isNull())
  return {};

// Import argument types
SmallVector<QualType, 4> ArgTypes;
for (const auto &A : T->param_types()) {
  QualType ArgType = Importer.Import(A);
  if (ArgType.isNull())
    return {};
  ArgTypes.push_back(ArgType);
}

// Import exception types
SmallVector<QualType, 4> ExceptionTypes;
for (const auto &E : T->exceptions()) {
  QualType ExceptionType = Importer.Import(E);
  if (ExceptionType.isNull())
    return {};
  ExceptionTypes.push_back(ExceptionType);
}

FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
FunctionProtoType::ExtProtoInfo ToEPI;

ToEPI.ExtInfo = FromEPI.ExtInfo;
ToEPI.Variadic = FromEPI.Variadic;
ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
ToEPI.TypeQuals = FromEPI.TypeQuals;
ToEPI.RefQualifier = FromEPI.RefQualifier;
ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
ToEPI.ExceptionSpec.NoexceptExpr =
    Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
    Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
    Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));

return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
822}

824QualType ASTNodeImporter::VisitUnresolvedUsingType(
  const UnresolvedUsingType *T) {
const auto *ToD =
    cast_or_null<UnresolvedUsingTypenameDecl>(Importer.Import(T->getDecl()));
if (!ToD)
  return {};

auto *ToPrevD =
    cast_or_null<UnresolvedUsingTypenameDecl>(
      Importer.Import(T->getDecl()->getPreviousDecl()));
if (!ToPrevD && T->getDecl()->getPreviousDecl())
  return {};

return Importer.getToContext().getTypeDeclType(ToD, ToPrevD);
838}

840QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
QualType ToInnerType = Importer.Import(T->getInnerType());
if (ToInnerType.isNull())
  return {};
  
return Importer.getToContext().getParenType(ToInnerType);
846}

848QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
auto *ToDecl =
    dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
if (!ToDecl)
  return {};

return Importer.getToContext().getTypeDeclType(ToDecl);
855}

857QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
if (!ToExpr)
  return {};

return Importer.getToContext().getTypeOfExprType(ToExpr);
863}

865QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
if (ToUnderlyingType.isNull())
  return {};

return Importer.getToContext().getTypeOfType(ToUnderlyingType);
871}

873QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
// FIXME: Make sure that the "to" context supports C++0x!
Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
if (!ToExpr)
  return {};

QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
if (UnderlyingType.isNull())
  return {};

return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
884}

886QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
QualType ToBaseType = Importer.Import(T->getBaseType());
QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
if (ToBaseType.isNull() || ToUnderlyingType.isNull())
  return {};

return Importer.getToContext().getUnaryTransformType(ToBaseType,
                                                     ToUnderlyingType,
                                                     T->getUTTKind());
895}

897QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
// FIXME: Make sure that the "to" context supports C++11!
QualType FromDeduced = T->getDeducedType();
QualType ToDeduced;
if (!FromDeduced.isNull()) {
  ToDeduced = Importer.Import(FromDeduced);
  if (ToDeduced.isNull())
    return {};
}

return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
                                           /*IsDependent*/false);
909}

911QualType ASTNodeImporter::VisitInjectedClassNameType(
  const InjectedClassNameType *T) {
auto *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
if (!D)
  return {};

QualType InjType = Importer.Import(T->getInjectedSpecializationType());
if (InjType.isNull())
  return {};

// FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
// See comments in InjectedClassNameType definition for details
// return Importer.getToContext().getInjectedClassNameType(D, InjType);
enum {
  TypeAlignmentInBits = 4,
  TypeAlignment = 1 << TypeAlignmentInBits
};

return QualType(new (Importer.getToContext(), TypeAlignment)
                InjectedClassNameType(D, InjType), 0);
931}

933QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
auto *ToDecl = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
if (!ToDecl)
  return {};

return Importer.getToContext().getTagDeclType(ToDecl);
939}

941QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
auto *ToDecl = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
if (!ToDecl)
  return {};

return Importer.getToContext().getTagDeclType(ToDecl);
947}

949QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
QualType FromModifiedType = T->getModifiedType();
QualType FromEquivalentType = T->getEquivalentType();
QualType ToModifiedType;
QualType ToEquivalentType;

if (!FromModifiedType.isNull()) {
  ToModifiedType = Importer.Import(FromModifiedType);
  if (ToModifiedType.isNull())
    return {};
}
if (!FromEquivalentType.isNull()) {
  ToEquivalentType = Importer.Import(FromEquivalentType);
  if (ToEquivalentType.isNull())
    return {};
}

return Importer.getToContext().getAttributedType(T->getAttrKind(),
  ToModifiedType, ToEquivalentType);
968}

970QualType ASTNodeImporter::VisitTemplateTypeParmType(
  const TemplateTypeParmType *T) {
auto *ParmDecl =
    cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
if (!ParmDecl && T->getDecl())
  return {};

return Importer.getToContext().getTemplateTypeParmType(
      T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
979}

981QualType ASTNodeImporter::VisitSubstTemplateTypeParmType(
  const SubstTemplateTypeParmType *T) {
const auto *Replaced =
    cast_or_null<TemplateTypeParmType>(Importer.Import(
      QualType(T->getReplacedParameter(), 0)).getTypePtr());
if (!Replaced)
  return {};

QualType Replacement = Importer.Import(T->getReplacementType());
if (Replacement.isNull())
  return {};
Replacement = Replacement.getCanonicalType();

return Importer.getToContext().getSubstTemplateTypeParmType(
      Replaced, Replacement);
996}

998QualType ASTNodeImporter::VisitTemplateSpecializationType(
                                     const TemplateSpecializationType *T) {
TemplateName ToTemplate = Importer.Import(T->getTemplateName());
if (ToTemplate.isNull())
  return {};

SmallVector<TemplateArgument, 2> ToTemplateArgs;
if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
  return {};

QualType ToCanonType;
if (!QualType(T, 0).isCanonical()) {
  QualType FromCanonType 
    = Importer.getFromContext().getCanonicalType(QualType(T, 0));
  ToCanonType =Importer.Import(FromCanonType);
  if (ToCanonType.isNull())
    return {};
}
return Importer.getToContext().getTemplateSpecializationType(ToTemplate, 
                                                             ToTemplateArgs,
                                                             ToCanonType);
1019}

1021QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
NestedNameSpecifier *ToQualifier = nullptr;
// Note: the qualifier in an ElaboratedType is optional.
if (T->getQualifier()) {
  ToQualifier = Importer.Import(T->getQualifier());
  if (!ToQualifier)
    return {};
}

QualType ToNamedType = Importer.Import(T->getNamedType());
if (ToNamedType.isNull())
  return {};

TagDecl *OwnedTagDecl =
    cast_or_null<TagDecl>(Importer.Import(T->getOwnedTagDecl()));
if (!OwnedTagDecl && T->getOwnedTagDecl())
  return {};

return Importer.getToContext().getElaboratedType(T->getKeyword(),
                                                 ToQualifier, ToNamedType,
                                                 OwnedTagDecl);
1042}

1044QualType ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
QualType Pattern = Importer.Import(T->getPattern());
if (Pattern.isNull())
  return {};

return Importer.getToContext().getPackExpansionType(Pattern,
                                                    T->getNumExpansions());
1051}

1053QualType ASTNodeImporter::VisitDependentTemplateSpecializationType(
  const DependentTemplateSpecializationType *T) {
NestedNameSpecifier *Qualifier = Importer.Import(T->getQualifier());
if (!Qualifier && T->getQualifier())
  return {};

IdentifierInfo *Name = Importer.Import(T->getIdentifier());
if (!Name && T->getIdentifier())
  return {};

SmallVector<TemplateArgument, 2> ToPack;
ToPack.reserve(T->getNumArgs());
if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToPack))
  return {};

return Importer.getToContext().getDependentTemplateSpecializationType(
      T->getKeyword(), Qualifier, Name, ToPack);
1070}

1072QualType ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
NestedNameSpecifier *NNS = Importer.Import(T->getQualifier());
if (!NNS && T->getQualifier())
  return QualType();

IdentifierInfo *Name = Importer.Import(T->getIdentifier());
if (!Name && T->getIdentifier())
  return QualType();

QualType Canon = (T == T->getCanonicalTypeInternal().getTypePtr())
                     ? QualType()
                     : Importer.Import(T->getCanonicalTypeInternal());
if (!Canon.isNull())
  Canon = Canon.getCanonicalType();

return Importer.getToContext().getDependentNameType(T->getKeyword(), NNS,
                                                    Name, Canon);
1089}

1091QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
auto *Class =
    dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
if (!Class)
  return {};

return Importer.getToContext().getObjCInterfaceType(Class);
1098}

1100QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
QualType ToBaseType = Importer.Import(T->getBaseType());
if (ToBaseType.isNull())
  return {};

SmallVector<QualType, 4> TypeArgs;
for (auto TypeArg : T->getTypeArgsAsWritten()) {
  QualType ImportedTypeArg = Importer.Import(TypeArg);
  if (ImportedTypeArg.isNull())
    return {};

  TypeArgs.push_back(ImportedTypeArg);
}

SmallVector<ObjCProtocolDecl *, 4> Protocols;
for (auto *P : T->quals()) {
  auto *Protocol = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
  if (!Protocol)
    return {};
  Protocols.push_back(Protocol);
}

return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
                                                 Protocols,
                                                 T->isKindOfTypeAsWritten());
1125}

1127QualType
1128ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
QualType ToPointeeType = Importer.Import(T->getPointeeType());
if (ToPointeeType.isNull())
  return {};

return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1134}

1136//----------------------------------------------------------------------------
1137// Import Declarations
1138//----------------------------------------------------------------------------
1139bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC, 
                                    DeclContext *&LexicalDC, 
                                    DeclarationName &Name, 
                                    NamedDecl *&ToD,
                                    SourceLocation &Loc) {
// Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
// example: int struct_in_proto(struct data_t{int a;int b;} *d);
DeclContext *OrigDC = D->getDeclContext();
FunctionDecl *FunDecl;
if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
    FunDecl->hasBody()) {
  SourceRange RecR = D->getSourceRange();
  SourceRange BodyR = FunDecl->getBody()->getSourceRange();
  // If RecordDecl is not in Body (it is a param), we bail out.
  if (RecR.isValid() && BodyR.isValid() &&
      (RecR.getBegin() < BodyR.getBegin() ||
       BodyR.getEnd() < RecR.getEnd())) {
    Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
        << D->getDeclKindName();
    return true;
  }
}

// Import the context of this declaration.
DC = Importer.ImportContext(OrigDC);
if (!DC)
  return true;

LexicalDC = DC;
if (D->getDeclContext() != D->getLexicalDeclContext()) {
  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
  if (!LexicalDC)
    return true;
}

// Import the name of this declaration.
Name = Importer.Import(D->getDeclName());
if (D->getDeclName() && !Name)
  return true;

// Import the location of this declaration.
Loc = Importer.Import(D->getLocation());
ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
return false;
1183}

1185void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
if (!FromD)
  return;

if (!ToD) {
  ToD = Importer.Import(FromD);
  if (!ToD)
    return;
}

if (auto *FromRecord = dyn_cast<RecordDecl>(FromD)) {
  if (auto *ToRecord = cast_or_null<RecordDecl>(ToD)) {
    if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
      ImportDefinition(FromRecord, ToRecord);
    }
  }
  return;
}

if (auto *FromEnum = dyn_cast<EnumDecl>(FromD)) {
  if (auto *ToEnum = cast_or_null<EnumDecl>(ToD)) {
    if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
      ImportDefinition(FromEnum, ToEnum);
    }
  }
  return;
}
1212}

1214void
1215ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
                                        DeclarationNameInfo& To) {
// NOTE: To.Name and To.Loc are already imported.
// We only have to import To.LocInfo.
switch (To.getName().getNameKind()) {
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXUsingDirective:
case DeclarationName::CXXDeductionGuideName:
  return;

case DeclarationName::CXXOperatorName: {
  SourceRange Range = From.getCXXOperatorNameRange();
  To.setCXXOperatorNameRange(Importer.Import(Range));
  return;
}
case DeclarationName::CXXLiteralOperatorName: {
  SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
  To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
  return;
}
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName: {
  TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
  To.setNamedTypeInfo(Importer.Import(FromTInfo));
  return;
}
}
llvm_unreachable("Unknown name kind.")::llvm::llvm_unreachable_internal("Unknown name kind.", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 1246);
1247}

1249void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {  
if (Importer.isMinimalImport() && !ForceImport) {
  Importer.ImportContext(FromDC);
  return;
}

for (auto *From : FromDC->decls())
  Importer.Import(From);
1257}

1259void ASTNodeImporter::ImportImplicitMethods(
  const CXXRecordDecl *From, CXXRecordDecl *To) {
assert(From->isCompleteDefinition() && To->getDefinition() == To &&(static_cast <bool> (From->isCompleteDefinition() &&
 To->getDefinition() == To && "Import implicit methods to or from non-definition"
) ? void (0) : __assert_fail ("From->isCompleteDefinition() && To->getDefinition() == To && \"Import implicit methods to or from non-definition\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 1262, __extension__ __PRETTY_FUNCTION__))
    "Import implicit methods to or from non-definition")(static_cast <bool> (From->isCompleteDefinition() &&
 To->getDefinition() == To && "Import implicit methods to or from non-definition"
) ? void (0) : __assert_fail ("From->isCompleteDefinition() && To->getDefinition() == To && \"Import implicit methods to or from non-definition\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 1262, __extension__ __PRETTY_FUNCTION__));

for (CXXMethodDecl *FromM : From->methods())
  if (FromM->isImplicit())
    Importer.Import(FromM);
1267}

1269static void setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
                             ASTImporter &Importer) {
if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
  auto *ToTypedef =
    cast_or_null<TypedefNameDecl>(Importer.Import(FromTypedef));
  assert (ToTypedef && "Failed to import typedef of an anonymous structure")(static_cast <bool> (ToTypedef && "Failed to import typedef of an anonymous structure"
) ? void (0) : __assert_fail ("ToTypedef && \"Failed to import typedef of an anonymous structure\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 1274, __extension__ __PRETTY_FUNCTION__));

  To->setTypedefNameForAnonDecl(ToTypedef);
}
1278}

1280bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To, 
                                     ImportDefinitionKind Kind) {
if (To->getDefinition() || To->isBeingDefined()) {
  if (Kind == IDK_Everything)
    ImportDeclContext(From, /*ForceImport=*/true);
  
  return false;
}

To->startDefinition();

setTypedefNameForAnonDecl(From, To, Importer);

// Add base classes.
if (auto *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
  auto *FromCXX = cast<CXXRecordDecl>(From);

  struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
  struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
  ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
  ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
  ToData.Aggregate = FromData.Aggregate;
  ToData.PlainOldData = FromData.PlainOldData;
  ToData.Empty = FromData.Empty;
  ToData.Polymorphic = FromData.Polymorphic;
  ToData.Abstract = FromData.Abstract;
  ToData.IsStandardLayout = FromData.IsStandardLayout;
  ToData.IsCXX11StandardLayout = FromData.IsCXX11StandardLayout;
  ToData.HasBasesWithFields = FromData.HasBasesWithFields;
  ToData.HasBasesWithNonStaticDataMembers =
      FromData.HasBasesWithNonStaticDataMembers;
  ToData.HasPrivateFields = FromData.HasPrivateFields;
  ToData.HasProtectedFields = FromData.HasProtectedFields;
  ToData.HasPublicFields = FromData.HasPublicFields;
  ToData.HasMutableFields = FromData.HasMutableFields;
  ToData.HasVariantMembers = FromData.HasVariantMembers;
  ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
  ToData.HasInClassInitializer = FromData.HasInClassInitializer;
  ToData.HasUninitializedReferenceMember
    = FromData.HasUninitializedReferenceMember;
  ToData.HasUninitializedFields = FromData.HasUninitializedFields;
  ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
  ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
  ToData.NeedOverloadResolutionForCopyConstructor
    = FromData.NeedOverloadResolutionForCopyConstructor;
  ToData.NeedOverloadResolutionForMoveConstructor
    = FromData.NeedOverloadResolutionForMoveConstructor;
  ToData.NeedOverloadResolutionForMoveAssignment
    = FromData.NeedOverloadResolutionForMoveAssignment;
  ToData.NeedOverloadResolutionForDestructor
    = FromData.NeedOverloadResolutionForDestructor;
  ToData.DefaultedCopyConstructorIsDeleted
    = FromData.DefaultedCopyConstructorIsDeleted;
  ToData.DefaultedMoveConstructorIsDeleted
    = FromData.DefaultedMoveConstructorIsDeleted;
  ToData.DefaultedMoveAssignmentIsDeleted
    = FromData.DefaultedMoveAssignmentIsDeleted;
  ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
  ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
  ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
  ToData.HasConstexprNonCopyMoveConstructor
    = FromData.HasConstexprNonCopyMoveConstructor;
  ToData.HasDefaultedDefaultConstructor
    = FromData.HasDefaultedDefaultConstructor;
  ToData.DefaultedDefaultConstructorIsConstexpr
    = FromData.DefaultedDefaultConstructorIsConstexpr;
  ToData.HasConstexprDefaultConstructor
    = FromData.HasConstexprDefaultConstructor;
  ToData.HasNonLiteralTypeFieldsOrBases
    = FromData.HasNonLiteralTypeFieldsOrBases;
  // ComputedVisibleConversions not imported.
  ToData.UserProvidedDefaultConstructor
    = FromData.UserProvidedDefaultConstructor;
  ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
  ToData.ImplicitCopyConstructorCanHaveConstParamForVBase
    = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase;
  ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase
    = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase;
  ToData.ImplicitCopyAssignmentHasConstParam
    = FromData.ImplicitCopyAssignmentHasConstParam;
  ToData.HasDeclaredCopyConstructorWithConstParam
    = FromData.HasDeclaredCopyConstructorWithConstParam;
  ToData.HasDeclaredCopyAssignmentWithConstParam
    = FromData.HasDeclaredCopyAssignmentWithConstParam;

  SmallVector<CXXBaseSpecifier *, 4> Bases;
  for (const auto &Base1 : FromCXX->bases()) {
    QualType T = Importer.Import(Base1.getType());
    if (T.isNull())
      return true;

    SourceLocation EllipsisLoc;
    if (Base1.isPackExpansion())
      EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());

    // Ensure that we have a definition for the base.
    ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
      
    Bases.push_back(
                  new (Importer.getToContext()) 
                    CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
                                     Base1.isVirtual(),
                                     Base1.isBaseOfClass(),
                                     Base1.getAccessSpecifierAsWritten(),
                                 Importer.Import(Base1.getTypeSourceInfo()),
                                     EllipsisLoc));
  }
  if (!Bases.empty())
    ToCXX->setBases(Bases.data(), Bases.size());
}

if (shouldForceImportDeclContext(Kind))
  ImportDeclContext(From, /*ForceImport=*/true);

To->completeDefinition();
return false;
1396}

1398bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
                                     ImportDefinitionKind Kind) {
if (To->getAnyInitializer())
  return false;

// FIXME: Can we really import any initializer? Alternatively, we could force
// ourselves to import every declaration of a variable and then only use
// getInit() here.
To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));

// FIXME: Other bits to merge?

return false;
1411}

1413bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To, 
                                     ImportDefinitionKind Kind) {
if (To->getDefinition() || To->isBeingDefined()) {
  if (Kind == IDK_Everything)
    ImportDeclContext(From, /*ForceImport=*/true);
  return false;
}

To->startDefinition();

setTypedefNameForAnonDecl(From, To, Importer);

QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
if (T.isNull())
  return true;

QualType ToPromotionType = Importer.Import(From->getPromotionType());
if (ToPromotionType.isNull())
  return true;

if (shouldForceImportDeclContext(Kind))
  ImportDeclContext(From, /*ForceImport=*/true);

// FIXME: we might need to merge the number of positive or negative bits
// if the enumerator lists don't match.
To->completeDefinition(T, ToPromotionType,
                       From->getNumPositiveBits(),
                       From->getNumNegativeBits());
return false;
1442}

1444TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
                                              TemplateParameterList *Params) {
SmallVector<NamedDecl *, 4> ToParams(Params->size());
if (ImportContainerChecked(*Params, ToParams))
  return nullptr;

Expr *ToRequiresClause;
if (Expr *const R = Params->getRequiresClause()) {
  ToRequiresClause = Importer.Import(R);
  if (!ToRequiresClause)
    return nullptr;
} else {
  ToRequiresClause = nullptr;
}

return TemplateParameterList::Create(Importer.getToContext(),
                                     Importer.Import(Params->getTemplateLoc()),
                                     Importer.Import(Params->getLAngleLoc()),
                                     ToParams,
                                     Importer.Import(Params->getRAngleLoc()),
                                     ToRequiresClause);
1465}

1467TemplateArgument 
1468ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
switch (From.getKind()) {
case TemplateArgument::Null:
  return TemplateArgument();
   
case TemplateArgument::Type: {
  QualType ToType = Importer.Import(From.getAsType());
  if (ToType.isNull())
    return {};
  return TemplateArgument(ToType);
}
    
case TemplateArgument::Integral: {
  QualType ToType = Importer.Import(From.getIntegralType());
  if (ToType.isNull())
    return {};
  return TemplateArgument(From, ToType);
}

case TemplateArgument::Declaration: {
  auto *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
  QualType ToType = Importer.Import(From.getParamTypeForDecl());
  if (!To || ToType.isNull())
    return {};
  return TemplateArgument(To, ToType);
}

case TemplateArgument::NullPtr: {
  QualType ToType = Importer.Import(From.getNullPtrType());
  if (ToType.isNull())
    return {};
  return TemplateArgument(ToType, /*isNullPtr*/true);
}

case TemplateArgument::Template: {
  TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
  if (ToTemplate.isNull())
    return {};
  
  return TemplateArgument(ToTemplate);
}

case TemplateArgument::TemplateExpansion: {
  TemplateName ToTemplate 
    = Importer.Import(From.getAsTemplateOrTemplatePattern());
  if (ToTemplate.isNull())
    return {};
  
  return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
}

case TemplateArgument::Expression:
  if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
    return TemplateArgument(ToExpr);
  return TemplateArgument();
    
case TemplateArgument::Pack: {
  SmallVector<TemplateArgument, 2> ToPack;
  ToPack.reserve(From.pack_size());
  if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
    return {};

  return TemplateArgument(
      llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
}
}

llvm_unreachable("Invalid template argument kind")::llvm::llvm_unreachable_internal("Invalid template argument kind"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 1535);
1536}

1538Optional<TemplateArgumentLoc>
1539ASTNodeImporter::ImportTemplateArgumentLoc(const TemplateArgumentLoc &TALoc) {
TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument());
TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
TemplateArgumentLocInfo ToInfo;
if (Arg.getKind() == TemplateArgument::Expression) {
  Expr *E = Importer.Import(FromInfo.getAsExpr());
  ToInfo = TemplateArgumentLocInfo(E);
  if (!E)
    return None;
} else if (Arg.getKind() == TemplateArgument::Type) {
  if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo()))
    ToInfo = TemplateArgumentLocInfo(TSI);
  else
    return None;
} else {
  ToInfo = TemplateArgumentLocInfo(
        Importer.Import(FromInfo.getTemplateQualifierLoc()),
        Importer.Import(FromInfo.getTemplateNameLoc()),
        Importer.Import(FromInfo.getTemplateEllipsisLoc()));
}
return TemplateArgumentLoc(Arg, ToInfo);
1560}

1562bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
                                            unsigned NumFromArgs,
                            SmallVectorImpl<TemplateArgument> &ToArgs) {
for (unsigned I = 0; I != NumFromArgs; ++I) {
  TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
  if (To.isNull() && !FromArgs[I].isNull())
    return true;
  
  ToArgs.push_back(To);
}

return false;
1574}

1576// We cannot use Optional<> pattern here and below because
1577// TemplateArgumentListInfo's operator new is declared as deleted so it cannot
1578// be stored in Optional.
1579template <typename InContainerTy>
1580bool ASTNodeImporter::ImportTemplateArgumentListInfo(
  const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
for (const auto &FromLoc : Container) {
  if (auto ToLoc = ImportTemplateArgumentLoc(FromLoc))
    ToTAInfo.addArgument(*ToLoc);
  else
    return true;
}
return false;
1589}

1591static StructuralEquivalenceKind
1592getStructuralEquivalenceKind(const ASTImporter &Importer) {
return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
                                  : StructuralEquivalenceKind::Default;
1595}

1597bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) {
StructuralEquivalenceContext Ctx(
    Importer.getFromContext(), Importer.getToContext(),
    Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
    false, Complain);
return Ctx.IsEquivalent(From, To);
1603}

1605bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
                                      RecordDecl *ToRecord, bool Complain) {
// Eliminate a potential failure point where we attempt to re-import
// something we're trying to import while completing ToRecord.
Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
if (ToOrigin) {
  auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
  if (ToOriginRecord)
    ToRecord = ToOriginRecord;
}

StructuralEquivalenceContext Ctx(Importer.getFromContext(),
                                 ToRecord->getASTContext(),
                                 Importer.getNonEquivalentDecls(),
                                 getStructuralEquivalenceKind(Importer),
                                 false, Complain);
return Ctx.IsEquivalent(FromRecord, ToRecord);
1622}

1624bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
                                      bool Complain) {
StructuralEquivalenceContext Ctx(
    Importer.getFromContext(), Importer.getToContext(),
    Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
    false, Complain);
return Ctx.IsEquivalent(FromVar, ToVar);
1631}

1633bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
StructuralEquivalenceContext Ctx(
    Importer.getFromContext(), Importer.getToContext(),
    Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
return Ctx.IsEquivalent(FromEnum, ToEnum);
1638}

1640bool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From,
                                      FunctionTemplateDecl *To) {
StructuralEquivalenceContext Ctx(
    Importer.getFromContext(), Importer.getToContext(),
    Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
    false, false);
return Ctx.IsEquivalent(From, To);
1647}

1649bool ASTNodeImporter::IsStructuralMatch(FunctionDecl *From, FunctionDecl *To) {
StructuralEquivalenceContext Ctx(
    Importer.getFromContext(), Importer.getToContext(),
    Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
    false, false);
return Ctx.IsEquivalent(From, To);
1655}

1657bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
                                      EnumConstantDecl *ToEC) {
const llvm::APSInt &FromVal = FromEC->getInitVal();
const llvm::APSInt &ToVal = ToEC->getInitVal();

return FromVal.isSigned() == ToVal.isSigned() &&
       FromVal.getBitWidth() == ToVal.getBitWidth() &&
       FromVal == ToVal;
1665}

1667bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
                                      ClassTemplateDecl *To) {
StructuralEquivalenceContext Ctx(Importer.getFromContext(),
                                 Importer.getToContext(),
                                 Importer.getNonEquivalentDecls(),
                                 getStructuralEquivalenceKind(Importer));
return Ctx.IsEquivalent(From, To);
1674}

1676bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
                                      VarTemplateDecl *To) {
StructuralEquivalenceContext Ctx(Importer.getFromContext(),
                                 Importer.getToContext(),
                                 Importer.getNonEquivalentDecls(),
                                 getStructuralEquivalenceKind(Importer));
return Ctx.IsEquivalent(From, To);
1683}

1685Decl *ASTNodeImporter::VisitDecl(Decl *D) {
Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
  << D->getDeclKindName();
return nullptr;
1689}

1691Decl *ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
// Import the context of this declaration.
DeclContext *DC = Importer.ImportContext(D->getDeclContext());
if (!DC)
  return nullptr;

DeclContext *LexicalDC = DC;
if (D->getDeclContext() != D->getLexicalDeclContext()) {
  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
  if (!LexicalDC)
    return nullptr;
}

// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());

EmptyDecl *ToD;
if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, Loc))
  return ToD;

ToD->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToD);
return ToD;
1714}

1716Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
TranslationUnitDecl *ToD = 
  Importer.getToContext().getTranslationUnitDecl();
  
Importer.MapImported(D, ToD);
  
return ToD;
1723}

1725Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
SourceLocation Loc = Importer.Import(D->getLocation());
SourceLocation ColonLoc = Importer.Import(D->getColonLoc());

// Import the context of this declaration.
DeclContext *DC = Importer.ImportContext(D->getDeclContext());
if (!DC)
  return nullptr;

AccessSpecDecl *ToD;
if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(),
                            DC, Loc, ColonLoc))
  return ToD;

// Lexical DeclContext and Semantic DeclContext
// is always the same for the accessSpec.
ToD->setLexicalDeclContext(DC);
DC->addDeclInternal(ToD);

return ToD;
1745}

1747Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
DeclContext *DC = Importer.ImportContext(D->getDeclContext());
if (!DC)
  return nullptr;

DeclContext *LexicalDC = DC;

// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());

Expr *AssertExpr = Importer.Import(D->getAssertExpr());
if (!AssertExpr)
  return nullptr;

StringLiteral *FromMsg = D->getMessage();
auto *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
if (!ToMsg && FromMsg)
  return nullptr;

StaticAssertDecl *ToD;
if (GetImportedOrCreateDecl(
        ToD, D, Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
        Importer.Import(D->getRParenLoc()), D->isFailed()))
  return ToD;

ToD->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToD);
return ToD;
1775}

1777Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
// Import the major distinguishing characteristics of this namespace.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

NamespaceDecl *MergeWithNamespace = nullptr;
if (!Name) {
  // This is an anonymous namespace. Adopt an existing anonymous
  // namespace if we can.
  // FIXME: Not testable.
  if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
    MergeWithNamespace = TU->getAnonymousNamespace();
  else
    MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
} else {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  SmallVector<NamedDecl *, 2> FoundDecls;
  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace))
      continue;
    
    if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
      MergeWithNamespace = FoundNS;
      ConflictingDecls.clear();
      break;
    }
    
    ConflictingDecls.push_back(FoundDecl);
  }
  
  if (!ConflictingDecls.empty()) {
    Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
                                       ConflictingDecls.data(), 
                                       ConflictingDecls.size());
  }
}

// Create the "to" namespace, if needed.
NamespaceDecl *ToNamespace = MergeWithNamespace;
if (!ToNamespace) {
  if (GetImportedOrCreateDecl(
          ToNamespace, D, Importer.getToContext(), DC, D->isInline(),
          Importer.Import(D->getLocStart()), Loc, Name.getAsIdentifierInfo(),
          /*PrevDecl=*/nullptr))
    return ToNamespace;
  ToNamespace->setLexicalDeclContext(LexicalDC);
  LexicalDC->addDeclInternal(ToNamespace);
  
  // If this is an anonymous namespace, register it as the anonymous
  // namespace within its context.
  if (!Name) {
    if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
      TU->setAnonymousNamespace(ToNamespace);
    else
      cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
  }
}
Importer.MapImported(D, ToNamespace);

ImportDeclContext(D);

return ToNamespace;
1846}

1848Decl *ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
// Import the major distinguishing characteristics of this namespace.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *LookupD;
if (ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
  return nullptr;
if (LookupD)
  return LookupD;

// NOTE: No conflict resolution is done for namespace aliases now.

auto *TargetDecl = cast_or_null<NamespaceDecl>(
    Importer.Import(D->getNamespace()));
if (!TargetDecl)
  return nullptr;

IdentifierInfo *ToII = Importer.Import(D->getIdentifier());
if (!ToII)
  return nullptr;

NestedNameSpecifierLoc ToQLoc = Importer.Import(D->getQualifierLoc());
if (D->getQualifierLoc() && !ToQLoc)
  return nullptr;

NamespaceAliasDecl *ToD;
if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC,
                            Importer.Import(D->getNamespaceLoc()),
                            Importer.Import(D->getAliasLoc()), ToII, ToQLoc,
                            Importer.Import(D->getTargetNameLoc()),
                            TargetDecl))
  return ToD;

ToD->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToD);

return ToD;
1886}

1888Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
// Import the major distinguishing characteristics of this typedef.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// If this typedef is not in block scope, determine whether we've
// seen a typedef with the same name (that we can merge with) or any
// other entity by that name (which name lookup could conflict with).
if (!DC->isFunctionOrMethod()) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  unsigned IDNS = Decl::IDNS_Ordinary;
  SmallVector<NamedDecl *, 2> FoundDecls;
  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;
    if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
      if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
                                          FoundTypedef->getUnderlyingType()))
        return Importer.MapImported(D, FoundTypedef);
    }

    ConflictingDecls.push_back(FoundDecl);
  }

  if (!ConflictingDecls.empty()) {
    Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                       ConflictingDecls.data(), 
                                       ConflictingDecls.size());
    if (!Name)
      return nullptr;
  }
}

// Import the underlying type of this typedef;
QualType T = Importer.Import(D->getUnderlyingType());
if (T.isNull())
  return nullptr;

// Create the new typedef node.
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
SourceLocation StartL = Importer.Import(D->getLocStart());

TypedefNameDecl *ToTypedef;
if (IsAlias) {
  if (GetImportedOrCreateDecl<TypeAliasDecl>(
          ToTypedef, D, Importer.getToContext(), DC, StartL, Loc,
          Name.getAsIdentifierInfo(), TInfo))
    return ToTypedef;
} else if (GetImportedOrCreateDecl<TypedefDecl>(
               ToTypedef, D, Importer.getToContext(), DC, StartL, Loc,
               Name.getAsIdentifierInfo(), TInfo))
  return ToTypedef;

ToTypedef->setAccess(D->getAccess());
ToTypedef->setLexicalDeclContext(LexicalDC);

// Templated declarations should not appear in DeclContext.
TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr;
if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
  LexicalDC->addDeclInternal(ToTypedef);

return ToTypedef;
1957}

1959Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
return VisitTypedefNameDecl(D, /*IsAlias=*/false);
1961}

1963Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
return VisitTypedefNameDecl(D, /*IsAlias=*/true);
1965}

1967Decl *ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
// Import the major distinguishing characteristics of this typedef.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *FoundD;
if (ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
  return nullptr;
if (FoundD)
  return FoundD;

// If this typedef is not in block scope, determine whether we've
// seen a typedef with the same name (that we can merge with) or any
// other entity by that name (which name lookup could conflict with).
if (!DC->isFunctionOrMethod()) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  unsigned IDNS = Decl::IDNS_Ordinary;
  SmallVector<NamedDecl *, 2> FoundDecls;
  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;
    if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
      return Importer.MapImported(D, FoundAlias);
    ConflictingDecls.push_back(FoundDecl);
  }

  if (!ConflictingDecls.empty()) {
    Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                       ConflictingDecls.data(),
                                       ConflictingDecls.size());
    if (!Name)
      return nullptr;
  }
}

TemplateParameterList *Params = ImportTemplateParameterList(
      D->getTemplateParameters());
if (!Params)
  return nullptr;

auto *TemplDecl = cast_or_null<TypeAliasDecl>(
      Importer.Import(D->getTemplatedDecl()));
if (!TemplDecl)
  return nullptr;

TypeAliasTemplateDecl *ToAlias;
if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc,
                            Name, Params, TemplDecl))
  return ToAlias;

TemplDecl->setDescribedAliasTemplate(ToAlias);

ToAlias->setAccess(D->getAccess());
ToAlias->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToAlias);
return ToAlias;
2024}

2026Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
// Import the major distinguishing characteristics of this label.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

assert(LexicalDC->isFunctionOrMethod())(static_cast <bool> (LexicalDC->isFunctionOrMethod()
) ? void (0) : __assert_fail ("LexicalDC->isFunctionOrMethod()"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 2037, __extension__ __PRETTY_FUNCTION__));

LabelDecl *ToLabel;
if (D->isGnuLocal()
        ? GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
                                  Importer.Import(D->getLocation()),
                                  Name.getAsIdentifierInfo(),
                                  Importer.Import(D->getLocStart()))
        : GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
                                  Importer.Import(D->getLocation()),
                                  Name.getAsIdentifierInfo()))
  return ToLabel;

auto *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
if (!Label)
  return nullptr;

ToLabel->setStmt(Label);
ToLabel->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToLabel);
return ToLabel;
2058}

2060Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
// Import the major distinguishing characteristics of this enum.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// Figure out what enum name we're looking for.
unsigned IDNS = Decl::IDNS_Tag;
DeclarationName SearchName = Name;
if (!SearchName && D->getTypedefNameForAnonDecl()) {
  SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
  IDNS = Decl::IDNS_Ordinary;
} else if (Importer.getToContext().getLangOpts().CPlusPlus)
  IDNS |= Decl::IDNS_Ordinary;

// We may already have an enum of the same name; try to find and match it.
if (!DC->isFunctionOrMethod() && SearchName) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  SmallVector<NamedDecl *, 2> FoundDecls;
  DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;
    
    Decl *Found = FoundDecl;
    if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
      if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
        Found = Tag->getDecl();
    }
    
    if (auto *FoundEnum = dyn_cast<EnumDecl>(Found)) {
      if (IsStructuralMatch(D, FoundEnum))
        return Importer.MapImported(D, FoundEnum);
    }
    
    ConflictingDecls.push_back(FoundDecl);
  }
  
  if (!ConflictingDecls.empty()) {
    Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                       ConflictingDecls.data(), 
                                       ConflictingDecls.size());
  }
}

// Create the enum declaration.
EnumDecl *D2;
if (GetImportedOrCreateDecl(
        D2, D, Importer.getToContext(), DC, Importer.Import(D->getLocStart()),
        Loc, Name.getAsIdentifierInfo(), nullptr, D->isScoped(),
        D->isScopedUsingClassTag(), D->isFixed()))
  return D2;

// Import the qualifier, if any.
D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
D2->setAccess(D->getAccess());
D2->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(D2);

// Import the integer type.
QualType ToIntegerType = Importer.Import(D->getIntegerType());
if (ToIntegerType.isNull())
  return nullptr;
D2->setIntegerType(ToIntegerType);

// Import the definition
if (D->isCompleteDefinition() && ImportDefinition(D, D2))
  return nullptr;

return D2;
2135}

2137Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
// If this record has a definition in the translation unit we're coming from,
// but this particular declaration is not that definition, import the
// definition and map to that.
TagDecl *Definition = D->getDefinition();
if (Definition && Definition != D &&
    // In contrast to a normal CXXRecordDecl, the implicit
    // CXXRecordDecl of ClassTemplateSpecializationDecl is its redeclaration.
    // The definition of the implicit CXXRecordDecl in this case is the
    // ClassTemplateSpecializationDecl itself. Thus, we start with an extra
    // condition in order to be able to import the implict Decl.
    !D->isImplicit()) {
  Decl *ImportedDef = Importer.Import(Definition);
  if (!ImportedDef)
    return nullptr;

  return Importer.MapImported(D, ImportedDef);
}

// Import the major distinguishing characteristics of this record.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// Figure out what structure name we're looking for.
unsigned IDNS = Decl::IDNS_Tag;
DeclarationName SearchName = Name;
if (!SearchName && D->getTypedefNameForAnonDecl()) {
  SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
  IDNS = Decl::IDNS_Ordinary;
} else if (Importer.getToContext().getLangOpts().CPlusPlus)
  IDNS |= Decl::IDNS_Ordinary;

// We may already have a record of the same name; try to find and match it.
RecordDecl *AdoptDecl = nullptr;
RecordDecl *PrevDecl = nullptr;
if (!DC->isFunctionOrMethod()) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  SmallVector<NamedDecl *, 2> FoundDecls;
  DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);

  if (!FoundDecls.empty()) {
    // We're going to have to compare D against potentially conflicting Decls, so complete it.
    if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
      D->getASTContext().getExternalSource()->CompleteType(D);
  }

  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;
    
    Decl *Found = FoundDecl;
    if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
      if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
        Found = Tag->getDecl();
    }

    if (D->getDescribedTemplate()) {
      if (auto *Template = dyn_cast<ClassTemplateDecl>(Found))
        Found = Template->getTemplatedDecl();
      else
        continue;
    }

    if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
      if (!SearchName) {
        if (!IsStructuralMatch(D, FoundRecord, false))
          continue;
      }

      PrevDecl = FoundRecord;

      if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
        if ((SearchName && !D->isCompleteDefinition())
            || (D->isCompleteDefinition() &&
                D->isAnonymousStructOrUnion()
                  == FoundDef->isAnonymousStructOrUnion() &&
                IsStructuralMatch(D, FoundDef))) {
          // The record types structurally match, or the "from" translation
          // unit only had a forward declaration anyway; call it the same
          // function.
          // FIXME: Structural equivalence check should check for same
          // user-defined methods.
          Importer.MapImported(D, FoundDef);
          if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
            auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
            assert(FoundCXX && "Record type mismatch")(static_cast <bool> (FoundCXX && "Record type mismatch"
) ? void (0) : __assert_fail ("FoundCXX && \"Record type mismatch\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 2228, __extension__ __PRETTY_FUNCTION__));

            if (D->isCompleteDefinition() && !Importer.isMinimalImport())
              // FoundDef may not have every implicit method that D has
              // because implicit methods are created only if they are used.
              ImportImplicitMethods(DCXX, FoundCXX);
          }
          return FoundDef;
        }
      } else if (!D->isCompleteDefinition()) {
        // We have a forward declaration of this type, so adopt that forward
        // declaration rather than building a new one.
          
        // If one or both can be completed from external storage then try one
        // last time to complete and compare them before doing this.
          
        if (FoundRecord->hasExternalLexicalStorage() &&
            !FoundRecord->isCompleteDefinition())
          FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
        if (D->hasExternalLexicalStorage())
          D->getASTContext().getExternalSource()->CompleteType(D);
          
        if (FoundRecord->isCompleteDefinition() &&
            D->isCompleteDefinition() &&
            !IsStructuralMatch(D, FoundRecord))
          continue;
            
        AdoptDecl = FoundRecord;
        continue;
      } else if (!SearchName) {
        continue;
      }
    }
    
    ConflictingDecls.push_back(FoundDecl);
  }
  
  if (!ConflictingDecls.empty() && SearchName) {
    Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                       ConflictingDecls.data(), 
                                       ConflictingDecls.size());
  }
}

// Create the record declaration.
RecordDecl *D2 = AdoptDecl;
SourceLocation StartLoc = Importer.Import(D->getLocStart());
if (!D2) {
  CXXRecordDecl *D2CXX = nullptr;
  if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
    if (DCXX->isLambda()) {
      TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
      if (GetImportedOrCreateSpecialDecl(
              D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
              DC, TInfo, Loc, DCXX->isDependentLambda(),
              DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
        return D2CXX;
      Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
      if (DCXX->getLambdaContextDecl() && !CDecl)
        return nullptr;
      D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
    } else if (DCXX->isInjectedClassName()) {
      // We have to be careful to do a similar dance to the one in
      // Sema::ActOnStartCXXMemberDeclarations
      CXXRecordDecl *const PrevDecl = nullptr;
      const bool DelayTypeCreation = true;
      if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
                                  D->getTagKind(), DC, StartLoc, Loc,
                                  Name.getAsIdentifierInfo(), PrevDecl,
                                  DelayTypeCreation))
        return D2CXX;
      Importer.getToContext().getTypeDeclType(
          D2CXX, dyn_cast<CXXRecordDecl>(DC));
    } else {
      if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
                                  D->getTagKind(), DC, StartLoc, Loc,
                                  Name.getAsIdentifierInfo(),
                                  cast_or_null<CXXRecordDecl>(PrevDecl)))
        return D2CXX;
    }

    D2 = D2CXX;
    D2->setAccess(D->getAccess());
    D2->setLexicalDeclContext(LexicalDC);
    if (!DCXX->getDescribedClassTemplate() || DCXX->isImplicit())
      LexicalDC->addDeclInternal(D2);

    if (ClassTemplateDecl *FromDescribed =
        DCXX->getDescribedClassTemplate()) {
      auto *ToDescribed = cast_or_null<ClassTemplateDecl>(
          Importer.Import(FromDescribed));
      if (!ToDescribed)
        return nullptr;
      D2CXX->setDescribedClassTemplate(ToDescribed);
      if (!DCXX->isInjectedClassName()) {
        // In a record describing a template the type should be an
        // InjectedClassNameType (see Sema::CheckClassTemplate). Update the
        // previously set type to the correct value here (ToDescribed is not
        // available at record create).
        // FIXME: The previous type is cleared but not removed from
        // ASTContext's internal storage.
        CXXRecordDecl *Injected = nullptr;
        for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
          auto *Record = dyn_cast<CXXRecordDecl>(Found);
          if (Record && Record->isInjectedClassName()) {
            Injected = Record;
            break;
          }
        }
        D2CXX->setTypeForDecl(nullptr);
        Importer.getToContext().getInjectedClassNameType(D2CXX,
            ToDescribed->getInjectedClassNameSpecialization());
        if (Injected) {
          Injected->setTypeForDecl(nullptr);
          Importer.getToContext().getTypeDeclType(Injected, D2CXX);
        }
      }
    } else if (MemberSpecializationInfo *MemberInfo =
                 DCXX->getMemberSpecializationInfo()) {
      TemplateSpecializationKind SK =
          MemberInfo->getTemplateSpecializationKind();
      CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
      auto *ToInst =
          cast_or_null<CXXRecordDecl>(Importer.Import(FromInst));
      if (FromInst && !ToInst)
        return nullptr;
      D2CXX->setInstantiationOfMemberClass(ToInst, SK);
      D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
            Importer.Import(MemberInfo->getPointOfInstantiation()));
    }
  } else {
    if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
                                D->getTagKind(), DC, StartLoc, Loc,
                                Name.getAsIdentifierInfo(), PrevDecl))
      return D2;
    D2->setLexicalDeclContext(LexicalDC);
    LexicalDC->addDeclInternal(D2);
  }

  D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
  if (D->isAnonymousStructOrUnion())
    D2->setAnonymousStructOrUnion(true);
}

Importer.MapImported(D, D2);

if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
  return nullptr;

return D2;
2378}

2380Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
// Import the major distinguishing characteristics of this enumerator.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

QualType T = Importer.Import(D->getType());
if (T.isNull())
  return nullptr;

// Determine whether there are any other declarations with the same name and 
// in the same context.
if (!LexicalDC->isFunctionOrMethod()) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  unsigned IDNS = Decl::IDNS_Ordinary;
  SmallVector<NamedDecl *, 2> FoundDecls;
  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;

    if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
      if (IsStructuralMatch(D, FoundEnumConstant))
        return Importer.MapImported(D, FoundEnumConstant);
    }

    ConflictingDecls.push_back(FoundDecl);
  }
  
  if (!ConflictingDecls.empty()) {
    Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                       ConflictingDecls.data(), 
                                       ConflictingDecls.size());
    if (!Name)
      return nullptr;
  }
}

Expr *Init = Importer.Import(D->getInitExpr());
if (D->getInitExpr() && !Init)
  return nullptr;

EnumConstantDecl *ToEnumerator;
if (GetImportedOrCreateDecl(
        ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc,
        Name.getAsIdentifierInfo(), T, Init, D->getInitVal()))
  return ToEnumerator;

ToEnumerator->setAccess(D->getAccess());
ToEnumerator->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToEnumerator);
return ToEnumerator;
2437}

2439bool ASTNodeImporter::ImportTemplateInformation(FunctionDecl *FromFD,
                                              FunctionDecl *ToFD) {
switch (FromFD->getTemplatedKind()) {
case FunctionDecl::TK_NonTemplate:
case FunctionDecl::TK_FunctionTemplate:
  return false;

case FunctionDecl::TK_MemberSpecialization: {
  auto *InstFD = cast_or_null<FunctionDecl>(
        Importer.Import(FromFD->getInstantiatedFromMemberFunction()));
  if (!InstFD)
    return true;

  TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
  SourceLocation POI = Importer.Import(
        FromFD->getMemberSpecializationInfo()->getPointOfInstantiation());
  ToFD->setInstantiationOfMemberFunction(InstFD, TSK);
  ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
  return false;
}

case FunctionDecl::TK_FunctionTemplateSpecialization: {
  FunctionTemplateDecl* Template;
  OptionalTemplateArgsTy ToTemplArgs;
  std::tie(Template, ToTemplArgs) =
      ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
  if (!Template || !ToTemplArgs)
    return true;

  TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
        Importer.getToContext(), *ToTemplArgs);

  auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
  TemplateArgumentListInfo ToTAInfo;
  const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
  if (FromTAArgsAsWritten)
    if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ToTAInfo))
      return true;

  SourceLocation POI = Importer.Import(FTSInfo->getPointOfInstantiation());

  TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
  ToFD->setFunctionTemplateSpecialization(
      Template, ToTAList, /* InsertPos= */ nullptr,
      TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, POI);
  return false;
}

case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
  auto *FromInfo = FromFD->getDependentSpecializationInfo();
  UnresolvedSet<8> TemplDecls;
  unsigned NumTemplates = FromInfo->getNumTemplates();
  for (unsigned I = 0; I < NumTemplates; I++) {
    if (auto *ToFTD = cast_or_null<FunctionTemplateDecl>(
            Importer.Import(FromInfo->getTemplate(I))))
      TemplDecls.addDecl(ToFTD);
    else
      return true;
  }

  // Import TemplateArgumentListInfo.
  TemplateArgumentListInfo ToTAInfo;
  if (ImportTemplateArgumentListInfo(
          FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
          llvm::makeArrayRef(FromInfo->getTemplateArgs(),
                             FromInfo->getNumTemplateArgs()),
          ToTAInfo))
    return true;

  ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
                                           TemplDecls, ToTAInfo);
  return false;
}
}
llvm_unreachable("All cases should be covered!")::llvm::llvm_unreachable_internal("All cases should be covered!"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 2513);
2514}

2516FunctionDecl *
2517ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
FunctionTemplateDecl* Template;
OptionalTemplateArgsTy ToTemplArgs;
std::tie(Template, ToTemplArgs) =
    ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
if (!Template || !ToTemplArgs)
  return nullptr;

void *InsertPos = nullptr;
auto *FoundSpec = Template->findSpecialization(*ToTemplArgs, InsertPos);
return FoundSpec;
2528}

2530Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {

SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
auto RedeclIt = Redecls.begin();
// Import the first part of the decl chain. I.e. import all previous
// declarations starting from the canonical decl.
for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt)
  if (!Importer.Import(*RedeclIt))
    return nullptr;
assert(*RedeclIt == D)(static_cast <bool> (*RedeclIt == D) ? void (0) : __assert_fail
 ("*RedeclIt == D", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 2539, __extension__ __PRETTY_FUNCTION__));

// Import the major distinguishing characteristics of this function.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

const FunctionDecl *FoundByLookup = nullptr;
FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();

// If this is a function template specialization, then try to find the same
// existing specialization in the "to" context. The localUncachedLookup
// below will not find any specialization, but would find the primary
// template; thus, we have to skip normal lookup in case of specializations.
// FIXME handle member function templates (TK_MemberSpecialization) similarly?
if (D->getTemplatedKind() ==
    FunctionDecl::TK_FunctionTemplateSpecialization) {
  if (FunctionDecl *FoundFunction = FindFunctionTemplateSpecialization(D)) {
    if (D->doesThisDeclarationHaveABody() &&
        FoundFunction->hasBody())
      return Importer.Imported(D, FoundFunction);
    FoundByLookup = FoundFunction;
  }
}
// Try to find a function in our own ("to") context with the same name, same
// type, and in the same context as the function we're importing.
else if (!LexicalDC->isFunctionOrMethod()) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
  SmallVector<NamedDecl *, 2> FoundDecls;
  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;

    // If template was found, look at the templated function.
    if (FromFT) {
      if (auto *Template = dyn_cast<FunctionTemplateDecl>(FoundDecl))
        FoundDecl = Template->getTemplatedDecl();
      else
        continue;
    }

    if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
      if (FoundFunction->hasExternalFormalLinkage() &&
          D->hasExternalFormalLinkage()) {
        if (IsStructuralMatch(D, FoundFunction)) {
          const FunctionDecl *Definition = nullptr;
          if (D->doesThisDeclarationHaveABody() &&
              FoundFunction->hasBody(Definition)) {
            return Importer.MapImported(
                D, const_cast<FunctionDecl *>(Definition));
          }
          FoundByLookup = FoundFunction;
          break;
        }

        // FIXME: Check for overloading more carefully, e.g., by boosting
        // Sema::IsOverload out to the AST library.

        // Function overloading is okay in C++.
        if (Importer.getToContext().getLangOpts().CPlusPlus)
          continue;

        // Complain about inconsistent function types.
        Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
          << Name << D->getType() << FoundFunction->getType();
        Importer.ToDiag(FoundFunction->getLocation(), 
                        diag::note_odr_value_here)
          << FoundFunction->getType();
      }
    }

    ConflictingDecls.push_back(FoundDecl);
  }

  if (!ConflictingDecls.empty()) {
    Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                       ConflictingDecls.data(), 
                                       ConflictingDecls.size());
    if (!Name)
      return nullptr;
  }    
}

DeclarationNameInfo NameInfo(Name, Loc);
// Import additional name location/type info.
ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);

QualType FromTy = D->getType();
bool usedDifferentExceptionSpec = false;

if (const auto *FromFPT = D->getType()->getAs<FunctionProtoType>()) {
  FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
  // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
  // FunctionDecl that we are importing the FunctionProtoType for.
  // To avoid an infinite recursion when importing, create the FunctionDecl
  // with a simplified function type and update it afterwards.
  if (FromEPI.ExceptionSpec.SourceDecl ||
      FromEPI.ExceptionSpec.SourceTemplate ||
      FromEPI.ExceptionSpec.NoexceptExpr) {
    FunctionProtoType::ExtProtoInfo DefaultEPI;
    FromTy = Importer.getFromContext().getFunctionType(
        FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
    usedDifferentExceptionSpec = true;
  }
}

// Import the type.
QualType T = Importer.Import(FromTy);
if (T.isNull())
  return nullptr;

// Import the function parameters.
SmallVector<ParmVarDecl *, 8> Parameters;
for (auto P : D->parameters()) {
  auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
  if (!ToP)
    return nullptr;

  Parameters.push_back(ToP);
}

TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
if (D->getTypeSourceInfo() && !TInfo)
  return nullptr;

// Create the imported function.
FunctionDecl *ToFunction = nullptr;
SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
  if (GetImportedOrCreateDecl<CXXConstructorDecl>(
          ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
          InnerLocStart, NameInfo, T, TInfo, FromConstructor->isExplicit(),
          D->isInlineSpecified(), D->isImplicit(), D->isConstexpr()))
    return ToFunction;
  if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
    SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
    for (auto *I : FromConstructor->inits()) {
      auto *ToI = cast_or_null<CXXCtorInitializer>(Importer.Import(I));
      if (!ToI && I)
        return nullptr;
      CtorInitializers.push_back(ToI);
    }
    auto **Memory =
        new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
    std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
    auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
    ToCtor->setCtorInitializers(Memory);
    ToCtor->setNumCtorInitializers(NumInitializers);
  }
} else if (isa<CXXDestructorDecl>(D)) {
  if (GetImportedOrCreateDecl<CXXDestructorDecl>(
          ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
          InnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
          D->isImplicit()))
    return ToFunction;
} else if (CXXConversionDecl *FromConversion =
               dyn_cast<CXXConversionDecl>(D)) {
  if (GetImportedOrCreateDecl<CXXConversionDecl>(
          ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
          InnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
          FromConversion->isExplicit(), D->isConstexpr(), SourceLocation()))
    return ToFunction;
} else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
  if (GetImportedOrCreateDecl<CXXMethodDecl>(
          ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
          InnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
          Method->isInlineSpecified(), D->isConstexpr(), SourceLocation()))
    return ToFunction;
} else {
  if (GetImportedOrCreateDecl(ToFunction, D, Importer.getToContext(), DC,
                              InnerLocStart, NameInfo, T, TInfo,
                              D->getStorageClass(), D->isInlineSpecified(),
                              D->hasWrittenPrototype(), D->isConstexpr()))
    return ToFunction;
}

// Import the qualifier, if any.
ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
ToFunction->setAccess(D->getAccess());
ToFunction->setLexicalDeclContext(LexicalDC);
ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
ToFunction->setTrivial(D->isTrivial());
ToFunction->setPure(D->isPure());
ToFunction->setRangeEnd(Importer.Import(D->getLocEnd()));

// Set the parameters.
for (auto *Param : Parameters) {
  Param->setOwningFunction(ToFunction);
  ToFunction->addDeclInternal(Param);
}
ToFunction->setParams(Parameters);

if (FoundByLookup) {
  auto *Recent = const_cast<FunctionDecl *>(
        FoundByLookup->getMostRecentDecl());
  ToFunction->setPreviousDecl(Recent);
}

// We need to complete creation of FunctionProtoTypeLoc manually with setting
// params it refers to.
if (TInfo) {
  if (auto ProtoLoc =
      TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
    for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
      ProtoLoc.setParam(I, Parameters[I]);
  }
}

if (usedDifferentExceptionSpec) {
  // Update FunctionProtoType::ExtProtoInfo.
  QualType T = Importer.Import(D->getType());
  if (T.isNull())
    return nullptr;
  ToFunction->setType(T);
}

// Import the describing template function, if any.
if (FromFT)
  if (!Importer.Import(FromFT))
    return nullptr;

if (D->doesThisDeclarationHaveABody()) {
  if (Stmt *FromBody = D->getBody()) {
    if (Stmt *ToBody = Importer.Import(FromBody)) {
      ToFunction->setBody(ToBody);
    }
  }
}

// FIXME: Other bits to merge?

// If it is a template, import all related things.
if (ImportTemplateInformation(D, ToFunction))
  return nullptr;

bool IsFriend = D->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend);

// TODO Can we generalize this approach to other AST nodes as well?
if (D->getDeclContext()->containsDeclAndLoad(D))
  DC->addDeclInternal(ToFunction);
if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D))
  LexicalDC->addDeclInternal(ToFunction);

// Friend declaration's lexical context is the befriending class, but the
// semantic context is the enclosing scope of the befriending class.
// We want the friend functions to be found in the semantic context by lookup.
// FIXME should we handle this generically in VisitFriendDecl?
// In Other cases when LexicalDC != DC we don't want it to be added,
// e.g out-of-class definitions like void B::f() {} .
if (LexicalDC != DC && IsFriend) {
  DC->makeDeclVisibleInContext(ToFunction);
}

// Import the rest of the chain. I.e. import all subsequent declarations.
for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt)
  if (!Importer.Import(*RedeclIt))
    return nullptr;

if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
  ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod);

return ToFunction;
2808}

2810Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
return VisitFunctionDecl(D);
2812}

2814Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
return VisitCXXMethodDecl(D);
2816}

2818Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
return VisitCXXMethodDecl(D);
2820}

2822Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
return VisitCXXMethodDecl(D);
2824}

2826static unsigned getFieldIndex(Decl *F) {
auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
if (!Owner)
  return 0;

unsigned Index = 1;
for (const auto *D : Owner->noload_decls()) {
  if (D == F)
    return Index;

  if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
    ++Index;
}

return Index;
2841}

2843Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
// Import the major distinguishing characteristics of a variable.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// Determine whether we've already imported this field. 
SmallVector<NamedDecl *, 2> FoundDecls;
DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
for (auto *FoundDecl : FoundDecls) {
  if (auto *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
    // For anonymous fields, match up by index.
    if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
      continue;

    if (Importer.IsStructurallyEquivalent(D->getType(),
                                          FoundField->getType())) {
      Importer.MapImported(D, FoundField);
      return FoundField;
    }

    Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
      << Name << D->getType() << FoundField->getType();
    Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
      << FoundField->getType();
    return nullptr;
  }
}

// Import the type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
  return nullptr;

TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Expr *BitWidth = Importer.Import(D->getBitWidth());
if (!BitWidth && D->getBitWidth())
  return nullptr;

FieldDecl *ToField;
if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
                            Importer.Import(D->getInnerLocStart()), Loc,
                            Name.getAsIdentifierInfo(), T, TInfo, BitWidth,
                            D->isMutable(), D->getInClassInitStyle()))
  return ToField;

ToField->setAccess(D->getAccess());
ToField->setLexicalDeclContext(LexicalDC);
if (Expr *FromInitializer = D->getInClassInitializer()) {
  Expr *ToInitializer = Importer.Import(FromInitializer);
  if (ToInitializer)
    ToField->setInClassInitializer(ToInitializer);
  else
    return nullptr;
}
ToField->setImplicit(D->isImplicit());
LexicalDC->addDeclInternal(ToField);
return ToField;
2906}

2908Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
// Import the major distinguishing characteristics of a variable.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// Determine whether we've already imported this field. 
SmallVector<NamedDecl *, 2> FoundDecls;
DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
  if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
    // For anonymous indirect fields, match up by index.
    if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
      continue;

    if (Importer.IsStructurallyEquivalent(D->getType(),
                                          FoundField->getType(),
                                          !Name.isEmpty())) {
      Importer.MapImported(D, FoundField);
      return FoundField;
    }

    // If there are more anonymous fields to check, continue.
    if (!Name && I < N-1)
      continue;

    Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
      << Name << D->getType() << FoundField->getType();
    Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
      << FoundField->getType();
    return nullptr;
  }
}

// Import the type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
  return nullptr;

auto **NamedChain =
  new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];

unsigned i = 0;
for (auto *PI : D->chain()) {
  Decl *D = Importer.Import(PI);
  if (!D)
    return nullptr;
  NamedChain[i++] = cast<NamedDecl>(D);
}

llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
IndirectFieldDecl *ToIndirectField;
if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC,
                            Loc, Name.getAsIdentifierInfo(), T, CH))
  // FIXME here we leak `NamedChain` which is allocated before
  return ToIndirectField;

for (const auto *A : D->attrs())
  ToIndirectField->addAttr(Importer.Import(A));

ToIndirectField->setAccess(D->getAccess());
ToIndirectField->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToIndirectField);
return ToIndirectField;
2977}

2979Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
// Import the major distinguishing characteristics of a declaration.
DeclContext *DC = Importer.ImportContext(D->getDeclContext());
DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
    ? DC : Importer.ImportContext(D->getLexicalDeclContext());
if (!DC || !LexicalDC)
  return nullptr;

// Determine whether we've already imported this decl.
// FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
auto *RD = cast<CXXRecordDecl>(DC);
FriendDecl *ImportedFriend = RD->getFirstFriend();

while (ImportedFriend) {
  if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
    if (IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(),
                          /*Complain=*/false))
      return Importer.MapImported(D, ImportedFriend);

  } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
    if (Importer.IsStructurallyEquivalent(
          D->getFriendType()->getType(),
          ImportedFriend->getFriendType()->getType(), true))
      return Importer.MapImported(D, ImportedFriend);
  }
  ImportedFriend = ImportedFriend->getNextFriend();
}

// Not found. Create it.
FriendDecl::FriendUnion ToFU;
if (NamedDecl *FriendD = D->getFriendDecl()) {
  auto *ToFriendD = cast_or_null<NamedDecl>(Importer.Import(FriendD));
  if (ToFriendD && FriendD->getFriendObjectKind() != Decl::FOK_None &&
      !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
    ToFriendD->setObjectOfFriendDecl(false);

  ToFU = ToFriendD;
}  else // The friend is a type, not a decl.
  ToFU = Importer.Import(D->getFriendType());
if (!ToFU)
  return nullptr;

SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
for (unsigned I = 0; I < D->NumTPLists; I++) {
  TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
  if (!List)
    return nullptr;
  ToTPLists[I] = List;
}

FriendDecl *FrD;
if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
                            Importer.Import(D->getLocation()), ToFU,
                            Importer.Import(D->getFriendLoc()), ToTPLists))
  return FrD;

FrD->setAccess(D->getAccess());
FrD->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(FrD);
return FrD;
3040}

3042Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
// Import the major distinguishing characteristics of an ivar.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// Determine whether we've already imported this ivar
SmallVector<NamedDecl *, 2> FoundDecls;
DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
for (auto *FoundDecl : FoundDecls) {
  if (auto *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
    if (Importer.IsStructurallyEquivalent(D->getType(),
                                          FoundIvar->getType())) {
      Importer.MapImported(D, FoundIvar);
      return FoundIvar;
    }

    Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
      << Name << D->getType() << FoundIvar->getType();
    Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
      << FoundIvar->getType();
    return nullptr;
  }
}

// Import the type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
  return nullptr;

TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Expr *BitWidth = Importer.Import(D->getBitWidth());
if (!BitWidth && D->getBitWidth())
  return nullptr;

ObjCIvarDecl *ToIvar;
if (GetImportedOrCreateDecl(
        ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
        Importer.Import(D->getInnerLocStart()), Loc,
        Name.getAsIdentifierInfo(), T, TInfo, D->getAccessControl(), BitWidth,
        D->getSynthesize()))
  return ToIvar;

ToIvar->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToIvar);
return ToIvar;
3093}

3095Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
// Import the major distinguishing characteristics of a variable.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// Try to find a variable in our own ("to") context with the same name and
// in the same context as the variable we're importing.
if (D->isFileVarDecl()) {
  VarDecl *MergeWithVar = nullptr;
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  unsigned IDNS = Decl::IDNS_Ordinary;
  SmallVector<NamedDecl *, 2> FoundDecls;
  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;

    if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
      // We have found a variable that we may need to merge with. Check it.
      if (FoundVar->hasExternalFormalLinkage() &&
          D->hasExternalFormalLinkage()) {
        if (Importer.IsStructurallyEquivalent(D->getType(),
                                              FoundVar->getType())) {
          MergeWithVar = FoundVar;
          break;
        }

        const ArrayType *FoundArray
          = Importer.getToContext().getAsArrayType(FoundVar->getType());
        const ArrayType *TArray
          = Importer.getToContext().getAsArrayType(D->getType());
        if (FoundArray && TArray) {
          if (isa<IncompleteArrayType>(FoundArray) &&
              isa<ConstantArrayType>(TArray)) {
            // Import the type.
            QualType T = Importer.Import(D->getType());
            if (T.isNull())
              return nullptr;

            FoundVar->setType(T);
            MergeWithVar = FoundVar;
            break;
          } else if (isa<IncompleteArrayType>(TArray) &&
                     isa<ConstantArrayType>(FoundArray)) {
            MergeWithVar = FoundVar;
            break;
          }
        }

        Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
          << Name << D->getType() << FoundVar->getType();
        Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
          << FoundVar->getType();
      }
    }
    
    ConflictingDecls.push_back(FoundDecl);
  }

  if (MergeWithVar) {
    // An equivalent variable with external linkage has been found. Link
    // the two declarations, then merge them.
    Importer.MapImported(D, MergeWithVar);
    updateFlags(D, MergeWithVar);

    if (VarDecl *DDef = D->getDefinition()) {
      if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
        Importer.ToDiag(ExistingDef->getLocation(), 
                        diag::err_odr_variable_multiple_def)
          << Name;
        Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
      } else {
        Expr *Init = Importer.Import(DDef->getInit());
        MergeWithVar->setInit(Init);
        if (DDef->isInitKnownICE()) {
          EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
          Eval->CheckedICE = true;
          Eval->IsICE = DDef->isInitICE();
        }
      }
    }
    
    return MergeWithVar;
  }
  
  if (!ConflictingDecls.empty()) {
    Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                       ConflictingDecls.data(), 
                                       ConflictingDecls.size());
    if (!Name)
      return nullptr;
  }
}
  
// Import the type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
  return nullptr;

// Create the imported variable.
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
VarDecl *ToVar;
if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC,
                            Importer.Import(D->getInnerLocStart()), Loc,
                            Name.getAsIdentifierInfo(), T, TInfo,
                            D->getStorageClass()))
  return ToVar;

ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
ToVar->setAccess(D->getAccess());
ToVar->setLexicalDeclContext(LexicalDC);

// Templated declarations should never appear in the enclosing DeclContext.
if (!D->getDescribedVarTemplate())
  LexicalDC->addDeclInternal(ToVar);

// Merge the initializer.
if (ImportDefinition(D, ToVar))
  return nullptr;

if (D->isConstexpr())
  ToVar->setConstexpr(true);

return ToVar;
3225}

3227Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
// Parameters are created in the translation unit's context, then moved
// into the function declaration's context afterward.
DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();

// Import the name of this declaration.
DeclarationName Name = Importer.Import(D->getDeclName());
if (D->getDeclName() && !Name)
  return nullptr;

// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());

// Import the parameter's type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
  return nullptr;

// Create the imported parameter.
ImplicitParamDecl *ToParm = nullptr;
if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC, Loc,
                            Name.getAsIdentifierInfo(), T,
                            D->getParameterKind()))
  return ToParm;
return ToParm;
3252}

3254Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
// Parameters are created in the translation unit's context, then moved
// into the function declaration's context afterward.
DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();

// Import the name of this declaration.
DeclarationName Name = Importer.Import(D->getDeclName());
if (D->getDeclName() && !Name)
  return nullptr;

// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());

// Import the parameter's type.
QualType T = Importer.Import(D->getType());
if (T.isNull())
  return nullptr;

// Create the imported parameter.
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
ParmVarDecl *ToParm;
if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
                            Importer.Import(D->getInnerLocStart()), Loc,
                            Name.getAsIdentifierInfo(), T, TInfo,
                            D->getStorageClass(),
                            /*DefaultArg*/ nullptr))
  return ToParm;

// Set the default argument.
ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
ToParm->setKNRPromoted(D->isKNRPromoted());

Expr *ToDefArg = nullptr;
Expr *FromDefArg = nullptr;
if (D->hasUninstantiatedDefaultArg()) {
  FromDefArg = D->getUninstantiatedDefaultArg();
  ToDefArg = Importer.Import(FromDefArg);
  ToParm->setUninstantiatedDefaultArg(ToDefArg);
} else if (D->hasUnparsedDefaultArg()) {
  ToParm->setUnparsedDefaultArg();
} else if (D->hasDefaultArg()) {
  FromDefArg = D->getDefaultArg();
  ToDefArg = Importer.Import(FromDefArg);
  ToParm->setDefaultArg(ToDefArg);
}
if (FromDefArg && !ToDefArg)
  return nullptr;

if (D->isObjCMethodParameter()) {
  ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
  ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
} else {
  ToParm->setScopeInfo(D->getFunctionScopeDepth(),
                       D->getFunctionScopeIndex());
}

return ToParm;
3311}

3313Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
// Import the major distinguishing characteristics of a method.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

SmallVector<NamedDecl *, 2> FoundDecls;
DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
for (auto *FoundDecl : FoundDecls) {
  if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
    if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
      continue;

    // Check return types.
    if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
                                           FoundMethod->getReturnType())) {
      Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
          << D->isInstanceMethod() << Name << D->getReturnType()
          << FoundMethod->getReturnType();
      Importer.ToDiag(FoundMethod->getLocation(), 
                      diag::note_odr_objc_method_here)
        << D->isInstanceMethod() << Name;
      return nullptr;
    }

    // Check the number of parameters.
    if (D->param_size() != FoundMethod->param_size()) {
      Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
        << D->isInstanceMethod() << Name
        << D->param_size() << FoundMethod->param_size();
      Importer.ToDiag(FoundMethod->getLocation(), 
                      diag::note_odr_objc_method_here)
        << D->isInstanceMethod() << Name;
      return nullptr;
    }

    // Check parameter types.
    for (ObjCMethodDecl::param_iterator P = D->param_begin(),
           PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
         P != PEnd; ++P, ++FoundP) {
      if (!Importer.IsStructurallyEquivalent((*P)->getType(),
                                             (*FoundP)->getType())) {
        Importer.FromDiag((*P)->getLocation(),
                          diag::err_odr_objc_method_param_type_inconsistent)
          << D->isInstanceMethod() << Name
          << (*P)->getType() << (*FoundP)->getType();
        Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
          << (*FoundP)->getType();
        return nullptr;
      }
    }

    // Check variadic/non-variadic.
    // Check the number of parameters.
    if (D->isVariadic() != FoundMethod->isVariadic()) {
      Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
        << D->isInstanceMethod() << Name;
      Importer.ToDiag(FoundMethod->getLocation(), 
                      diag::note_odr_objc_method_here)
        << D->isInstanceMethod() << Name;
      return nullptr;
    }

    // FIXME: Any other bits we need to merge?
    return Importer.MapImported(D, FoundMethod);
  }
}

// Import the result type.
QualType ResultTy = Importer.Import(D->getReturnType());
if (ResultTy.isNull())
  return nullptr;

TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());

ObjCMethodDecl *ToMethod;
if (GetImportedOrCreateDecl(
        ToMethod, D, Importer.getToContext(), Loc,
        Importer.Import(D->getLocEnd()), Name.getObjCSelector(), ResultTy,
        ReturnTInfo, DC, D->isInstanceMethod(), D->isVariadic(),
        D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
        D->getImplementationControl(), D->hasRelatedResultType()))
  return ToMethod;

// FIXME: When we decide to merge method definitions, we'll need to
// deal with implicit parameters.

// Import the parameters
SmallVector<ParmVarDecl *, 5> ToParams;
for (auto *FromP : D->parameters()) {
  auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
  if (!ToP)
    return nullptr;

  ToParams.push_back(ToP);
}

// Set the parameters.
for (auto *ToParam : ToParams) {
  ToParam->setOwningFunction(ToMethod);
  ToMethod->addDeclInternal(ToParam);
}

SmallVector<SourceLocation, 12> SelLocs;
D->getSelectorLocs(SelLocs);
for (auto &Loc : SelLocs)
  Loc = Importer.Import(Loc);

ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);

ToMethod->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToMethod);
return ToMethod;
3431}

3433Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
// Import the major distinguishing characteristics of a category.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
if (!BoundInfo)
  return nullptr;

ObjCTypeParamDecl *Result;
if (GetImportedOrCreateDecl(
        Result, D, Importer.getToContext(), DC, D->getVariance(),
        Importer.Import(D->getVarianceLoc()), D->getIndex(),
        Importer.Import(D->getLocation()), Name.getAsIdentifierInfo(),
        Importer.Import(D->getColonLoc()), BoundInfo))
  return Result;

Result->setLexicalDeclContext(LexicalDC);
return Result;
3458}

3460Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
// Import the major distinguishing characteristics of a category.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

auto *ToInterface =
    cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
if (!ToInterface)
  return nullptr;

// Determine if we've already encountered this category.
ObjCCategoryDecl *MergeWithCategory
  = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
ObjCCategoryDecl *ToCategory = MergeWithCategory;
if (!ToCategory) {

  if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
                              Importer.Import(D->getAtStartLoc()), Loc,
                              Importer.Import(D->getCategoryNameLoc()),
                              Name.getAsIdentifierInfo(), ToInterface,
                              /*TypeParamList=*/nullptr,
                              Importer.Import(D->getIvarLBraceLoc()),
                              Importer.Import(D->getIvarRBraceLoc())))
    return ToCategory;

  ToCategory->setLexicalDeclContext(LexicalDC);
  LexicalDC->addDeclInternal(ToCategory);
  // Import the type parameter list after calling Imported, to avoid
  // loops when bringing in their DeclContext.
  ToCategory->setTypeParamList(ImportObjCTypeParamList(
                                 D->getTypeParamList()));
  
  // Import protocols
  SmallVector<ObjCProtocolDecl *, 4> Protocols;
  SmallVector<SourceLocation, 4> ProtocolLocs;
  ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
    = D->protocol_loc_begin();
  for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
                                        FromProtoEnd = D->protocol_end();
       FromProto != FromProtoEnd;
       ++FromProto, ++FromProtoLoc) {
    auto *ToProto =
        cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
    if (!ToProto)
      return nullptr;
    Protocols.push_back(ToProto);
    ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
  }
  
  // FIXME: If we're merging, make sure that the protocol list is the same.
  ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
                              ProtocolLocs.data(), Importer.getToContext());
} else {
  Importer.MapImported(D, ToCategory);
}

// Import all of the members of this category.
ImportDeclContext(D);

// If we have an implementation, import it as well.
if (D->getImplementation()) {
  auto *Impl =
      cast_or_null<ObjCCategoryImplDecl>(
                                     Importer.Import(D->getImplementation()));
  if (!Impl)
    return nullptr;

  ToCategory->setImplementation(Impl);
}

return ToCategory;
3537}

3539bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From, 
                                     ObjCProtocolDecl *To,
                                     ImportDefinitionKind Kind) {
if (To->getDefinition()) {
  if (shouldForceImportDeclContext(Kind))
    ImportDeclContext(From);
  return false;
}

// Start the protocol definition
To->startDefinition();

// Import protocols
SmallVector<ObjCProtocolDecl *, 4> Protocols;
SmallVector<SourceLocation, 4> ProtocolLocs;
ObjCProtocolDecl::protocol_loc_iterator 
FromProtoLoc = From->protocol_loc_begin();
for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
                                      FromProtoEnd = From->protocol_end();
     FromProto != FromProtoEnd;
     ++FromProto, ++FromProtoLoc) {
  auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
  if (!ToProto)
    return true;
  Protocols.push_back(ToProto);
  ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
}

// FIXME: If we're merging, make sure that the protocol list is the same.
To->setProtocolList(Protocols.data(), Protocols.size(),
                    ProtocolLocs.data(), Importer.getToContext());

if (shouldForceImportDeclContext(Kind)) {
  // Import all of the members of this protocol.
  ImportDeclContext(From, /*ForceImport=*/true);
}
return false;
3576}

3578Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
// If this protocol has a definition in the translation unit we're coming 
// from, but this particular declaration is not that definition, import the
// definition and map to that.
ObjCProtocolDecl *Definition = D->getDefinition();
if (Definition && Definition != D) {
  Decl *ImportedDef = Importer.Import(Definition);
  if (!ImportedDef)
    return nullptr;

  return Importer.MapImported(D, ImportedDef);
}

// Import the major distinguishing characteristics of a protocol.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

ObjCProtocolDecl *MergeWithProtocol = nullptr;
SmallVector<NamedDecl *, 2> FoundDecls;
DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
for (auto *FoundDecl : FoundDecls) {
  if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
    continue;
  
  if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
    break;
}

ObjCProtocolDecl *ToProto = MergeWithProtocol;
if (!ToProto) {
  if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC,
                              Name.getAsIdentifierInfo(), Loc,
                              Importer.Import(D->getAtStartLoc()),
                              /*PrevDecl=*/nullptr))
    return ToProto;
  ToProto->setLexicalDeclContext(LexicalDC);
  LexicalDC->addDeclInternal(ToProto);
}

Importer.MapImported(D, ToProto);

if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
  return nullptr;

return ToProto;
3629}

3631Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
DeclContext *DC = Importer.ImportContext(D->getDeclContext());
DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());

SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
SourceLocation LangLoc = Importer.Import(D->getLocation());

bool HasBraces = D->hasBraces();

LinkageSpecDecl *ToLinkageSpec;
if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC,
                            ExternLoc, LangLoc, D->getLanguage(), HasBraces))
  return ToLinkageSpec;

if (HasBraces) {
  SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
  ToLinkageSpec->setRBraceLoc(RBraceLoc);
}

ToLinkageSpec->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToLinkageSpec);

return ToLinkageSpec;
3654}

3656Decl *ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

DeclarationNameInfo NameInfo(Name,
                             Importer.Import(D->getNameInfo().getLoc()));
ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);

UsingDecl *ToUsing;
if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
                            Importer.Import(D->getUsingLoc()),
                            Importer.Import(D->getQualifierLoc()), NameInfo,
                            D->hasTypename()))
  return ToUsing;

ToUsing->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToUsing);

if (NamedDecl *FromPattern =
    Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
  if (auto *ToPattern =
          dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern)))
    Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, ToPattern);
  else
    return nullptr;
}

for (auto *FromShadow : D->shadows()) {
  if (auto *ToShadow =
          dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow)))
    ToUsing->addShadowDecl(ToShadow);
  else
    // FIXME: We return a nullptr here but the definition is already created
    // and available with lookups. How to fix this?..
    return nullptr;
}
return ToUsing;
3699}

3701Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

auto *ToUsing = dyn_cast_or_null<UsingDecl>(
    Importer.Import(D->getUsingDecl()));
if (!ToUsing)
  return nullptr;

auto *ToTarget = dyn_cast_or_null<NamedDecl>(
    Importer.Import(D->getTargetDecl()));
if (!ToTarget)
  return nullptr;

UsingShadowDecl *ToShadow;
if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
                            ToUsing, ToTarget))
  return ToShadow;

ToShadow->setLexicalDeclContext(LexicalDC);
ToShadow->setAccess(D->getAccess());

if (UsingShadowDecl *FromPattern =
    Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
  if (auto *ToPattern =
          dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern)))
    Importer.getToContext().setInstantiatedFromUsingShadowDecl(ToShadow,
                                                               ToPattern);
  else
    // FIXME: We return a nullptr here but the definition is already created
    // and available with lookups. How to fix this?..
    return nullptr;
}

LexicalDC->addDeclInternal(ToShadow);

return ToShadow;
3744}

3746Decl *ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

DeclContext *ToComAncestor = Importer.ImportContext(D->getCommonAncestor());
if (!ToComAncestor)
  return nullptr;

auto *ToNominated = cast_or_null<NamespaceDecl>(
    Importer.Import(D->getNominatedNamespace()));
if (!ToNominated)
  return nullptr;

UsingDirectiveDecl *ToUsingDir;
if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
                            Importer.Import(D->getUsingLoc()),
                            Importer.Import(D->getNamespaceKeyLocation()),
                            Importer.Import(D->getQualifierLoc()),
                            Importer.Import(D->getIdentLocation()),
                            ToNominated, ToComAncestor))
  return ToUsingDir;

ToUsingDir->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToUsingDir);

return ToUsingDir;
3778}

3780Decl *ASTNodeImporter::VisitUnresolvedUsingValueDecl(
  UnresolvedUsingValueDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

DeclarationNameInfo NameInfo(Name, Importer.Import(D->getNameInfo().getLoc()));
ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);

UnresolvedUsingValueDecl *ToUsingValue;
if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
                            Importer.Import(D->getUsingLoc()),
                            Importer.Import(D->getQualifierLoc()), NameInfo,
                            Importer.Import(D->getEllipsisLoc())))
  return ToUsingValue;

ToUsingValue->setAccess(D->getAccess());
ToUsingValue->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToUsingValue);

return ToUsingValue;
3806}

3808Decl *ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
  UnresolvedUsingTypenameDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

UnresolvedUsingTypenameDecl *ToUsing;
if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
                            Importer.Import(D->getUsingLoc()),
                            Importer.Import(D->getTypenameLoc()),
                            Importer.Import(D->getQualifierLoc()), Loc, Name,
                            Importer.Import(D->getEllipsisLoc())))
  return ToUsing;

ToUsing->setAccess(D->getAccess());
ToUsing->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToUsing);

return ToUsing;
3832}

3834bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From, 
                                     ObjCInterfaceDecl *To,
                                     ImportDefinitionKind Kind) {
if (To->getDefinition()) {
  // Check consistency of superclass.
  ObjCInterfaceDecl *FromSuper = From->getSuperClass();
  if (FromSuper) {
    FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
    if (!FromSuper)
      return true;
  }
  
  ObjCInterfaceDecl *ToSuper = To->getSuperClass();    
  if ((bool)FromSuper != (bool)ToSuper ||
      (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
    Importer.ToDiag(To->getLocation(), 
                    diag::err_odr_objc_superclass_inconsistent)
      << To->getDeclName();
    if (ToSuper)
      Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
        << To->getSuperClass()->getDeclName();
    else
      Importer.ToDiag(To->getLocation(), 
                      diag::note_odr_objc_missing_superclass);
    if (From->getSuperClass())
      Importer.FromDiag(From->getSuperClassLoc(), 
                        diag::note_odr_objc_superclass)
      << From->getSuperClass()->getDeclName();
    else
      Importer.FromDiag(From->getLocation(), 
                        diag::note_odr_objc_missing_superclass);        
  }
  
  if (shouldForceImportDeclContext(Kind))
    ImportDeclContext(From);
  return false;
}

// Start the definition.
To->startDefinition();

// If this class has a superclass, import it.
if (From->getSuperClass()) {
  TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
  if (!SuperTInfo)
    return true;

  To->setSuperClass(SuperTInfo);
}

// Import protocols
SmallVector<ObjCProtocolDecl *, 4> Protocols;
SmallVector<SourceLocation, 4> ProtocolLocs;
ObjCInterfaceDecl::protocol_loc_iterator 
FromProtoLoc = From->protocol_loc_begin();

for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
                                       FromProtoEnd = From->protocol_end();
     FromProto != FromProtoEnd;
     ++FromProto, ++FromProtoLoc) {
  auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
  if (!ToProto)
    return true;
  Protocols.push_back(ToProto);
  ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
}

// FIXME: If we're merging, make sure that the protocol list is the same.
To->setProtocolList(Protocols.data(), Protocols.size(),
                    ProtocolLocs.data(), Importer.getToContext());

// Import categories. When the categories themselves are imported, they'll
// hook themselves into this interface.
for (auto *Cat : From->known_categories())
  Importer.Import(Cat);

// If we have an @implementation, import it as well.
if (From->getImplementation()) {
  auto *Impl = cast_or_null<ObjCImplementationDecl>(
      Importer.Import(From->getImplementation()));
  if (!Impl)
    return true;
  
  To->setImplementation(Impl);
}

if (shouldForceImportDeclContext(Kind)) {
  // Import all of the members of this class.
  ImportDeclContext(From, /*ForceImport=*/true);
}
return false;
3925}

3927ObjCTypeParamList *
3928ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
if (!list)
  return nullptr;

SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
for (auto fromTypeParam : *list) {
  auto *toTypeParam = cast_or_null<ObjCTypeParamDecl>(
      Importer.Import(fromTypeParam));
  if (!toTypeParam)
    return nullptr;

  toTypeParams.push_back(toTypeParam);
}

return ObjCTypeParamList::create(Importer.getToContext(),
                                 Importer.Import(list->getLAngleLoc()),
                                 toTypeParams,
                                 Importer.Import(list->getRAngleLoc()));
3946}

3948Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
// If this class has a definition in the translation unit we're coming from,
// but this particular declaration is not that definition, import the
// definition and map to that.
ObjCInterfaceDecl *Definition = D->getDefinition();
if (Definition && Definition != D) {
  Decl *ImportedDef = Importer.Import(Definition);
  if (!ImportedDef)
    return nullptr;

  return Importer.MapImported(D, ImportedDef);
}

// Import the major distinguishing characteristics of an @interface.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// Look for an existing interface with the same name.
ObjCInterfaceDecl *MergeWithIface = nullptr;
SmallVector<NamedDecl *, 2> FoundDecls;
DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
for (auto *FoundDecl : FoundDecls) {
  if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
    continue;
  
  if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
    break;
}

// Create an interface declaration, if one does not already exist.
ObjCInterfaceDecl *ToIface = MergeWithIface;
if (!ToIface) {
  if (GetImportedOrCreateDecl(
          ToIface, D, Importer.getToContext(), DC,
          Importer.Import(D->getAtStartLoc()), Name.getAsIdentifierInfo(),
          /*TypeParamList=*/nullptr,
          /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl()))
    return ToIface;
  ToIface->setLexicalDeclContext(LexicalDC);
  LexicalDC->addDeclInternal(ToIface);
}
Importer.MapImported(D, ToIface);
// Import the type parameter list after calling Imported, to avoid
// loops when bringing in their DeclContext.
ToIface->setTypeParamList(ImportObjCTypeParamList(
                            D->getTypeParamListAsWritten()));

if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
  return nullptr;

return ToIface;
4005}

4007Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
auto *Category = cast_or_null<ObjCCategoryDecl>(
    Importer.Import(D->getCategoryDecl()));
if (!Category)
  return nullptr;

ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
if (!ToImpl) {
  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
  if (!DC)
    return nullptr;

  SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
  if (GetImportedOrCreateDecl(
          ToImpl, D, Importer.getToContext(), DC,
          Importer.Import(D->getIdentifier()), Category->getClassInterface(),
          Importer.Import(D->getLocation()),
          Importer.Import(D->getAtStartLoc()), CategoryNameLoc))
    return ToImpl;

  DeclContext *LexicalDC = DC;
  if (D->getDeclContext() != D->getLexicalDeclContext()) {
    LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
    if (!LexicalDC)
      return nullptr;

    ToImpl->setLexicalDeclContext(LexicalDC);
  }
  
  LexicalDC->addDeclInternal(ToImpl);
  Category->setImplementation(ToImpl);
}

Importer.MapImported(D, ToImpl);
ImportDeclContext(D);
return ToImpl;
4043}

4045Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
// Find the corresponding interface.
auto *Iface = cast_or_null<ObjCInterfaceDecl>(
    Importer.Import(D->getClassInterface()));
if (!Iface)
  return nullptr;

// Import the superclass, if any.
ObjCInterfaceDecl *Super = nullptr;
if (D->getSuperClass()) {
  Super = cast_or_null<ObjCInterfaceDecl>(
                                        Importer.Import(D->getSuperClass()));
  if (!Super)
    return nullptr;
}

ObjCImplementationDecl *Impl = Iface->getImplementation();
if (!Impl) {
  // We haven't imported an implementation yet. Create a new @implementation
  // now.
  if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
                              Importer.ImportContext(D->getDeclContext()),
                              Iface, Super, Importer.Import(D->getLocation()),
                              Importer.Import(D->getAtStartLoc()),
                              Importer.Import(D->getSuperClassLoc()),
                              Importer.Import(D->getIvarLBraceLoc()),
                              Importer.Import(D->getIvarRBraceLoc())))
    return Impl;

  if (D->getDeclContext() != D->getLexicalDeclContext()) {
    DeclContext *LexicalDC
      = Importer.ImportContext(D->getLexicalDeclContext());
    if (!LexicalDC)
      return nullptr;
    Impl->setLexicalDeclContext(LexicalDC);
  }

  // Associate the implementation with the class it implements.
  Iface->setImplementation(Impl);
  Importer.MapImported(D, Iface->getImplementation());
} else {
  Importer.MapImported(D, Iface->getImplementation());

  // Verify that the existing @implementation has the same superclass.
  if ((Super && !Impl->getSuperClass()) ||
      (!Super && Impl->getSuperClass()) ||
      (Super && Impl->getSuperClass() &&
       !declaresSameEntity(Super->getCanonicalDecl(),
                           Impl->getSuperClass()))) {
    Importer.ToDiag(Impl->getLocation(),
                    diag::err_odr_objc_superclass_inconsistent)
      << Iface->getDeclName();
    // FIXME: It would be nice to have the location of the superclass
    // below.
    if (Impl->getSuperClass())
      Importer.ToDiag(Impl->getLocation(),
                      diag::note_odr_objc_superclass)
      << Impl->getSuperClass()->getDeclName();
    else
      Importer.ToDiag(Impl->getLocation(),
                      diag::note_odr_objc_missing_superclass);
    if (D->getSuperClass())
      Importer.FromDiag(D->getLocation(),
                        diag::note_odr_objc_superclass)
      << D->getSuperClass()->getDeclName();
    else
      Importer.FromDiag(D->getLocation(),
                        diag::note_odr_objc_missing_superclass);
    return nullptr;
  }
}
  
// Import all of the members of this @implementation.
ImportDeclContext(D);

return Impl;
4121}

4123Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
// Import the major distinguishing characteristics of an @property.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// Check whether we have already imported this property.
SmallVector<NamedDecl *, 2> FoundDecls;
DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
for (auto *FoundDecl : FoundDecls) {
  if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
    // Check property types.
    if (!Importer.IsStructurallyEquivalent(D->getType(),
                                           FoundProp->getType())) {
      Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
        << Name << D->getType() << FoundProp->getType();
      Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
        << FoundProp->getType();
      return nullptr;
    }

    // FIXME: Check property attributes, getters, setters, etc.?

    // Consider these properties to be equivalent.
    Importer.MapImported(D, FoundProp);
    return FoundProp;
  }
}

// Import the type.
TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
if (!TSI)
  return nullptr;

// Create the new property.
ObjCPropertyDecl *ToProperty;
if (GetImportedOrCreateDecl(
        ToProperty, D, Importer.getToContext(), DC, Loc,
        Name.getAsIdentifierInfo(), Importer.Import(D->getAtLoc()),
        Importer.Import(D->getLParenLoc()), Importer.Import(D->getType()),
        TSI, D->getPropertyImplementation()))
  return ToProperty;

ToProperty->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToProperty);

ToProperty->setPropertyAttributes(D->getPropertyAttributes());
ToProperty->setPropertyAttributesAsWritten(
                                    D->getPropertyAttributesAsWritten());
ToProperty->setGetterName(Importer.Import(D->getGetterName()),
                          Importer.Import(D->getGetterNameLoc()));
ToProperty->setSetterName(Importer.Import(D->getSetterName()),
                          Importer.Import(D->getSetterNameLoc()));
ToProperty->setGetterMethodDecl(
   cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
ToProperty->setSetterMethodDecl(
   cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
ToProperty->setPropertyIvarDecl(
     cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
return ToProperty;
4188}

4190Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
auto *Property = cast_or_null<ObjCPropertyDecl>(
    Importer.Import(D->getPropertyDecl()));
if (!Property)
  return nullptr;

DeclContext *DC = Importer.ImportContext(D->getDeclContext());
if (!DC)
  return nullptr;

// Import the lexical declaration context.
DeclContext *LexicalDC = DC;
if (D->getDeclContext() != D->getLexicalDeclContext()) {
  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
  if (!LexicalDC)
    return nullptr;
}

auto *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
if (!InImpl)
  return nullptr;

// Import the ivar (for an @synthesize).
ObjCIvarDecl *Ivar = nullptr;
if (D->getPropertyIvarDecl()) {
  Ivar = cast_or_null<ObjCIvarDecl>(
                                  Importer.Import(D->getPropertyIvarDecl()));
  if (!Ivar)
    return nullptr;
}

ObjCPropertyImplDecl *ToImpl
  = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
                                 Property->getQueryKind());
if (!ToImpl) {
  if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
                              Importer.Import(D->getLocStart()),
                              Importer.Import(D->getLocation()), Property,
                              D->getPropertyImplementation(), Ivar,
                              Importer.Import(D->getPropertyIvarDeclLoc())))
    return ToImpl;

  ToImpl->setLexicalDeclContext(LexicalDC);
  LexicalDC->addDeclInternal(ToImpl);
} else {
  // Check that we have the same kind of property implementation (@synthesize
  // vs. @dynamic).
  if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
    Importer.ToDiag(ToImpl->getLocation(), 
                    diag::err_odr_objc_property_impl_kind_inconsistent)
      << Property->getDeclName() 
      << (ToImpl->getPropertyImplementation() 
                                            == ObjCPropertyImplDecl::Dynamic);
    Importer.FromDiag(D->getLocation(),
                      diag::note_odr_objc_property_impl_kind)
      << D->getPropertyDecl()->getDeclName()
      << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
    return nullptr;
  }
  
  // For @synthesize, check that we have the same 
  if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
      Ivar != ToImpl->getPropertyIvarDecl()) {
    Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(), 
                    diag::err_odr_objc_synthesize_ivar_inconsistent)
      << Property->getDeclName()
      << ToImpl->getPropertyIvarDecl()->getDeclName()
      << Ivar->getDeclName();
    Importer.FromDiag(D->getPropertyIvarDeclLoc(), 
                      diag::note_odr_objc_synthesize_ivar_here)
      << D->getPropertyIvarDecl()->getDeclName();
    return nullptr;
  }
  
  // Merge the existing implementation with the new implementation.
  Importer.MapImported(D, ToImpl);
}

return ToImpl;
4269}

4271Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
// For template arguments, we adopt the translation unit as our declaration
// context. This context will be fixed when the actual template declaration
// is created.

// FIXME: Import default argument.
TemplateTypeParmDecl *ToD = nullptr;
(void)GetImportedOrCreateDecl(
    ToD, D, Importer.getToContext(),
    Importer.getToContext().getTranslationUnitDecl(),
    Importer.Import(D->getLocStart()), Importer.Import(D->getLocation()),
    D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
    D->wasDeclaredWithTypename(), D->isParameterPack());
return ToD;
4285}

4287Decl *
4288ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
// Import the name of this declaration.
DeclarationName Name = Importer.Import(D->getDeclName());
if (D->getDeclName() && !Name)
  return nullptr;

// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());

// Import the type of this declaration.
QualType T = Importer.Import(D->getType());
if (T.isNull())
  return nullptr;

// Import type-source information.
TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
if (D->getTypeSourceInfo() && !TInfo)
  return nullptr;

// FIXME: Import default argument.

NonTypeTemplateParmDecl *ToD = nullptr;
(void)GetImportedOrCreateDecl(
    ToD, D, Importer.getToContext(),
    Importer.getToContext().getTranslationUnitDecl(),
    Importer.Import(D->getInnerLocStart()), Loc, D->getDepth(),
    D->getPosition(), Name.getAsIdentifierInfo(), T, D->isParameterPack(),
    TInfo);
return ToD;
4317}

4319Decl *
4320ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
// Import the name of this declaration.
DeclarationName Name = Importer.Import(D->getDeclName());
if (D->getDeclName() && !Name)
  return nullptr;

// Import the location of this declaration.
SourceLocation Loc = Importer.Import(D->getLocation());

// Import template parameters.
TemplateParameterList *TemplateParams
  = ImportTemplateParameterList(D->getTemplateParameters());
if (!TemplateParams)
  return nullptr;

// FIXME: Import default argument.

TemplateTemplateParmDecl *ToD = nullptr;
(void)GetImportedOrCreateDecl(
    ToD, D, Importer.getToContext(),
    Importer.getToContext().getTranslationUnitDecl(), Loc, D->getDepth(),
    D->getPosition(), D->isParameterPack(), Name.getAsIdentifierInfo(),
    TemplateParams);
return ToD;
4344}

4346// Returns the definition for a (forward) declaration of a ClassTemplateDecl, if
4347// it has any definition in the redecl chain.
4348static ClassTemplateDecl *getDefinition(ClassTemplateDecl *D) {
CXXRecordDecl *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
if (!ToTemplatedDef)
  return nullptr;
ClassTemplateDecl *TemplateWithDef =
    ToTemplatedDef->getDescribedClassTemplate();
return TemplateWithDef;
4355}

4357Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
// If this record has a definition in the translation unit we're coming from,
// but this particular declaration is not that definition, import the
// definition and map to that.
auto *Definition =
    cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
if (Definition && Definition != D->getTemplatedDecl()) {
  Decl *ImportedDef
    = Importer.Import(Definition->getDescribedClassTemplate());
  if (!ImportedDef)
    return nullptr;

  return Importer.MapImported(D, ImportedDef);
}

// Import the major distinguishing characteristics of this class template.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// We may already have a template of the same name; try to find and match it.
if (!DC->isFunctionOrMethod()) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  SmallVector<NamedDecl *, 2> FoundDecls;
  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
      continue;

    Decl *Found = FoundDecl;
    if (auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found)) {

      // The class to be imported is a definition.
      if (D->isThisDeclarationADefinition()) {
        // Lookup will find the fwd decl only if that is more recent than the
        // definition. So, try to get the definition if that is available in
        // the redecl chain.
        ClassTemplateDecl *TemplateWithDef = getDefinition(FoundTemplate);
        if (!TemplateWithDef)
          continue;
        FoundTemplate = TemplateWithDef; // Continue with the definition.
      }

      if (IsStructuralMatch(D, FoundTemplate)) {
        // The class templates structurally match; call it the same template.

        Importer.MapImported(D->getTemplatedDecl(),
                             FoundTemplate->getTemplatedDecl());
        return Importer.MapImported(D, FoundTemplate);
      }
    }

    ConflictingDecls.push_back(FoundDecl);
  }

  if (!ConflictingDecls.empty()) {
    Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
                                       ConflictingDecls.data(),
                                       ConflictingDecls.size());
  }

  if (!Name)
    return nullptr;
}

CXXRecordDecl *FromTemplated = D->getTemplatedDecl();

// Create the declaration that is being templated.
auto *ToTemplated = cast_or_null<CXXRecordDecl>(
    Importer.Import(FromTemplated));
if (!ToTemplated)
  return nullptr;

// Create the class template declaration itself.
TemplateParameterList *TemplateParams =
    ImportTemplateParameterList(D->getTemplateParameters());
if (!TemplateParams)
  return nullptr;

ClassTemplateDecl *D2;
if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
                            TemplateParams, ToTemplated))
  return D2;

ToTemplated->setDescribedClassTemplate(D2);

D2->setAccess(D->getAccess());
D2->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(D2);

if (FromTemplated->isCompleteDefinition() &&
    !ToTemplated->isCompleteDefinition()) {
  // FIXME: Import definition!
}

return D2;
4458}

4460Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
                                        ClassTemplateSpecializationDecl *D) {
// If this record has a definition in the translation unit we're coming from,
// but this particular declaration is not that definition, import the
// definition and map to that.
TagDecl *Definition = D->getDefinition();
if (Definition && Definition != D) {
  Decl *ImportedDef = Importer.Import(Definition);
  if (!ImportedDef)
    return nullptr;

  return Importer.MapImported(D, ImportedDef);
}

auto *ClassTemplate =
    cast_or_null<ClassTemplateDecl>(Importer.Import(
                                               D->getSpecializedTemplate()));
if (!ClassTemplate)
  return nullptr;

// Import the context of this declaration.
DeclContext *DC = ClassTemplate->getDeclContext();
if (!DC)
  return nullptr;

DeclContext *LexicalDC = DC;
if (D->getDeclContext() != D->getLexicalDeclContext()) {
  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
  if (!LexicalDC)
    return nullptr;
}

// Import the location of this declaration.
SourceLocation StartLoc = Importer.Import(D->getLocStart());
SourceLocation IdLoc = Importer.Import(D->getLocation());

// Import template arguments.
SmallVector<TemplateArgument, 2> TemplateArgs;
if (ImportTemplateArguments(D->getTemplateArgs().data(), 
                            D->getTemplateArgs().size(),
                            TemplateArgs))
  return nullptr;

// Try to find an existing specialization with these template arguments.
void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *D2
  = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
if (D2) {
  // We already have a class template specialization with these template
  // arguments.
  
  // FIXME: Check for specialization vs. instantiation errors.
  
  if (RecordDecl *FoundDef = D2->getDefinition()) {
    if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
      // The record types structurally match, or the "from" translation
      // unit only had a forward declaration anyway; call it the same
      // function.
      return Importer.MapImported(D, FoundDef);
    }
  }
} else {
  // Create a new specialization.
  if (auto *PartialSpec =
          dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
    // Import TemplateArgumentListInfo
    TemplateArgumentListInfo ToTAInfo;
    const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
    if (ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
      return nullptr;

    QualType CanonInjType = Importer.Import(
          PartialSpec->getInjectedSpecializationType());
    if (CanonInjType.isNull())
      return nullptr;
    CanonInjType = CanonInjType.getCanonicalType();

    TemplateParameterList *ToTPList = ImportTemplateParameterList(
          PartialSpec->getTemplateParameters());
    if (!ToTPList && PartialSpec->getTemplateParameters())
      return nullptr;

    if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
            D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
            IdLoc, ToTPList, ClassTemplate,
            llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
            ToTAInfo, CanonInjType, nullptr))
      return D2;

  } else {
    if (GetImportedOrCreateDecl(
            D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
            IdLoc, ClassTemplate, TemplateArgs, /*PrevDecl=*/nullptr))
      return D2;
  }

  D2->setSpecializationKind(D->getSpecializationKind());

  // Add this specialization to the class template.
  ClassTemplate->AddSpecialization(D2, InsertPos);
  
  // Import the qualifier, if any.
  D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));

  if (auto *TSI = D->getTypeAsWritten()) {
    TypeSourceInfo *TInfo = Importer.Import(TSI);
    if (!TInfo)
      return nullptr;
    D2->setTypeAsWritten(TInfo);
    D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
    D2->setExternLoc(Importer.Import(D->getExternLoc()));
  }

  SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
  if (POI.isValid())
    D2->setPointOfInstantiation(POI);
  else if (D->getPointOfInstantiation().isValid())
    return nullptr;

  D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());

  // Set the context of this specialization/instantiation.
  D2->setLexicalDeclContext(LexicalDC);

  // Add to the DC only if it was an explicit specialization/instantiation.
  if (D2->isExplicitInstantiationOrSpecialization()) {
    LexicalDC->addDeclInternal(D2);
  }
}
if (D->isCompleteDefinition() && ImportDefinition(D, D2))
  return nullptr;

return D2;
4593}

4595Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
// If this variable has a definition in the translation unit we're coming
// from,
// but this particular declaration is not that definition, import the
// definition and map to that.
auto *Definition =
    cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
if (Definition && Definition != D->getTemplatedDecl()) {
  Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
  if (!ImportedDef)
    return nullptr;

  return Importer.MapImported(D, ImportedDef);
}

// Import the major distinguishing characteristics of this variable template.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;
if (ToD)
  return ToD;

// We may already have a template of the same name; try to find and match it.
assert(!DC->isFunctionOrMethod() &&(static_cast <bool> (!DC->isFunctionOrMethod() &&
 "Variable templates cannot be declared at function scope") ?
 void (0) : __assert_fail ("!DC->isFunctionOrMethod() && \"Variable templates cannot be declared at function scope\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 4622, __extension__ __PRETTY_FUNCTION__))
       "Variable templates cannot be declared at function scope")(static_cast <bool> (!DC->isFunctionOrMethod() &&
 "Variable templates cannot be declared at function scope") ?
 void (0) : __assert_fail ("!DC->isFunctionOrMethod() && \"Variable templates cannot be declared at function scope\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 4622, __extension__ __PRETTY_FUNCTION__));
SmallVector<NamedDecl *, 4> ConflictingDecls;
SmallVector<NamedDecl *, 2> FoundDecls;
DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
for (auto *FoundDecl : FoundDecls) {
  if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
    continue;

  Decl *Found = FoundDecl;
  if (auto *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
    if (IsStructuralMatch(D, FoundTemplate)) {
      // The variable templates structurally match; call it the same template.
      Importer.MapImported(D->getTemplatedDecl(),
                           FoundTemplate->getTemplatedDecl());
      return Importer.MapImported(D, FoundTemplate);
    }
  }

  ConflictingDecls.push_back(FoundDecl);
}

if (!ConflictingDecls.empty()) {
  Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
                                     ConflictingDecls.data(),
                                     ConflictingDecls.size());
}

if (!Name)
  return nullptr;

VarDecl *DTemplated = D->getTemplatedDecl();

// Import the type.
QualType T = Importer.Import(DTemplated->getType());
if (T.isNull())
  return nullptr;

// Create the declaration that is being templated.
auto *ToTemplated = dyn_cast_or_null<VarDecl>(Importer.Import(DTemplated));
if (!ToTemplated)
  return nullptr;

// Create the variable template declaration itself.
TemplateParameterList *TemplateParams =
    ImportTemplateParameterList(D->getTemplateParameters());
if (!TemplateParams)
  return nullptr;

VarTemplateDecl *ToVarTD;
if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc,
                            Name, TemplateParams, ToTemplated))
  return ToVarTD;

ToTemplated->setDescribedVarTemplate(ToVarTD);

ToVarTD->setAccess(D->getAccess());
ToVarTD->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToVarTD);

if (DTemplated->isThisDeclarationADefinition() &&
    !ToTemplated->isThisDeclarationADefinition()) {
  // FIXME: Import definition!
}

return ToVarTD;
4687}

4689Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
  VarTemplateSpecializationDecl *D) {
// If this record has a definition in the translation unit we're coming from,
// but this particular declaration is not that definition, import the
// definition and map to that.
VarDecl *Definition = D->getDefinition();
if (Definition && Definition != D) {
  Decl *ImportedDef = Importer.Import(Definition);
  if (!ImportedDef)
    return nullptr;

  return Importer.MapImported(D, ImportedDef);
}

auto *VarTemplate = cast_or_null<VarTemplateDecl>(
    Importer.Import(D->getSpecializedTemplate()));
if (!VarTemplate)
  return nullptr;

// Import the context of this declaration.
DeclContext *DC = VarTemplate->getDeclContext();
if (!DC)
  return nullptr;

DeclContext *LexicalDC = DC;
if (D->getDeclContext() != D->getLexicalDeclContext()) {
  LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
  if (!LexicalDC)
    return nullptr;
}

// Import the location of this declaration.
SourceLocation StartLoc = Importer.Import(D->getLocStart());
SourceLocation IdLoc = Importer.Import(D->getLocation());

// Import template arguments.
SmallVector<TemplateArgument, 2> TemplateArgs;
if (ImportTemplateArguments(D->getTemplateArgs().data(),
                            D->getTemplateArgs().size(), TemplateArgs))
  return nullptr;

// Try to find an existing specialization with these template arguments.
void *InsertPos = nullptr;
VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
    TemplateArgs, InsertPos);
if (D2) {
  // We already have a variable template specialization with these template
  // arguments.

  // FIXME: Check for specialization vs. instantiation errors.

  if (VarDecl *FoundDef = D2->getDefinition()) {
    if (!D->isThisDeclarationADefinition() ||
        IsStructuralMatch(D, FoundDef)) {
      // The record types structurally match, or the "from" translation
      // unit only had a forward declaration anyway; call it the same
      // variable.
      return Importer.MapImported(D, FoundDef);
    }
  }
} else {
  // Import the type.
  QualType T = Importer.Import(D->getType());
  if (T.isNull())
    return nullptr;

  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
  if (D->getTypeSourceInfo() && !TInfo)
    return nullptr;

  TemplateArgumentListInfo ToTAInfo;
  if (ImportTemplateArgumentListInfo(D->getTemplateArgsInfo(), ToTAInfo))
    return nullptr;

  using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
  // Create a new specialization.
  if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
    // Import TemplateArgumentListInfo
    TemplateArgumentListInfo ArgInfos;
    const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
    // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
    if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ArgInfos))
      return nullptr;

    TemplateParameterList *ToTPList = ImportTemplateParameterList(
          FromPartial->getTemplateParameters());
    if (!ToTPList)
      return nullptr;

    PartVarSpecDecl *ToPartial;
    if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
                                StartLoc, IdLoc, ToTPList, VarTemplate, T,
                                TInfo, D->getStorageClass(), TemplateArgs,
                                ArgInfos))
      return ToPartial;

    auto *FromInst = FromPartial->getInstantiatedFromMember();
    auto *ToInst = cast_or_null<PartVarSpecDecl>(Importer.Import(FromInst));
    if (FromInst && !ToInst)
      return nullptr;

    ToPartial->setInstantiatedFromMember(ToInst);
    if (FromPartial->isMemberSpecialization())
      ToPartial->setMemberSpecialization();

    D2 = ToPartial;
  } else { // Full specialization
    if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, StartLoc,
                                IdLoc, VarTemplate, T, TInfo,
                                D->getStorageClass(), TemplateArgs))
      return D2;
  }

  SourceLocation POI = D->getPointOfInstantiation();
  if (POI.isValid())
    D2->setPointOfInstantiation(Importer.Import(POI));

  D2->setSpecializationKind(D->getSpecializationKind());
  D2->setTemplateArgsInfo(ToTAInfo);

  // Add this specialization to the class template.
  VarTemplate->AddSpecialization(D2, InsertPos);

  // Import the qualifier, if any.
  D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));

  if (D->isConstexpr())
    D2->setConstexpr(true);

  // Add the specialization to this context.
  D2->setLexicalDeclContext(LexicalDC);
  LexicalDC->addDeclInternal(D2);

  D2->setAccess(D->getAccess());
}

// NOTE: isThisDeclarationADefinition() can return DeclarationOnly even if
// declaration has initializer. Should this be fixed in the AST?.. Anyway,
// we have to check the declaration for initializer - otherwise, it won't be
// imported.
if ((D->isThisDeclarationADefinition() || D->hasInit()) &&
    ImportDefinition(D, D2))
  return nullptr;

return D2;
4834}

4836Decl *ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;

if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return nullptr;

if (ToD)
  return ToD;

// Try to find a function in our own ("to") context with the same name, same
// type, and in the same context as the function we're importing.
if (!LexicalDC->isFunctionOrMethod()) {
  unsigned IDNS = Decl::IDNS_Ordinary;
  SmallVector<NamedDecl *, 2> FoundDecls;
  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;

    if (auto *FoundFunction = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
      if (FoundFunction->hasExternalFormalLinkage() &&
          D->hasExternalFormalLinkage()) {
        if (IsStructuralMatch(D, FoundFunction)) {
          Importer.MapImported(D, FoundFunction);
          // FIXME: Actually try to merge the body and other attributes.
          return FoundFunction;
        }
      }
    }
  }
}

TemplateParameterList *Params =
    ImportTemplateParameterList(D->getTemplateParameters());
if (!Params)
  return nullptr;

auto *TemplatedFD =
    cast_or_null<FunctionDecl>(Importer.Import(D->getTemplatedDecl()));
if (!TemplatedFD)
  return nullptr;

FunctionTemplateDecl *ToFunc;
if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
                            Params, TemplatedFD))
  return ToFunc;

TemplatedFD->setDescribedFunctionTemplate(ToFunc);
ToFunc->setAccess(D->getAccess());
ToFunc->setLexicalDeclContext(LexicalDC);

LexicalDC->addDeclInternal(ToFunc);
return ToFunc;
4892}

4894//----------------------------------------------------------------------------
4895// Import Statements
4896//----------------------------------------------------------------------------

4898DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
if (DG.isNull())
  return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
size_t NumDecls = DG.end() - DG.begin();
SmallVector<Decl *, 1> ToDecls(NumDecls);
auto &_Importer = this->Importer;
std::transform(DG.begin(), DG.end(), ToDecls.begin(),
  [&_Importer](Decl *D) -> Decl * {
    return _Importer.Import(D);
  });
return DeclGroupRef::Create(Importer.getToContext(),
                            ToDecls.begin(),
                            NumDecls);
4911}

4913Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
  << S->getStmtClassName();
return nullptr;
4917}

4919Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
SmallVector<IdentifierInfo *, 4> Names;
for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
  IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
  // ToII is nullptr when no symbolic name is given for output operand
  // see ParseStmtAsm::ParseAsmOperandsOpt
  if (!ToII && S->getOutputIdentifier(I))
    return nullptr;
  Names.push_back(ToII);
}
for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
  IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
  // ToII is nullptr when no symbolic name is given for input operand
  // see ParseStmtAsm::ParseAsmOperandsOpt
  if (!ToII && S->getInputIdentifier(I))
    return nullptr;
  Names.push_back(ToII);
}

SmallVector<StringLiteral *, 4> Clobbers;
for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
  auto *Clobber = cast_or_null<StringLiteral>(
      Importer.Import(S->getClobberStringLiteral(I)));
  if (!Clobber)
    return nullptr;
  Clobbers.push_back(Clobber);
}

SmallVector<StringLiteral *, 4> Constraints;
for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
  auto *Output = cast_or_null<StringLiteral>(
      Importer.Import(S->getOutputConstraintLiteral(I)));
  if (!Output)
    return nullptr;
  Constraints.push_back(Output);
}

for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
  auto *Input = cast_or_null<StringLiteral>(
      Importer.Import(S->getInputConstraintLiteral(I)));
  if (!Input)
    return nullptr;
  Constraints.push_back(Input);
}

SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
if (ImportContainerChecked(S->outputs(), Exprs))
  return nullptr;

if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
  return nullptr;

auto *AsmStr = cast_or_null<StringLiteral>(
    Importer.Import(S->getAsmString()));
if (!AsmStr)
  return nullptr;

return new (Importer.getToContext()) GCCAsmStmt(
      Importer.getToContext(),
      Importer.Import(S->getAsmLoc()),
      S->isSimple(),
      S->isVolatile(),
      S->getNumOutputs(),
      S->getNumInputs(),
      Names.data(),
      Constraints.data(),
      Exprs.data(),
      AsmStr,
      S->getNumClobbers(),
      Clobbers.data(),
      Importer.Import(S->getRParenLoc()));
4990}

4992Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
for (auto *ToD : ToDG) {
  if (!ToD)
    return nullptr;
}
SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
5001}

5003Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
return new (Importer.getToContext()) NullStmt(ToSemiLoc,
                                              S->hasLeadingEmptyMacro());
5007}

5009Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
SmallVector<Stmt *, 8> ToStmts(S->size());

if (ImportContainerChecked(S->body(), ToStmts))
  return nullptr;

SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
return CompoundStmt::Create(Importer.getToContext(), ToStmts, ToLBraceLoc,
                            ToRBraceLoc);
5019}

5021Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
Expr *ToLHS = Importer.Import(S->getLHS());
if (!ToLHS)
  return nullptr;
Expr *ToRHS = Importer.Import(S->getRHS());
if (!ToRHS && S->getRHS())
  return nullptr;
Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
if (!ToSubStmt && S->getSubStmt())
  return nullptr;
SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
auto *ToStmt = new (Importer.getToContext())
    CaseStmt(ToLHS, ToRHS, ToCaseLoc, ToEllipsisLoc, ToColonLoc);
ToStmt->setSubStmt(ToSubStmt);
return ToStmt;
5038}

5040Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
if (!ToSubStmt && S->getSubStmt())
  return nullptr;
return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
                                                 ToSubStmt);
5048}

5050Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
auto *ToLabelDecl = cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
if (!ToLabelDecl && S->getDecl())
  return nullptr;
Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
if (!ToSubStmt && S->getSubStmt())
  return nullptr;
return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
                                               ToSubStmt);
5060}

5062Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
ArrayRef<const Attr*> FromAttrs(S->getAttrs());
SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
if (ImportContainerChecked(FromAttrs, ToAttrs))
  return nullptr;
Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
if (!ToSubStmt && S->getSubStmt())
  return nullptr;
return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
                              ToAttrs, ToSubStmt);
5073}

5075Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
Stmt *ToInit = Importer.Import(S->getInit());
if (!ToInit && S->getInit())
  return nullptr;
VarDecl *ToConditionVariable = nullptr;
if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
  ToConditionVariable =
    dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
  if (!ToConditionVariable)
    return nullptr;
}
Expr *ToCondition = Importer.Import(S->getCond());
if (!ToCondition && S->getCond())
  return nullptr;
Stmt *ToThenStmt = Importer.Import(S->getThen());
if (!ToThenStmt && S->getThen())
  return nullptr;
SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
Stmt *ToElseStmt = Importer.Import(S->getElse());
if (!ToElseStmt && S->getElse())
  return nullptr;
return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
                                            ToIfLoc, S->isConstexpr(),
                                            ToInit,
                                            ToConditionVariable,
                                            ToCondition, ToThenStmt,
                                            ToElseLoc, ToElseStmt);
5103}

5105Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
Stmt *ToInit = Importer.Import(S->getInit());
if (!ToInit && S->getInit())
  return nullptr;
VarDecl *ToConditionVariable = nullptr;
if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
  ToConditionVariable =
    dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
  if (!ToConditionVariable)
    return nullptr;
}
Expr *ToCondition = Importer.Import(S->getCond());
if (!ToCondition && S->getCond())
  return nullptr;
auto *ToStmt = new (Importer.getToContext()) SwitchStmt(
                       Importer.getToContext(), ToInit,
                       ToConditionVariable, ToCondition);
Stmt *ToBody = Importer.Import(S->getBody());
if (!ToBody && S->getBody())
  return nullptr;
ToStmt->setBody(ToBody);
ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
// Now we have to re-chain the cases.
SwitchCase *LastChainedSwitchCase = nullptr;
for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
     SC = SC->getNextSwitchCase()) {
  auto *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
  if (!ToSC)
    return nullptr;
  if (LastChainedSwitchCase)
    LastChainedSwitchCase->setNextSwitchCase(ToSC);
  else
    ToStmt->setSwitchCaseList(ToSC);
  LastChainedSwitchCase = ToSC;
}
return ToStmt;
5141}

5143Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
VarDecl *ToConditionVariable = nullptr;
if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
  ToConditionVariable =
    dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
  if (!ToConditionVariable)
    return nullptr;
}
Expr *ToCondition = Importer.Import(S->getCond());
if (!ToCondition && S->getCond())
  return nullptr;
Stmt *ToBody = Importer.Import(S->getBody());
if (!ToBody && S->getBody())
  return nullptr;
SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
                                               ToConditionVariable,
                                               ToCondition, ToBody,
                                               ToWhileLoc);
5162}

5164Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
Stmt *ToBody = Importer.Import(S->getBody());
if (!ToBody && S->getBody())
  return nullptr;
Expr *ToCondition = Importer.Import(S->getCond());
if (!ToCondition && S->getCond())
  return nullptr;
SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
                                            ToDoLoc, ToWhileLoc,
                                            ToRParenLoc);
5177}

5179Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
Stmt *ToInit = Importer.Import(S->getInit());
if (!ToInit && S->getInit())
  return nullptr;
Expr *ToCondition = Importer.Import(S->getCond());
if (!ToCondition && S->getCond())
  return nullptr;
VarDecl *ToConditionVariable = nullptr;
if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
  ToConditionVariable =
    dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
  if (!ToConditionVariable)
    return nullptr;
}
Expr *ToInc = Importer.Import(S->getInc());
if (!ToInc && S->getInc())
  return nullptr;
Stmt *ToBody = Importer.Import(S->getBody());
if (!ToBody && S->getBody())
  return nullptr;
SourceLocation ToForLoc = Importer.Import(S->getForLoc());
SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
                                             ToInit, ToCondition,
                                             ToConditionVariable,
                                             ToInc, ToBody,
                                             ToForLoc, ToLParenLoc,
                                             ToRParenLoc);
5208}

5210Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
LabelDecl *ToLabel = nullptr;
if (LabelDecl *FromLabel = S->getLabel()) {
  ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
  if (!ToLabel)
    return nullptr;
}
SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
return new (Importer.getToContext()) GotoStmt(ToLabel,
                                              ToGotoLoc, ToLabelLoc);
5221}

5223Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
Expr *ToTarget = Importer.Import(S->getTarget());
if (!ToTarget && S->getTarget())
  return nullptr;
return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
                                                      ToTarget);
5231}

5233Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5236}

5238Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5241}

5243Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
Expr *ToRetExpr = Importer.Import(S->getRetValue());
if (!ToRetExpr && S->getRetValue())
  return nullptr;
auto *NRVOCandidate = const_cast<VarDecl *>(S->getNRVOCandidate());
auto *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
if (!ToNRVOCandidate && NRVOCandidate)
  return nullptr;
return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
                                                ToNRVOCandidate);
5254}

5256Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
VarDecl *ToExceptionDecl = nullptr;
if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
  ToExceptionDecl =
    dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
  if (!ToExceptionDecl)
    return nullptr;
}
Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
if (!ToHandlerBlock && S->getHandlerBlock())
  return nullptr;
return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
                                                  ToExceptionDecl,
                                                  ToHandlerBlock);
5271}

5273Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
if (!ToTryBlock && S->getTryBlock())
  return nullptr;
SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
  CXXCatchStmt *FromHandler = S->getHandler(HI);
  if (Stmt *ToHandler = Importer.Import(FromHandler))
    ToHandlers[HI] = ToHandler;
  else
    return nullptr;
}
return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
                          ToHandlers);
5288}

5290Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
auto *ToRange =
  dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
if (!ToRange && S->getRangeStmt())
  return nullptr;
auto *ToBegin =
  dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
if (!ToBegin && S->getBeginStmt())
  return nullptr;
auto *ToEnd =
  dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
if (!ToEnd && S->getEndStmt())
  return nullptr;
Expr *ToCond = Importer.Import(S->getCond());
if (!ToCond && S->getCond())
  return nullptr;
Expr *ToInc = Importer.Import(S->getInc());
if (!ToInc && S->getInc())
  return nullptr;
auto *ToLoopVar =
  dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
if (!ToLoopVar && S->getLoopVarStmt())
  return nullptr;
Stmt *ToBody = Importer.Import(S->getBody());
if (!ToBody && S->getBody())
  return nullptr;
SourceLocation ToForLoc = Importer.Import(S->getForLoc());
SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
                                                     ToCond, ToInc,
                                                     ToLoopVar, ToBody,
                                                     ToForLoc, ToCoawaitLoc,
                                                     ToColonLoc, ToRParenLoc);
5325}

5327Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
Stmt *ToElem = Importer.Import(S->getElement());
if (!ToElem && S->getElement())
  return nullptr;
Expr *ToCollect = Importer.Import(S->getCollection());
if (!ToCollect && S->getCollection())
  return nullptr;
Stmt *ToBody = Importer.Import(S->getBody());
if (!ToBody && S->getBody())
  return nullptr;
SourceLocation ToForLoc = Importer.Import(S->getForLoc());
SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
                                                           ToCollect,
                                                           ToBody, ToForLoc,
                                                           ToRParenLoc);
5343}

5345Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
VarDecl *ToExceptionDecl = nullptr;
if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
  ToExceptionDecl =
    dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
  if (!ToExceptionDecl)
    return nullptr;
}
Stmt *ToBody = Importer.Import(S->getCatchBody());
if (!ToBody && S->getCatchBody())
  return nullptr;
return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
                                                     ToRParenLoc,
                                                     ToExceptionDecl,
                                                     ToBody);
5362}

5364Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
if (!ToAtFinallyStmt && S->getFinallyBody())
  return nullptr;
return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
                                                       ToAtFinallyStmt);
5371}

5373Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
if (!ToAtTryStmt && S->getTryBody())
  return nullptr;
SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
  ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
  if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
    ToCatchStmts[CI] = ToCatchStmt;
  else
    return nullptr;
}
Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
if (!ToAtFinallyStmt && S->getFinallyStmt())
  return nullptr;
return ObjCAtTryStmt::Create(Importer.getToContext(),
                             ToAtTryLoc, ToAtTryStmt,
                             ToCatchStmts.begin(), ToCatchStmts.size(),
                             ToAtFinallyStmt);
5393}

5395Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
(ObjCAtSynchronizedStmt *S) {
SourceLocation ToAtSynchronizedLoc =
  Importer.Import(S->getAtSynchronizedLoc());
Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
if (!ToSynchExpr && S->getSynchExpr())
  return nullptr;
Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
if (!ToSynchBody && S->getSynchBody())
  return nullptr;
return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
  ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5407}

5409Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
Expr *ToThrow = Importer.Import(S->getThrowExpr());
if (!ToThrow && S->getThrowExpr())
  return nullptr;
return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5415}

5417Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
(ObjCAutoreleasePoolStmt *S) {
SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
if (!ToSubStmt && S->getSubStmt())
  return nullptr;
return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
                                                             ToSubStmt);
5425}

5427//----------------------------------------------------------------------------
5428// Import Expressions
5429//----------------------------------------------------------------------------
5430Expr *ASTNodeImporter::VisitExpr(Expr *E) {
Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
  << E->getStmtClassName();
return nullptr;
5434}

5436Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr && E->getSubExpr())
  return nullptr;

TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
if (!TInfo)
  return nullptr;

return new (Importer.getToContext()) VAArgExpr(
      Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
      Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5452}

5454Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

return new (Importer.getToContext()) GNUNullExpr(
      T, Importer.Import(E->getLocStart()));
5461}

5463Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

auto *SL = cast_or_null<StringLiteral>(Importer.Import(E->getFunctionName()));
if (!SL && E->getFunctionName())
  return nullptr;

return new (Importer.getToContext()) PredefinedExpr(
      Importer.Import(E->getLocStart()), T, E->getIdentType(), SL);
5474}

5476Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
auto *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
if (!ToD)
  return nullptr;

NamedDecl *FoundD = nullptr;
if (E->getDecl() != E->getFoundDecl()) {
  FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
  if (!FoundD)
    return nullptr;
}

QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

TemplateArgumentListInfo ToTAInfo;
TemplateArgumentListInfo *ResInfo = nullptr;
if (E->hasExplicitTemplateArgs()) {
  if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
    return nullptr;
  ResInfo = &ToTAInfo;
}

DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(), 
                                       Importer.Import(E->getQualifierLoc()),
                                 Importer.Import(E->getTemplateKeywordLoc()),
                                       ToD,
                                      E->refersToEnclosingVariableOrCapture(),
                                       Importer.Import(E->getLocation()),
                                       T, E->getValueKind(),
                                       FoundD, ResInfo);
if (E->hadMultipleCandidates())
  DRE->setHadMultipleCandidates(true);
return DRE;
5511}

5513Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5519}

5521ASTNodeImporter::Designator
5522ASTNodeImporter::ImportDesignator(const Designator &D) {
if (D.isFieldDesignator()) {
  IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
  // Caller checks for import error
  return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
                    Importer.Import(D.getFieldLoc()));
}
if (D.isArrayDesignator())
  return Designator(D.getFirstExprIndex(),
                    Importer.Import(D.getLBracketLoc()),
                    Importer.Import(D.getRBracketLoc()));

assert(D.isArrayRangeDesignator())(static_cast <bool> (D.isArrayRangeDesignator()) ? void
 (0) : __assert_fail ("D.isArrayRangeDesignator()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 5534, __extension__ __PRETTY_FUNCTION__));
return Designator(D.getFirstExprIndex(),
                  Importer.Import(D.getLBracketLoc()),
                  Importer.Import(D.getEllipsisLoc()),
                  Importer.Import(D.getRBracketLoc()));
5539}


5542Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
auto *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
if (!Init)
  return nullptr;

SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
// List elements from the second, the first is Init itself
for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
  if (auto *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
    IndexExprs[I - 1] = Arg;
  else
    return nullptr;
}

SmallVector<Designator, 4> Designators(DIE->size());
llvm::transform(DIE->designators(), Designators.begin(),
                [this](const Designator &D) -> Designator {
                  return ImportDesignator(D);
                });

for (const auto &D : DIE->designators())
  if (D.isFieldDesignator() && !D.getFieldName())
    return nullptr;

return DesignatedInitExpr::Create(
      Importer.getToContext(), Designators,
      IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
      DIE->usesGNUSyntax(), Init);
5570}

5572Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

return new (Importer.getToContext())
    CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5579}

5581Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

return IntegerLiteral::Create(Importer.getToContext(), 
                              E->getValue(), T,
                              Importer.Import(E->getLocation()));
5589}

5591Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

return FloatingLiteral::Create(Importer.getToContext(),
                              E->getValue(), E->isExact(), T,
                              Importer.Import(E->getLocation()));
5599}

5601Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
                                                      E->getKind(), T,
                                        Importer.Import(E->getLocation()));
5609}

5611Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());

return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
                             E->getKind(), E->isPascal(), T,
                             Locations.data(), Locations.size());
5622}

5624Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
if (!TInfo)
  return nullptr;

Expr *Init = Importer.Import(E->getInitializer());
if (!Init)
  return nullptr;

return new (Importer.getToContext()) CompoundLiteralExpr(
      Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
      Init, E->isFileScope());
5640}

5642Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
if (ImportArrayChecked(
      E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
      Exprs.begin()))
  return nullptr;

return new (Importer.getToContext()) AtomicExpr(
      Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
      Importer.Import(E->getRParenLoc()));
5656}

5658Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

auto *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
if (!ToLabel)
  return nullptr;

return new (Importer.getToContext()) AddrLabelExpr(
      Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
      ToLabel, T);
5670}

5672Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr)
  return nullptr;

return new (Importer.getToContext()) 
                                ParenExpr(Importer.Import(E->getLParen()),
                                          Importer.Import(E->getRParen()),
                                          SubExpr);
5681}

5683Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
SmallVector<Expr *, 4> Exprs(E->getNumExprs());
if (ImportContainerChecked(E->exprs(), Exprs))
  return nullptr;

return new (Importer.getToContext()) ParenListExpr(
      Importer.getToContext(), Importer.Import(E->getLParenLoc()),
      Exprs, Importer.Import(E->getLParenLoc()));
5691}

5693Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

auto *ToSubStmt = cast_or_null<CompoundStmt>(
    Importer.Import(E->getSubStmt()));
if (!ToSubStmt && E->getSubStmt())
  return nullptr;

return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
      Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
5705}

5707Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr)
  return nullptr;

return new (Importer.getToContext()) UnaryOperator(
    SubExpr, E->getOpcode(), T, E->getValueKind(), E->getObjectKind(),
    Importer.Import(E->getOperatorLoc()), E->canOverflow());
5719}

5721Expr *
5722ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
QualType ResultType = Importer.Import(E->getType());

if (E->isArgumentType()) {
  TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
  if (!TInfo)
    return nullptr;

  return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
                                         TInfo, ResultType,
                                         Importer.Import(E->getOperatorLoc()),
                                         Importer.Import(E->getRParenLoc()));
}

Expr *SubExpr = Importer.Import(E->getArgumentExpr());
if (!SubExpr)
  return nullptr;

return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
                                        SubExpr, ResultType,
                                        Importer.Import(E->getOperatorLoc()),
                                        Importer.Import(E->getRParenLoc()));
5744}

5746Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *LHS = Importer.Import(E->getLHS());
if (!LHS)
  return nullptr;

Expr *RHS = Importer.Import(E->getRHS());
if (!RHS)
  return nullptr;

return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
                                                    T, E->getValueKind(),
                                                    E->getObjectKind(),
                                         Importer.Import(E->getOperatorLoc()),
                                                    E->getFPFeatures());
5764}

5766Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *ToLHS = Importer.Import(E->getLHS());
if (!ToLHS)
  return nullptr;

Expr *ToRHS = Importer.Import(E->getRHS());
if (!ToRHS)
  return nullptr;

Expr *ToCond = Importer.Import(E->getCond());
if (!ToCond)
  return nullptr;

return new (Importer.getToContext()) ConditionalOperator(
      ToCond, Importer.Import(E->getQuestionLoc()),
      ToLHS, Importer.Import(E->getColonLoc()),
      ToRHS, T, E->getValueKind(), E->getObjectKind());
5787}

5789Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
  BinaryConditionalOperator *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *Common = Importer.Import(E->getCommon());
if (!Common)
  return nullptr;

Expr *Cond = Importer.Import(E->getCond());
if (!Cond)
  return nullptr;

auto *OpaqueValue = cast_or_null<OpaqueValueExpr>(
    Importer.Import(E->getOpaqueValue()));
if (!OpaqueValue)
  return nullptr;

Expr *TrueExpr = Importer.Import(E->getTrueExpr());
if (!TrueExpr)
  return nullptr;

Expr *FalseExpr = Importer.Import(E->getFalseExpr());
if (!FalseExpr)
  return nullptr;

return new (Importer.getToContext()) BinaryConditionalOperator(
      Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
      Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
      T, E->getValueKind(), E->getObjectKind());
5820}

5822Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
if (!ToQueried)
  return nullptr;

Expr *Dim = Importer.Import(E->getDimensionExpression());
if (!Dim && E->getDimensionExpression())
  return nullptr;

return new (Importer.getToContext()) ArrayTypeTraitExpr(
      Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
      E->getValue(), Dim, Importer.Import(E->getLocEnd()), T);
5838}

5840Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *ToQueried = Importer.Import(E->getQueriedExpression());
if (!ToQueried)
  return nullptr;

return new (Importer.getToContext()) ExpressionTraitExpr(
      Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
      E->getValue(), Importer.Import(E->getLocEnd()), T);
5852}

5854Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *SourceExpr = Importer.Import(E->getSourceExpr());
if (!SourceExpr && E->getSourceExpr())
  return nullptr;

return new (Importer.getToContext()) OpaqueValueExpr(
      Importer.Import(E->getLocation()), T, E->getValueKind(),
      E->getObjectKind(), SourceExpr);
5866}

5868Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *ToLHS = Importer.Import(E->getLHS());
if (!ToLHS)
  return nullptr;

Expr *ToRHS = Importer.Import(E->getRHS());
if (!ToRHS)
  return nullptr;

return new (Importer.getToContext()) ArraySubscriptExpr(
      ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
      Importer.Import(E->getRBracketLoc()));
5884}

5886Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

QualType CompLHSType = Importer.Import(E->getComputationLHSType());
if (CompLHSType.isNull())
  return nullptr;

QualType CompResultType = Importer.Import(E->getComputationResultType());
if (CompResultType.isNull())
  return nullptr;

Expr *LHS = Importer.Import(E->getLHS());
if (!LHS)
  return nullptr;

Expr *RHS = Importer.Import(E->getRHS());
if (!RHS)
  return nullptr;

return new (Importer.getToContext()) 
                      CompoundAssignOperator(LHS, RHS, E->getOpcode(),
                                             T, E->getValueKind(),
                                             E->getObjectKind(),
                                             CompLHSType, CompResultType,
                                         Importer.Import(E->getOperatorLoc()),
                                             E->getFPFeatures());
5914}

5916bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) {
for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
  if (CXXBaseSpecifier *Spec = Importer.Import(*I))
    Path.push_back(Spec);
  else
    return true;
}
return false;
5924}

5926Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr)
  return nullptr;

CXXCastPath BasePath;
if (ImportCastPath(E, BasePath))
  return nullptr;

return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
                                SubExpr, &BasePath, E->getValueKind());
5941}

5943Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr)
  return nullptr;

TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
if (!TInfo && E->getTypeInfoAsWritten())
  return nullptr;

CXXCastPath BasePath;
if (ImportCastPath(E, BasePath))
  return nullptr;

switch (E->getStmtClass()) {
case Stmt::CStyleCastExprClass: {
  auto *CCE = cast<CStyleCastExpr>(E);
  return CStyleCastExpr::Create(Importer.getToContext(), T,
                                E->getValueKind(), E->getCastKind(),
                                SubExpr, &BasePath, TInfo,
                                Importer.Import(CCE->getLParenLoc()),
                                Importer.Import(CCE->getRParenLoc()));
}

case Stmt::CXXFunctionalCastExprClass: {
  auto *FCE = cast<CXXFunctionalCastExpr>(E);
  return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
                                       E->getValueKind(), TInfo,
                                       E->getCastKind(), SubExpr, &BasePath,
                                       Importer.Import(FCE->getLParenLoc()),
                                       Importer.Import(FCE->getRParenLoc()));
}

case Stmt::ObjCBridgedCastExprClass: {
    auto *OCE = cast<ObjCBridgedCastExpr>(E);
    return new (Importer.getToContext()) ObjCBridgedCastExpr(
          Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
          E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
          TInfo, SubExpr);
}
default:
  break; // just fall through
}

auto *Named = cast<CXXNamedCastExpr>(E);
SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
    RParenLoc = Importer.Import(Named->getRParenLoc());
SourceRange Brackets = Importer.Import(Named->getAngleBrackets());

switch (E->getStmtClass()) {
case Stmt::CXXStaticCastExprClass:
  return CXXStaticCastExpr::Create(Importer.getToContext(), T,
                                   E->getValueKind(), E->getCastKind(),
                                   SubExpr, &BasePath, TInfo,
                                   ExprLoc, RParenLoc, Brackets);

case Stmt::CXXDynamicCastExprClass:
  return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
                                    E->getValueKind(), E->getCastKind(),
                                    SubExpr, &BasePath, TInfo,
                                    ExprLoc, RParenLoc, Brackets);

case Stmt::CXXReinterpretCastExprClass:
  return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
                                        E->getValueKind(), E->getCastKind(),
                                        SubExpr, &BasePath, TInfo,
                                        ExprLoc, RParenLoc, Brackets);

case Stmt::CXXConstCastExprClass:
  return CXXConstCastExpr::Create(Importer.getToContext(), T,
                                  E->getValueKind(), SubExpr, TInfo, ExprLoc,
                                  RParenLoc, Brackets);
default:
  llvm_unreachable("Cast expression of unsupported type!")::llvm::llvm_unreachable_internal("Cast expression of unsupported type!"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 6019);
  return nullptr;
}
6022}

6024Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) {
QualType T = Importer.Import(OE->getType());
if (T.isNull())
  return nullptr;

SmallVector<OffsetOfNode, 4> Nodes;
for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
  const OffsetOfNode &Node = OE->getComponent(I);

  switch (Node.getKind()) {
  case OffsetOfNode::Array:
    Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()),
                                 Node.getArrayExprIndex(),
                                 Importer.Import(Node.getLocEnd())));
    break;

  case OffsetOfNode::Base: {
    CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
    if (!BS && Node.getBase())
      return nullptr;
    Nodes.push_back(OffsetOfNode(BS));
    break;
  }
  case OffsetOfNode::Field: {
    auto *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
    if (!FD)
      return nullptr;
    Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
                                 Importer.Import(Node.getLocEnd())));
    break;
  }
  case OffsetOfNode::Identifier: {
    IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
    if (!ToII)
      return nullptr;
    Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII,
                                 Importer.Import(Node.getLocEnd())));
    break;
  }
  }
}

SmallVector<Expr *, 4> Exprs(OE->getNumExpressions());
for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) {
  Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I));
  if (!ToIndexExpr)
    return nullptr;
  Exprs[I] = ToIndexExpr;
}

TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo());
if (!TInfo && OE->getTypeSourceInfo())
  return nullptr;

return OffsetOfExpr::Create(Importer.getToContext(), T,
                            Importer.Import(OE->getOperatorLoc()),
                            TInfo, Nodes, Exprs,
                            Importer.Import(OE->getRParenLoc()));
6082}

6084Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *Operand = Importer.Import(E->getOperand());
if (!Operand)
  return nullptr;

CanThrowResult CanThrow;
if (E->isValueDependent())
  CanThrow = CT_Dependent;
else
  CanThrow = E->getValue() ? CT_Can : CT_Cannot;

return new (Importer.getToContext()) CXXNoexceptExpr(
      T, Operand, CanThrow,
      Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd()));
6102}

6104Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr && E->getSubExpr())
  return nullptr;

return new (Importer.getToContext()) CXXThrowExpr(
      SubExpr, T, Importer.Import(E->getThrowLoc()),
      E->isThrownVariableInScope());
6116}

6118Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
auto *Param = cast_or_null<ParmVarDecl>(Importer.Import(E->getParam()));
if (!Param)
  return nullptr;

return CXXDefaultArgExpr::Create(
      Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
6125}

6127Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
if (!TypeInfo)
  return nullptr;

return new (Importer.getToContext()) CXXScalarValueInitExpr(
      T, TypeInfo, Importer.Import(E->getRParenLoc()));
6138}

6140Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
Expr *SubExpr = Importer.Import(E->getSubExpr());
if (!SubExpr)
  return nullptr;

auto *Dtor = cast_or_null<CXXDestructorDecl>(
      Importer.Import(const_cast<CXXDestructorDecl *>(
                        E->getTemporary()->getDestructor())));
if (!Dtor)
  return nullptr;

ASTContext &ToCtx = Importer.getToContext();
CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
6154}

6156Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
QualType T = Importer.Import(CE->getType());
if (T.isNull())
  return nullptr;

TypeSourceInfo *TInfo = Importer.Import(CE->getTypeSourceInfo());
if (!TInfo)
  return nullptr;

SmallVector<Expr *, 8> Args(CE->getNumArgs());
if (ImportContainerChecked(CE->arguments(), Args))
  return nullptr;

auto *Ctor = cast_or_null<CXXConstructorDecl>(
      Importer.Import(CE->getConstructor()));
if (!Ctor)
  return nullptr;

return new (Importer.getToContext()) CXXTemporaryObjectExpr(
    Importer.getToContext(), Ctor, T, TInfo, Args,
    Importer.Import(CE->getParenOrBraceRange()), CE->hadMultipleCandidates(),
    CE->isListInitialization(), CE->isStdInitListInitialization(),
    CE->requiresZeroInitialization());
6179}

6181Expr *
6182ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *TempE = Importer.Import(E->GetTemporaryExpr());
if (!TempE)
  return nullptr;

auto *ExtendedBy = cast_or_null<ValueDecl>(
      Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
if (!ExtendedBy && E->getExtendingDecl())
  return nullptr;

auto *ToMTE =  new (Importer.getToContext()) MaterializeTemporaryExpr(
      T, TempE, E->isBoundToLvalueReference());

// FIXME: Should ManglingNumber get numbers associated with 'to' context?
ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
return ToMTE;
6202}

6204Expr *ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *Pattern = Importer.Import(E->getPattern());
if (!Pattern)
  return nullptr;

return new (Importer.getToContext()) PackExpansionExpr(
      T, Pattern, Importer.Import(E->getEllipsisLoc()),
      E->getNumExpansions());
6216}

6218Expr *ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
auto *Pack = cast_or_null<NamedDecl>(Importer.Import(E->getPack()));
if (!Pack)
  return nullptr;

Optional<unsigned> Length;

if (!E->isValueDependent())
  Length = E->getPackLength();

SmallVector<TemplateArgument, 8> PartialArguments;
if (E->isPartiallySubstituted()) {
  if (ImportTemplateArguments(E->getPartialArguments().data(),
                              E->getPartialArguments().size(),
                              PartialArguments))
    return nullptr;
}

return SizeOfPackExpr::Create(
    Importer.getToContext(), Importer.Import(E->getOperatorLoc()), Pack,
    Importer.Import(E->getPackLoc()), Importer.Import(E->getRParenLoc()),
    Length, PartialArguments);
6240}

6242Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
QualType T = Importer.Import(CE->getType());
if (T.isNull())
  return nullptr;

SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
  return nullptr;

auto *OperatorNewDecl = cast_or_null<FunctionDecl>(
      Importer.Import(CE->getOperatorNew()));
if (!OperatorNewDecl && CE->getOperatorNew())
  return nullptr;

auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
      Importer.Import(CE->getOperatorDelete()));
if (!OperatorDeleteDecl && CE->getOperatorDelete())
  return nullptr;

Expr *ToInit = Importer.Import(CE->getInitializer());
if (!ToInit && CE->getInitializer())
  return nullptr;

TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
if (!TInfo)
  return nullptr;

Expr *ToArrSize = Importer.Import(CE->getArraySize());
if (!ToArrSize && CE->getArraySize())
  return nullptr;

return new (Importer.getToContext()) CXXNewExpr(
      Importer.getToContext(),
      CE->isGlobalNew(),
      OperatorNewDecl, OperatorDeleteDecl,
      CE->passAlignment(),
      CE->doesUsualArrayDeleteWantSize(),
      PlacementArgs,
      Importer.Import(CE->getTypeIdParens()),
      ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
      Importer.Import(CE->getSourceRange()),
      Importer.Import(CE->getDirectInitRange()));
6284}

6286Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
      Importer.Import(E->getOperatorDelete()));
if (!OperatorDeleteDecl && E->getOperatorDelete())
  return nullptr;

Expr *ToArg = Importer.Import(E->getArgument());
if (!ToArg && E->getArgument())
  return nullptr;

return new (Importer.getToContext()) CXXDeleteExpr(
      T, E->isGlobalDelete(),
      E->isArrayForm(),
      E->isArrayFormAsWritten(),
      E->doesUsualArrayDeleteWantSize(),
      OperatorDeleteDecl,
      ToArg,
      Importer.Import(E->getLocStart()));
6308}

6310Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

auto *ToCCD =
  dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
if (!ToCCD)
  return nullptr;

SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
if (ImportContainerChecked(E->arguments(), ToArgs))
  return nullptr;

return CXXConstructExpr::Create(Importer.getToContext(), T,
                                Importer.Import(E->getLocation()),
                                ToCCD, E->isElidable(),
                                ToArgs, E->hadMultipleCandidates(),
                                E->isListInitialization(),
                                E->isStdInitListInitialization(),
                                E->requiresZeroInitialization(),
                                E->getConstructionKind(),
                                Importer.Import(E->getParenOrBraceRange()));
6333}

6335Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) {
Expr *SubExpr = Importer.Import(EWC->getSubExpr());
if (!SubExpr && EWC->getSubExpr())
  return nullptr;

SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects());
for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
  if (ExprWithCleanups::CleanupObject Obj =
      cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
    Objs[I] = Obj;
  else
    return nullptr;

return ExprWithCleanups::Create(Importer.getToContext(),
                                SubExpr, EWC->cleanupsHaveSideEffects(),
                                Objs);
6351}

6353Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *ToFn = Importer.Import(E->getCallee());
if (!ToFn)
  return nullptr;

SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
if (ImportContainerChecked(E->arguments(), ToArgs))
  return nullptr;

return new (Importer.getToContext()) CXXMemberCallExpr(
      Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
      Importer.Import(E->getRParenLoc()));
6369}

6371Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

return new (Importer.getToContext())
CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
6378}

6380Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

return new (Importer.getToContext())
CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
6387}


6390Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *ToBase = Importer.Import(E->getBase());
if (!ToBase && E->getBase())
  return nullptr;

auto *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
if (!ToMember && E->getMemberDecl())
  return nullptr;

auto *ToDecl =
    dyn_cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl()));
if (!ToDecl && E->getFoundDecl().getDecl())
  return nullptr;

DeclAccessPair ToFoundDecl =
    DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess());

DeclarationNameInfo ToMemberNameInfo(
  Importer.Import(E->getMemberNameInfo().getName()),
  Importer.Import(E->getMemberNameInfo().getLoc()));

if (E->hasExplicitTemplateArgs()) {
  return nullptr; // FIXME: handle template arguments
}

return MemberExpr::Create(Importer.getToContext(), ToBase,
                          E->isArrow(),
                          Importer.Import(E->getOperatorLoc()),
                          Importer.Import(E->getQualifierLoc()),
                          Importer.Import(E->getTemplateKeywordLoc()),
                          ToMember, ToFoundDecl, ToMemberNameInfo,
                          nullptr, T, E->getValueKind(),
                          E->getObjectKind());
6427}

6429Expr *ASTNodeImporter::VisitCXXPseudoDestructorExpr(
  CXXPseudoDestructorExpr *E) {
Expr *BaseE = Importer.Import(E->getBase());
if (!BaseE)
  return nullptr;

TypeSourceInfo *ScopeInfo = Importer.Import(E->getScopeTypeInfo());
if (!ScopeInfo && E->getScopeTypeInfo())
  return nullptr;

PseudoDestructorTypeStorage Storage;
if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
  IdentifierInfo *ToII = Importer.Import(FromII);
  if (!ToII)
    return nullptr;
  Storage = PseudoDestructorTypeStorage(
        ToII, Importer.Import(E->getDestroyedTypeLoc()));
} else {
  TypeSourceInfo *TI = Importer.Import(E->getDestroyedTypeInfo());
  if (!TI)
    return nullptr;
  Storage = PseudoDestructorTypeStorage(TI);
}

return new (Importer.getToContext()) CXXPseudoDestructorExpr(
      Importer.getToContext(), BaseE, E->isArrow(),
      Importer.Import(E->getOperatorLoc()),
      Importer.Import(E->getQualifierLoc()),
      ScopeInfo, Importer.Import(E->getColonColonLoc()),
      Importer.Import(E->getTildeLoc()), Storage);
6459}

6461Expr *ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
  CXXDependentScopeMemberExpr *E) {
Expr *Base = nullptr;
if (!E->isImplicitAccess()) {
  Base = Importer.Import(E->getBase());
  if (!Base)
    return nullptr;
}

QualType BaseType = Importer.Import(E->getBaseType());
if (BaseType.isNull())
  return nullptr;

TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
if (E->hasExplicitTemplateArgs()) {
  if (ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
                                     E->template_arguments(), ToTAInfo))
    return nullptr;
  ResInfo = &ToTAInfo;
}

DeclarationName Name = Importer.Import(E->getMember());
if (!E->getMember().isEmpty() && Name.isEmpty())
  return nullptr;

DeclarationNameInfo MemberNameInfo(Name, Importer.Import(E->getMemberLoc()));
// Import additional name location/type info.
ImportDeclarationNameLoc(E->getMemberNameInfo(), MemberNameInfo);
auto ToFQ = Importer.Import(E->getFirstQualifierFoundInScope());
if (!ToFQ && E->getFirstQualifierFoundInScope())
  return nullptr;

return CXXDependentScopeMemberExpr::Create(
    Importer.getToContext(), Base, BaseType, E->isArrow(),
    Importer.Import(E->getOperatorLoc()),
    Importer.Import(E->getQualifierLoc()),
    Importer.Import(E->getTemplateKeywordLoc()),
    cast_or_null<NamedDecl>(ToFQ), MemberNameInfo, ResInfo);
6499}

6501Expr *
6502ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
DeclarationName Name = Importer.Import(E->getDeclName());
if (!E->getDeclName().isEmpty() && Name.isEmpty())
  return nullptr;

DeclarationNameInfo NameInfo(Name, Importer.Import(E->getExprLoc()));
ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);

TemplateArgumentListInfo ToTAInfo(Importer.Import(E->getLAngleLoc()),
                                  Importer.Import(E->getRAngleLoc()));
TemplateArgumentListInfo *ResInfo = nullptr;
if (E->hasExplicitTemplateArgs()) {
  if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
    return nullptr;
  ResInfo = &ToTAInfo;
}

return DependentScopeDeclRefExpr::Create(
    Importer.getToContext(), Importer.Import(E->getQualifierLoc()),
    Importer.Import(E->getTemplateKeywordLoc()), NameInfo, ResInfo);
6522}

6524Expr *ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
  CXXUnresolvedConstructExpr *CE) {
unsigned NumArgs = CE->arg_size();

SmallVector<Expr *, 8> ToArgs(NumArgs);
if (ImportArrayChecked(CE->arg_begin(), CE->arg_end(), ToArgs.begin()))
  return nullptr;

return CXXUnresolvedConstructExpr::Create(
    Importer.getToContext(), Importer.Import(CE->getTypeSourceInfo()),
    Importer.Import(CE->getLParenLoc()), llvm::makeArrayRef(ToArgs),
    Importer.Import(CE->getRParenLoc()));
6536}

6538Expr *ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
auto *NamingClass =
    cast_or_null<CXXRecordDecl>(Importer.Import(E->getNamingClass()));
if (E->getNamingClass() && !NamingClass)
  return nullptr;

DeclarationName Name = Importer.Import(E->getName());
if (E->getName() && !Name)
  return nullptr;

DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
// Import additional name location/type info.
ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);

UnresolvedSet<8> ToDecls;
for (auto *D : E->decls()) {
  if (auto *To = cast_or_null<NamedDecl>(Importer.Import(D)))
    ToDecls.addDecl(To);
  else
    return nullptr;
}

TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
if (E->hasExplicitTemplateArgs()) {
  if (ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
                                     E->template_arguments(), ToTAInfo))
    return nullptr;
  ResInfo = &ToTAInfo;
}

if (ResInfo || E->getTemplateKeywordLoc().isValid())
  return UnresolvedLookupExpr::Create(
      Importer.getToContext(), NamingClass,
      Importer.Import(E->getQualifierLoc()),
      Importer.Import(E->getTemplateKeywordLoc()), NameInfo, E->requiresADL(),
      ResInfo, ToDecls.begin(), ToDecls.end());

return UnresolvedLookupExpr::Create(
    Importer.getToContext(), NamingClass,
    Importer.Import(E->getQualifierLoc()), NameInfo, E->requiresADL(),
    E->isOverloaded(), ToDecls.begin(), ToDecls.end());
6579}

6581Expr *ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
DeclarationName Name = Importer.Import(E->getName());
if (!E->getName().isEmpty() && Name.isEmpty())
  return nullptr;
DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
// Import additional name location/type info.
ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);

QualType BaseType = Importer.Import(E->getType());
if (!E->getType().isNull() && BaseType.isNull())
  return nullptr;

UnresolvedSet<8> ToDecls;
for (Decl *D : E->decls()) {
  if (NamedDecl *To = cast_or_null<NamedDecl>(Importer.Import(D)))
    ToDecls.addDecl(To);
  else
    return nullptr;
}

TemplateArgumentListInfo ToTAInfo;
TemplateArgumentListInfo *ResInfo = nullptr;
if (E->hasExplicitTemplateArgs()) {
  if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
    return nullptr;
  ResInfo = &ToTAInfo;
}

Expr *BaseE = E->isImplicitAccess() ? nullptr : Importer.Import(E->getBase());
if (!BaseE && !E->isImplicitAccess() && E->getBase()) {
  return nullptr;
}

return UnresolvedMemberExpr::Create(
    Importer.getToContext(), E->hasUnresolvedUsing(), BaseE, BaseType,
    E->isArrow(), Importer.Import(E->getOperatorLoc()),
    Importer.Import(E->getQualifierLoc()),
    Importer.Import(E->getTemplateKeywordLoc()), NameInfo, ResInfo,
    ToDecls.begin(), ToDecls.end());
6620}

6622Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *ToCallee = Importer.Import(E->getCallee());
if (!ToCallee && E->getCallee())
  return nullptr;

unsigned NumArgs = E->getNumArgs();
SmallVector<Expr *, 2> ToArgs(NumArgs);
if (ImportContainerChecked(E->arguments(), ToArgs))
   return nullptr;

auto **ToArgs_Copied = new (Importer.getToContext()) Expr*[NumArgs];

for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
  ToArgs_Copied[ai] = ToArgs[ai];

if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
  return new (Importer.getToContext()) CXXOperatorCallExpr(
        Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, T,
        OCE->getValueKind(), Importer.Import(OCE->getRParenLoc()),
        OCE->getFPFeatures());
}

return new (Importer.getToContext())
  CallExpr(Importer.getToContext(), ToCallee, 
           llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
           Importer.Import(E->getRParenLoc()));
6652}

6654Optional<LambdaCapture>
6655ASTNodeImporter::ImportLambdaCapture(const LambdaCapture &From) {
VarDecl *Var = nullptr;
if (From.capturesVariable()) {
  Var = cast_or_null<VarDecl>(Importer.Import(From.getCapturedVar()));
  if (!Var)
    return None;
}

return LambdaCapture(Importer.Import(From.getLocation()), From.isImplicit(),
                     From.getCaptureKind(), Var,
                     From.isPackExpansion()
                       ? Importer.Import(From.getEllipsisLoc())
                       : SourceLocation());
6668}

6670Expr *ASTNodeImporter::VisitLambdaExpr(LambdaExpr *LE) {
CXXRecordDecl *FromClass = LE->getLambdaClass();
auto *ToClass = dyn_cast_or_null<CXXRecordDecl>(Importer.Import(FromClass));
if (!ToClass)
  return nullptr;

// NOTE: lambda classes are created with BeingDefined flag set up.
// It means that ImportDefinition doesn't work for them and we should fill it
// manually.
if (ToClass->isBeingDefined()) {
  for (auto FromField : FromClass->fields()) {
    auto *ToField = cast_or_null<FieldDecl>(Importer.Import(FromField));
    if (!ToField)
      return nullptr;
  }
}

auto *ToCallOp = dyn_cast_or_null<CXXMethodDecl>(
      Importer.Import(LE->getCallOperator()));
if (!ToCallOp)
  return nullptr;

ToClass->completeDefinition();

unsigned NumCaptures = LE->capture_size();
SmallVector<LambdaCapture, 8> Captures;
Captures.reserve(NumCaptures);
for (const auto &FromCapture : LE->captures()) {
  if (auto ToCapture = ImportLambdaCapture(FromCapture))
    Captures.push_back(*ToCapture);
  else
    return nullptr;
}

SmallVector<Expr *, 8> InitCaptures(NumCaptures);
if (ImportContainerChecked(LE->capture_inits(), InitCaptures))
  return nullptr;

return LambdaExpr::Create(Importer.getToContext(), ToClass,
                          Importer.Import(LE->getIntroducerRange()),
                          LE->getCaptureDefault(),
                          Importer.Import(LE->getCaptureDefaultLoc()),
                          Captures,
                          LE->hasExplicitParameters(),
                          LE->hasExplicitResultType(),
                          InitCaptures,
                          Importer.Import(LE->getLocEnd()),
                          LE->containsUnexpandedParameterPack());
6718}

6720Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
QualType T = Importer.Import(ILE->getType());
if (T.isNull())
  return nullptr;

SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
if (ImportContainerChecked(ILE->inits(), Exprs))
  return nullptr;

ASTContext &ToCtx = Importer.getToContext();
InitListExpr *To = new (ToCtx) InitListExpr(
      ToCtx, Importer.Import(ILE->getLBraceLoc()),
      Exprs, Importer.Import(ILE->getLBraceLoc()));
To->setType(T);

if (ILE->hasArrayFiller()) {
  Expr *Filler = Importer.Import(ILE->getArrayFiller());
  if (!Filler)
    return nullptr;
  To->setArrayFiller(Filler);
}

if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
  auto *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
  if (!ToFD)
    return nullptr;
  To->setInitializedFieldInUnion(ToFD);
}

if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
  auto *ToSyntForm = cast_or_null<InitListExpr>(Importer.Import(SyntForm));
  if (!ToSyntForm)
    return nullptr;
  To->setSyntacticForm(ToSyntForm);
}

To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
To->setValueDependent(ILE->isValueDependent());
To->setInstantiationDependent(ILE->isInstantiationDependent());

return To;
6761}

6763Expr *ASTNodeImporter::VisitCXXStdInitializerListExpr(
  CXXStdInitializerListExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

Expr *SE = Importer.Import(E->getSubExpr());
if (!SE)
  return nullptr;

return new (Importer.getToContext()) CXXStdInitializerListExpr(T, SE);
6774}

6776Expr *ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
  CXXInheritedCtorInitExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

auto *Ctor = cast_or_null<CXXConstructorDecl>(Importer.Import(
    E->getConstructor()));
if (!Ctor)
  return nullptr;

return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
    Importer.Import(E->getLocation()), T, Ctor,
    E->constructsVBase(), E->inheritedFromVBase());
6790}

6792Expr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
QualType ToType = Importer.Import(E->getType());
if (ToType.isNull())
1
Taking false branch→
  return nullptr;

Expr *ToCommon = Importer.Import(E->getCommonExpr());
if (!ToCommon && E->getCommonExpr())
2
←
Assuming 'ToCommon' is non-null→
  return nullptr;

Expr *ToSubExpr = Importer.Import(E->getSubExpr());
3
←
Calling 'ASTImporter::Import'→
15
←
Returning from 'ASTImporter::Import'→
16
←
'ToSubExpr' initialized here→
if (!ToSubExpr && E->getSubExpr())
17
←
Assuming 'ToSubExpr' is null→
18
←
Assuming the condition is false→
19
←
Taking false branch→
  return nullptr;

return new (Importer.getToContext())
    ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr);
20
←
Passing null pointer value via 3rd parameter 'ElementInit'→
21
←
Calling constructor for 'ArrayInitLoopExpr'→
6807}

6809Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
QualType ToType = Importer.Import(E->getType());
if (ToType.isNull())
  return nullptr;
return new (Importer.getToContext()) ArrayInitIndexExpr(ToType);
6814}

6816Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
auto *ToField = dyn_cast_or_null<FieldDecl>(Importer.Import(DIE->getField()));
if (!ToField && DIE->getField())
  return nullptr;

return CXXDefaultInitExpr::Create(
    Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField);
6823}

6825Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
QualType ToType = Importer.Import(E->getType());
if (ToType.isNull() && !E->getType().isNull())
  return nullptr;
ExprValueKind VK = E->getValueKind();
CastKind CK = E->getCastKind();
Expr *ToOp = Importer.Import(E->getSubExpr());
if (!ToOp && E->getSubExpr())
  return nullptr;
CXXCastPath BasePath;
if (ImportCastPath(E, BasePath))
  return nullptr;
TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten());
SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc());
SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc());
SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets());

if (isa<CXXStaticCastExpr>(E)) {
  return CXXStaticCastExpr::Create(
      Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 
      ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
} else if (isa<CXXDynamicCastExpr>(E)) {
  return CXXDynamicCastExpr::Create(
      Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 
      ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
} else if (isa<CXXReinterpretCastExpr>(E)) {
  return CXXReinterpretCastExpr::Create(
      Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 
      ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
} else {
  return nullptr;
}
6857}

6859Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
  SubstNonTypeTemplateParmExpr *E) {
QualType T = Importer.Import(E->getType());
if (T.isNull())
  return nullptr;

auto *Param = cast_or_null<NonTypeTemplateParmDecl>(
      Importer.Import(E->getParameter()));
if (!Param)
  return nullptr;

Expr *Replacement = Importer.Import(E->getReplacement());
if (!Replacement)
  return nullptr;

return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
      T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param,
      Replacement);
6877}

6879Expr *ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
QualType ToType = Importer.Import(E->getType());
if (ToType.isNull())
  return nullptr;

SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
if (ImportContainerChecked(E->getArgs(), ToArgs))
  return nullptr;

// According to Sema::BuildTypeTrait(), if E is value-dependent,
// Value is always false.
bool ToValue = false;
if (!E->isValueDependent())
  ToValue = E->getValue();

return TypeTraitExpr::Create(
    Importer.getToContext(), ToType, Importer.Import(E->getLocStart()),
    E->getTrait(), ToArgs, Importer.Import(E->getLocEnd()), ToValue);
6897}

6899Expr *ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
QualType ToType = Importer.Import(E->getType());
if (ToType.isNull())
  return nullptr;

if (E->isTypeOperand()) {
  TypeSourceInfo *TSI = Importer.Import(E->getTypeOperandSourceInfo());
  if (!TSI)
    return nullptr;

  return new (Importer.getToContext())
      CXXTypeidExpr(ToType, TSI, Importer.Import(E->getSourceRange()));
}

Expr *Op = Importer.Import(E->getExprOperand());
if (!Op)
  return nullptr;

return new (Importer.getToContext())
    CXXTypeidExpr(ToType, Op, Importer.Import(E->getSourceRange()));
6919}

6921void ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod,
                                    CXXMethodDecl *FromMethod) {
for (auto *FromOverriddenMethod : FromMethod->overridden_methods())
  ToMethod->addOverriddenMethod(
    cast<CXXMethodDecl>(Importer.Import(const_cast<CXXMethodDecl*>(
                                          FromOverriddenMethod))));
6927}

6929ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
                       ASTContext &FromContext, FileManager &FromFileManager,
                       bool MinimalImport)
  : ToContext(ToContext), FromContext(FromContext),
    ToFileManager(ToFileManager), FromFileManager(FromFileManager),
    Minimal(MinimalImport) {
ImportedDecls[FromContext.getTranslationUnitDecl()]
  = ToContext.getTranslationUnitDecl();
6937}

6939ASTImporter::~ASTImporter() = default;

6941QualType ASTImporter::Import(QualType FromT) {
if (FromT.isNull())
  return {};

const Type *fromTy = FromT.getTypePtr();

// Check whether we've already imported this type.  
llvm::DenseMap<const Type *, const Type *>::iterator Pos
  = ImportedTypes.find(fromTy);
if (Pos != ImportedTypes.end())
  return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());

// Import the type
ASTNodeImporter Importer(*this);
QualType ToT = Importer.Visit(fromTy);
if (ToT.isNull())
  return ToT;

// Record the imported type.
ImportedTypes[fromTy] = ToT.getTypePtr();

return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
6963}

6965TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
if (!FromTSI)
  return FromTSI;

// FIXME: For now we just create a "trivial" type source info based
// on the type and a single location. Implement a real version of this.
QualType T = Import(FromTSI->getType());
if (T.isNull())
  return nullptr;

return ToContext.getTrivialTypeSourceInfo(T, 
         Import(FromTSI->getTypeLoc().getLocStart()));
6977}

6979Attr *ASTImporter::Import(const Attr *FromAttr) {
Attr *ToAttr = FromAttr->clone(ToContext);
ToAttr->setRange(Import(FromAttr->getRange()));
return ToAttr;
6983}

6985Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) {
llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
if (Pos != ImportedDecls.end()) {
  Decl *ToD = Pos->second;
  // FIXME: move this call to ImportDeclParts().
  ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
  return ToD;
} else {
  return nullptr;
}
6995}

6997Decl *ASTImporter::Import(Decl *FromD) {
if (!FromD)
  return nullptr;

ASTNodeImporter Importer(*this);

// Check whether we've already imported this declaration.
Decl *ToD = GetAlreadyImportedOrNull(FromD);
if (ToD) {
  // If FromD has some updated flags after last import, apply it
  updateFlags(FromD, ToD);
  return ToD;
}

// Import the type.
ToD = Importer.Visit(FromD);
if (!ToD)
  return nullptr;

// Notify subclasses.
Imported(FromD, ToD);

return ToD;
7020}

7022DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
if (!FromDC)
  return FromDC;

auto *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
if (!ToDC)
  return nullptr;

// When we're using a record/enum/Objective-C class/protocol as a context, we 
// need it to have a definition.
if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
  auto *FromRecord = cast<RecordDecl>(FromDC);
  if (ToRecord->isCompleteDefinition()) {
    // Do nothing.
  } else if (FromRecord->isCompleteDefinition()) {
    ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
                                            ASTNodeImporter::IDK_Basic);
  } else {
    CompleteDecl(ToRecord);
  }
} else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
  auto *FromEnum = cast<EnumDecl>(FromDC);
  if (ToEnum->isCompleteDefinition()) {
    // Do nothing.
  } else if (FromEnum->isCompleteDefinition()) {
    ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
                                            ASTNodeImporter::IDK_Basic);
  } else {
    CompleteDecl(ToEnum);
  }    
} else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
  auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
  if (ToClass->getDefinition()) {
    // Do nothing.
  } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
    ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
                                            ASTNodeImporter::IDK_Basic);
  } else {
    CompleteDecl(ToClass);
  }
} else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
  auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
  if (ToProto->getDefinition()) {
    // Do nothing.
  } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
    ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
                                            ASTNodeImporter::IDK_Basic);
  } else {
    CompleteDecl(ToProto);
  }    
}

return ToDC;
7075}

7077Expr *ASTImporter::Import(Expr *FromE) {
if (!FromE)
4
←
Assuming 'FromE' is non-null→
5
←
Taking false branch→
  return nullptr;

return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
6
←
Calling 'cast_or_null<clang::Expr, clang::Stmt>'→
14
←
Returning from 'cast_or_null<clang::Expr, clang::Stmt>'→
7082}

7084Stmt *ASTImporter::Import(Stmt *FromS) {
if (!FromS)
  return nullptr;

// Check whether we've already imported this declaration.  
llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
if (Pos != ImportedStmts.end())
  return Pos->second;

// Import the type
ASTNodeImporter Importer(*this);
Stmt *ToS = Importer.Visit(FromS);
if (!ToS)
  return nullptr;

// Record the imported declaration.
ImportedStmts[FromS] = ToS;
return ToS;
7102}

7104NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
if (!FromNNS)
  return nullptr;

NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());

switch (FromNNS->getKind()) {
case NestedNameSpecifier::Identifier:
  if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
    return NestedNameSpecifier::Create(ToContext, prefix, II);
  }
  return nullptr;

case NestedNameSpecifier::Namespace:
  if (auto *NS = 
          cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
    return NestedNameSpecifier::Create(ToContext, prefix, NS);
  }
  return nullptr;

case NestedNameSpecifier::NamespaceAlias:
  if (auto *NSAD = 
        cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
    return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
  }
  return nullptr;

case NestedNameSpecifier::Global:
  return NestedNameSpecifier::GlobalSpecifier(ToContext);

case NestedNameSpecifier::Super:
  if (auto *RD =
          cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
    return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
  }
  return nullptr;

case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate: {
    QualType T = Import(QualType(FromNNS->getAsType(), 0u));
    if (!T.isNull()) {
      bool bTemplate = FromNNS->getKind() == 
                       NestedNameSpecifier::TypeSpecWithTemplate;
      return NestedNameSpecifier::Create(ToContext, prefix, 
                                         bTemplate, T.getTypePtr());
    }
  }
    return nullptr;
}

llvm_unreachable("Invalid nested name specifier kind")::llvm::llvm_unreachable_internal("Invalid nested name specifier kind"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 7154);
7155}

7157NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
// Copied from NestedNameSpecifier mostly.
SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
NestedNameSpecifierLoc NNS = FromNNS;

// Push each of the nested-name-specifiers's onto a stack for
// serialization in reverse order.
while (NNS) {
  NestedNames.push_back(NNS);
  NNS = NNS.getPrefix();
}

NestedNameSpecifierLocBuilder Builder;

while (!NestedNames.empty()) {
  NNS = NestedNames.pop_back_val();
  NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier());
  if (!Spec)
    return NestedNameSpecifierLoc();

  NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
  switch (Kind) {
  case NestedNameSpecifier::Identifier:
    Builder.Extend(getToContext(),
                   Spec->getAsIdentifier(),
                   Import(NNS.getLocalBeginLoc()),
                   Import(NNS.getLocalEndLoc()));
    break;

  case NestedNameSpecifier::Namespace:
    Builder.Extend(getToContext(),
                   Spec->getAsNamespace(),
                   Import(NNS.getLocalBeginLoc()),
                   Import(NNS.getLocalEndLoc()));
    break;

  case NestedNameSpecifier::NamespaceAlias:
    Builder.Extend(getToContext(),
                   Spec->getAsNamespaceAlias(),
                   Import(NNS.getLocalBeginLoc()),
                   Import(NNS.getLocalEndLoc()));
    break;

  case NestedNameSpecifier::TypeSpec:
  case NestedNameSpecifier::TypeSpecWithTemplate: {
    TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
          QualType(Spec->getAsType(), 0));
    Builder.Extend(getToContext(),
                   Import(NNS.getLocalBeginLoc()),
                   TSI->getTypeLoc(),
                   Import(NNS.getLocalEndLoc()));
    break;
  }

  case NestedNameSpecifier::Global:
    Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc()));
    break;

  case NestedNameSpecifier::Super: {
    SourceRange ToRange = Import(NNS.getSourceRange());
    Builder.MakeSuper(getToContext(),
                      Spec->getAsRecordDecl(),
                      ToRange.getBegin(),
                      ToRange.getEnd());
  }
}
}

return Builder.getWithLocInContext(getToContext());
7226}

7228TemplateName ASTImporter::Import(TemplateName From) {
switch (From.getKind()) {
case TemplateName::Template:
  if (auto *ToTemplate =
          cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
    return TemplateName(ToTemplate);
    
  return {};
    
case TemplateName::OverloadedTemplate: {
  OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
  UnresolvedSet<2> ToTemplates;
  for (auto *I : *FromStorage) {
    if (auto *To = cast_or_null<NamedDecl>(Import(I))) 
      ToTemplates.addDecl(To);
    else
      return {};
  }
  return ToContext.getOverloadedTemplateName(ToTemplates.begin(), 
                                             ToTemplates.end());
}
    
case TemplateName::QualifiedTemplate: {
  QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
  NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
  if (!Qualifier)
    return {};
  
  if (auto *ToTemplate =
          cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
    return ToContext.getQualifiedTemplateName(Qualifier, 
                                              QTN->hasTemplateKeyword(), 
                                              ToTemplate);

  return {};
}

case TemplateName::DependentTemplate: {
  DependentTemplateName *DTN = From.getAsDependentTemplateName();
  NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
  if (!Qualifier)
    return {};
  
  if (DTN->isIdentifier()) {
    return ToContext.getDependentTemplateName(Qualifier, 
                                              Import(DTN->getIdentifier()));
  }
  
  return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
}

case TemplateName::SubstTemplateTemplateParm: {
  SubstTemplateTemplateParmStorage *subst
    = From.getAsSubstTemplateTemplateParm();
  auto *param =
      cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
  if (!param)
    return {};

  TemplateName replacement = Import(subst->getReplacement());
  if (replacement.isNull())
    return {};
  
  return ToContext.getSubstTemplateTemplateParm(param, replacement);
}
    
case TemplateName::SubstTemplateTemplateParmPack: {
  SubstTemplateTemplateParmPackStorage *SubstPack
    = From.getAsSubstTemplateTemplateParmPack();
  auto *Param =
      cast_or_null<TemplateTemplateParmDecl>(
          Import(SubstPack->getParameterPack()));
  if (!Param)
    return {};
  
  ASTNodeImporter Importer(*this);
  TemplateArgument ArgPack 
    = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
  if (ArgPack.isNull())
    return {};
  
  return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
}
}

llvm_unreachable("Invalid template name kind")::llvm::llvm_unreachable_internal("Invalid template name kind"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 7313);
7314}

7316SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
if (FromLoc.isInvalid())
  return {};

SourceManager &FromSM = FromContext.getSourceManager();

std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
FileID ToFileID = Import(Decomposed.first);
if (ToFileID.isInvalid())
  return {};
SourceManager &ToSM = ToContext.getSourceManager();
return ToSM.getComposedLoc(ToFileID, Decomposed.second);
7328}

7330SourceRange ASTImporter::Import(SourceRange FromRange) {
return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
7332}

7334FileID ASTImporter::Import(FileID FromID) {
llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
if (Pos != ImportedFileIDs.end())
  return Pos->second;

SourceManager &FromSM = FromContext.getSourceManager();
SourceManager &ToSM = ToContext.getSourceManager();
const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);

// Map the FromID to the "to" source manager.
FileID ToID;
if (FromSLoc.isExpansion()) {
  const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
  SourceLocation ToSpLoc = Import(FromEx.getSpellingLoc());
  SourceLocation ToExLocS = Import(FromEx.getExpansionLocStart());
  unsigned TokenLen = FromSM.getFileIDSize(FromID);
  SourceLocation MLoc;
  if (FromEx.isMacroArgExpansion()) {
    MLoc = ToSM.createMacroArgExpansionLoc(ToSpLoc, ToExLocS, TokenLen);
  } else {
    SourceLocation ToExLocE = Import(FromEx.getExpansionLocEnd());
    MLoc = ToSM.createExpansionLoc(ToSpLoc, ToExLocS, ToExLocE, TokenLen,
                                   FromEx.isExpansionTokenRange());
  }
  ToID = ToSM.getFileID(MLoc);
} else {
  // Include location of this file.
  SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());

  const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
  if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
    // FIXME: We probably want to use getVirtualFile(), so we don't hit the
    // disk again
    // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
    // than mmap the files several times.
    const FileEntry *Entry =
        ToFileManager.getFile(Cache->OrigEntry->getName());
    if (!Entry)
      return {};
    ToID = ToSM.createFileID(Entry, ToIncludeLoc,
                             FromSLoc.getFile().getFileCharacteristic());
  } else {
    // FIXME: We want to re-use the existing MemoryBuffer!
    const llvm::MemoryBuffer *FromBuf =
        Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
    std::unique_ptr<llvm::MemoryBuffer> ToBuf =
        llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
                                             FromBuf->getBufferIdentifier());
    ToID = ToSM.createFileID(std::move(ToBuf),
                             FromSLoc.getFile().getFileCharacteristic());
  }
}

ImportedFileIDs[FromID] = ToID;
return ToID;
7389}

7391CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
Expr *ToExpr = Import(From->getInit());
if (!ToExpr && From->getInit())
  return nullptr;

if (From->isBaseInitializer()) {
  TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
  if (!ToTInfo && From->getTypeSourceInfo())
    return nullptr;

  return new (ToContext) CXXCtorInitializer(
      ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
      ToExpr, Import(From->getRParenLoc()),
      From->isPackExpansion() ? Import(From->getEllipsisLoc())
                              : SourceLocation());
} else if (From->isMemberInitializer()) {
  auto *ToField = cast_or_null<FieldDecl>(Import(From->getMember()));
  if (!ToField && From->getMember())
    return nullptr;

  return new (ToContext) CXXCtorInitializer(
      ToContext, ToField, Import(From->getMemberLocation()),
      Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
} else if (From->isIndirectMemberInitializer()) {
  auto *ToIField = cast_or_null<IndirectFieldDecl>(
      Import(From->getIndirectMember()));
  if (!ToIField && From->getIndirectMember())
    return nullptr;

  return new (ToContext) CXXCtorInitializer(
      ToContext, ToIField, Import(From->getMemberLocation()),
      Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
} else if (From->isDelegatingInitializer()) {
  TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
  if (!ToTInfo && From->getTypeSourceInfo())
    return nullptr;

  return new (ToContext)
      CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
                         ToExpr, Import(From->getRParenLoc()));
} else {
  return nullptr;
}
7434}

7436CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
if (Pos != ImportedCXXBaseSpecifiers.end())
  return Pos->second;

CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
      Import(BaseSpec->getSourceRange()),
      BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
      BaseSpec->getAccessSpecifierAsWritten(),
      Import(BaseSpec->getTypeSourceInfo()),
      Import(BaseSpec->getEllipsisLoc()));
ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
return Imported;
7449}

7451void ASTImporter::ImportDefinition(Decl *From) {
Decl *To = Import(From);
if (!To)
  return;

if (auto *FromDC = cast<DeclContext>(From)) {
  ASTNodeImporter Importer(*this);
    
  if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
    if (!ToRecord->getDefinition()) {
      Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord, 
                                ASTNodeImporter::IDK_Everything);
      return;
    }      
  }

  if (auto *ToEnum = dyn_cast<EnumDecl>(To)) {
    if (!ToEnum->getDefinition()) {
      Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum, 
                                ASTNodeImporter::IDK_Everything);
      return;
    }      
  }
  
  if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
    if (!ToIFace->getDefinition()) {
      Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
                                ASTNodeImporter::IDK_Everything);
      return;
    }
  }

  if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
    if (!ToProto->getDefinition()) {
      Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
                                ASTNodeImporter::IDK_Everything);
      return;
    }
  }
  
  Importer.ImportDeclContext(FromDC, true);
}
7493}

7495DeclarationName ASTImporter::Import(DeclarationName FromName) {
if (!FromName)
  return {};

switch (FromName.getNameKind()) {
case DeclarationName::Identifier:
  return Import(FromName.getAsIdentifierInfo());

case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
  return Import(FromName.getObjCSelector());

case DeclarationName::CXXConstructorName: {
  QualType T = Import(FromName.getCXXNameType());
  if (T.isNull())
    return {};

  return ToContext.DeclarationNames.getCXXConstructorName(
                                             ToContext.getCanonicalType(T));
}

case DeclarationName::CXXDestructorName: {
  QualType T = Import(FromName.getCXXNameType());
  if (T.isNull())
    return {};

  return ToContext.DeclarationNames.getCXXDestructorName(
                                             ToContext.getCanonicalType(T));
}

case DeclarationName::CXXDeductionGuideName: {
  auto *Template = cast_or_null<TemplateDecl>(
      Import(FromName.getCXXDeductionGuideTemplate()));
  if (!Template)
    return {};
  return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
}

case DeclarationName::CXXConversionFunctionName: {
  QualType T = Import(FromName.getCXXNameType());
  if (T.isNull())
    return {};

  return ToContext.DeclarationNames.getCXXConversionFunctionName(
                                             ToContext.getCanonicalType(T));
}

case DeclarationName::CXXOperatorName:
  return ToContext.DeclarationNames.getCXXOperatorName(
                                        FromName.getCXXOverloadedOperator());

case DeclarationName::CXXLiteralOperatorName:
  return ToContext.DeclarationNames.getCXXLiteralOperatorName(
                                 Import(FromName.getCXXLiteralIdentifier()));

case DeclarationName::CXXUsingDirective:
  // FIXME: STATICS!
  return DeclarationName::getUsingDirectiveName();
}

llvm_unreachable("Invalid DeclarationName Kind!")::llvm::llvm_unreachable_internal("Invalid DeclarationName Kind!"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 7556);
7557}

7559IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
if (!FromId)
  return nullptr;

IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());

if (!ToId->getBuiltinID() && FromId->getBuiltinID())
  ToId->setBuiltinID(FromId->getBuiltinID());

return ToId;
7569}

7571Selector ASTImporter::Import(Selector FromSel) {
if (FromSel.isNull())
  return {};

SmallVector<IdentifierInfo *, 4> Idents;
Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
  Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
7580}

7582DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
                                              DeclContext *DC,
                                              unsigned IDNS,
                                              NamedDecl **Decls,
                                              unsigned NumDecls) {
return Name;
7588}

7590DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
if (LastDiagFromFrom)
  ToContext.getDiagnostics().notePriorDiagnosticFrom(
    FromContext.getDiagnostics());
LastDiagFromFrom = false;
return ToContext.getDiagnostics().Report(Loc, DiagID);
7596}

7598DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
if (!LastDiagFromFrom)
  FromContext.getDiagnostics().notePriorDiagnosticFrom(
    ToContext.getDiagnostics());
LastDiagFromFrom = true;
return FromContext.getDiagnostics().Report(Loc, DiagID);
7604}

7606void ASTImporter::CompleteDecl (Decl *D) {
if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
  if (!ID->getDefinition())
    ID->startDefinition();
}
else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
  if (!PD->getDefinition())
    PD->startDefinition();
}
else if (auto *TD = dyn_cast<TagDecl>(D)) {
  if (!TD->getDefinition() && !TD->isBeingDefined()) {
    TD->startDefinition();
    TD->setCompleteDefinition(true);
  }
}
else {
  assert(0 && "CompleteDecl called on a Decl that can't be completed")(static_cast <bool> (0 && "CompleteDecl called on a Decl that can't be completed"
) ? void (0) : __assert_fail ("0 && \"CompleteDecl called on a Decl that can't be completed\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 7622, __extension__ __PRETTY_FUNCTION__));
}
7624}

7626Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
assert((Pos == ImportedDecls.end() || Pos->second == To) &&(static_cast <bool> ((Pos == ImportedDecls.end() || Pos
->second == To) && "Try to import an already imported Decl"
) ? void (0) : __assert_fail ("(Pos == ImportedDecls.end() || Pos->second == To) && \"Try to import an already imported Decl\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 7629, __extension__ __PRETTY_FUNCTION__))
    "Try to import an already imported Decl")(static_cast <bool> ((Pos == ImportedDecls.end() || Pos
->second == To) && "Try to import an already imported Decl"
) ? void (0) : __assert_fail ("(Pos == ImportedDecls.end() || Pos->second == To) && \"Try to import an already imported Decl\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTImporter.cpp"
, 7629, __extension__ __PRETTY_FUNCTION__));
if (Pos != ImportedDecls.end())
  return Pos->second;
ImportedDecls[From] = To;
return To;
7634}

7636bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
                                         bool Complain) {
llvm::DenseMap<const Type *, const Type *>::iterator Pos
 = ImportedTypes.find(From.getTypePtr());
if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
  return true;

StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
                                 getStructuralEquivalenceKind(*this), false,
                                 Complain);
return Ctx.IsEquivalent(From, To);
7647}

←

/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h

→

1//===- llvm/Support/Casting.h - Allow flexible, checked, casts --*- C++ -*-===//
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 defines the isa<X>(), cast<X>(), dyn_cast<X>(), cast_or_null<X>(),
11// and dyn_cast_or_null<X>() templates.
12//
13//===----------------------------------------------------------------------===//
14 
15#ifndef LLVM_SUPPORT_CASTING_H
16#define LLVM_SUPPORT_CASTING_H
17 
18#include "llvm/Support/Compiler.h"
19#include "llvm/Support/type_traits.h"
20#include <cassert>
21#include <memory>
22#include <type_traits>
23 
24namespace llvm {
25 
26//===----------------------------------------------------------------------===//
27//                          isa<x> Support Templates
28//===----------------------------------------------------------------------===//
29 
30// Define a template that can be specialized by smart pointers to reflect the
31// fact that they are automatically dereferenced, and are not involved with the
32// template selection process...  the default implementation is a noop.
33//
34template<typename From> struct simplify_type {
35  using SimpleType = From; // The real type this represents...
36 
37  // An accessor to get the real value...
38  static SimpleType &getSimplifiedValue(From &Val) { return Val; }
39};
40 
41template<typename From> struct simplify_type<const From> {
42  using NonConstSimpleType = typename simplify_type<From>::SimpleType;
43  using SimpleType =
44      typename add_const_past_pointer<NonConstSimpleType>::type;
45  using RetType =
46      typename add_lvalue_reference_if_not_pointer<SimpleType>::type;
47 
48  static RetType getSimplifiedValue(const From& Val) {
49    return simplify_type<From>::getSimplifiedValue(const_cast<From&>(Val));
50  }
51};
52 
53// The core of the implementation of isa<X> is here; To and From should be
54// the names of classes.  This template can be specialized to customize the
55// implementation of isa<> without rewriting it from scratch.
56template <typename To, typename From, typename Enabler = void>
57struct isa_impl {
58  static inline bool doit(const From &Val) {
59    return To::classof(&Val);
60  }
61};
62 
63/// Always allow upcasts, and perform no dynamic check for them.
64template <typename To, typename From>
65struct isa_impl<
66    To, From, typename std::enable_if<std::is_base_of<To, From>::value>::type> {
67  static inline bool doit(const From &) { return true; }
68};
69 
70template <typename To, typename From> struct isa_impl_cl {
71  static inline bool doit(const From &Val) {
72    return isa_impl<To, From>::doit(Val);
73  }
74};
75 
76template <typename To, typename From> struct isa_impl_cl<To, const From> {
77  static inline bool doit(const From &Val) {
78    return isa_impl<To, From>::doit(Val);
79  }
80};
81 
82template <typename To, typename From>
83struct isa_impl_cl<To, const std::unique_ptr<From>> {
84  static inline bool doit(const std::unique_ptr<From> &Val) {
85    assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 85, __extension__ __PRETTY_FUNCTION__));
86    return isa_impl_cl<To, From>::doit(*Val);
87  }
88};
89 
90template <typename To, typename From> struct isa_impl_cl<To, From*> {
91  static inline bool doit(const From *Val) {
92    assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 92, __extension__ __PRETTY_FUNCTION__));
93    return isa_impl<To, From>::doit(*Val);
94  }
95};
96 
97template <typename To, typename From> struct isa_impl_cl<To, From*const> {
98  static inline bool doit(const From *Val) {
99    assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 99, __extension__ __PRETTY_FUNCTION__));
100    return isa_impl<To, From>::doit(*Val);
101  }
102};
103 
104template <typename To, typename From> struct isa_impl_cl<To, const From*> {
105  static inline bool doit(const From *Val) {
106    assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 106, __extension__ __PRETTY_FUNCTION__));
107    return isa_impl<To, From>::doit(*Val);
108  }
109};
110 
111template <typename To, typename From> struct isa_impl_cl<To, const From*const> {
112  static inline bool doit(const From *Val) {
113    assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 113, __extension__ __PRETTY_FUNCTION__));
114    return isa_impl<To, From>::doit(*Val);
115  }
116};
117 
118template<typename To, typename From, typename SimpleFrom>
119struct isa_impl_wrap {
120  // When From != SimplifiedType, we can simplify the type some more by using
121  // the simplify_type template.
122  static bool doit(const From &Val) {
123    return isa_impl_wrap<To, SimpleFrom,
124      typename simplify_type<SimpleFrom>::SimpleType>::doit(
125                          simplify_type<const From>::getSimplifiedValue(Val));
126  }
127};
128 
129template<typename To, typename FromTy>
130struct isa_impl_wrap<To, FromTy, FromTy> {
131  // When From == SimpleType, we are as simple as we are going to get.
132  static bool doit(const FromTy &Val) {
133    return isa_impl_cl<To,FromTy>::doit(Val);
134  }
135};
136 
137// isa<X> - Return true if the parameter to the template is an instance of the
138// template type argument.  Used like this:
139//
140//  if (isa<Type>(myVal)) { ... }
141//
142template <class X, class Y> LLVM_NODISCARD[[clang::warn_unused_result]] inline bool isa(const Y &Val) {
143  return isa_impl_wrap<X, const Y,
144                       typename simplify_type<const Y>::SimpleType>::doit(Val);
145}
146 
147//===----------------------------------------------------------------------===//
148//                          cast<x> Support Templates
149//===----------------------------------------------------------------------===//
150 
151template<class To, class From> struct cast_retty;
152 
153// Calculate what type the 'cast' function should return, based on a requested
154// type of To and a source type of From.
155template<class To, class From> struct cast_retty_impl {
156  using ret_type = To &;       // Normal case, return Ty&
157};
158template<class To, class From> struct cast_retty_impl<To, const From> {
159  using ret_type = const To &; // Normal case, return Ty&
160};
161 
162template<class To, class From> struct cast_retty_impl<To, From*> {
163  using ret_type = To *;       // Pointer arg case, return Ty*
164};
165 
166template<class To, class From> struct cast_retty_impl<To, const From*> {
167  using ret_type = const To *; // Constant pointer arg case, return const Ty*
168};
169 
170template<class To, class From> struct cast_retty_impl<To, const From*const> {
171  using ret_type = const To *; // Constant pointer arg case, return const Ty*
172};
173 
174template <class To, class From>
175struct cast_retty_impl<To, std::unique_ptr<From>> {
176private:
177  using PointerType = typename cast_retty_impl<To, From *>::ret_type;
178  using ResultType = typename std::remove_pointer<PointerType>::type;
179 
180public:
181  using ret_type = std::unique_ptr<ResultType>;
182};
183 
184template<class To, class From, class SimpleFrom>
185struct cast_retty_wrap {
186  // When the simplified type and the from type are not the same, use the type
187  // simplifier to reduce the type, then reuse cast_retty_impl to get the
188  // resultant type.
189  using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
190};
191 
192template<class To, class FromTy>
193struct cast_retty_wrap<To, FromTy, FromTy> {
194  // When the simplified type is equal to the from type, use it directly.
195  using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
196};
197 
198template<class To, class From>
199struct cast_retty {
200  using ret_type = typename cast_retty_wrap<
201      To, From, typename simplify_type<From>::SimpleType>::ret_type;
202};
203 
204// Ensure the non-simple values are converted using the simplify_type template
205// that may be specialized by smart pointers...
206//
207template<class To, class From, class SimpleFrom> struct cast_convert_val {
208  // This is not a simple type, use the template to simplify it...
209  static typename cast_retty<To, From>::ret_type doit(From &Val) {
210    return cast_convert_val<To, SimpleFrom,
211      typename simplify_type<SimpleFrom>::SimpleType>::doit(
212                          simplify_type<From>::getSimplifiedValue(Val));
213  }
214};
215 
216template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {
217  // This _is_ a simple type, just cast it.
218  static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
219    typename cast_retty<To, FromTy>::ret_type Res2
220     = (typename cast_retty<To, FromTy>::ret_type)const_cast<FromTy&>(Val);
221    return Res2;
222  }
223};
224 
225template <class X> struct is_simple_type {
226  static const bool value =
227      std::is_same<X, typename simplify_type<X>::SimpleType>::value;
228};
229 
230// cast<X> - Return the argument parameter cast to the specified type.  This
231// casting operator asserts that the type is correct, so it does not return null
232// on failure.  It does not allow a null argument (use cast_or_null for that).
233// It is typically used like this:
234//
235//  cast<Instruction>(myVal)->getParent()
236//
237template <class X, class Y>
238inline typename std::enable_if<!is_simple_type<Y>::value,
239                               typename cast_retty<X, const Y>::ret_type>::type
240cast(const Y &Val) {
241  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 241, __extension__ __PRETTY_FUNCTION__));
242  return cast_convert_val<
243      X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
244}
245 
246template <class X, class Y>
247inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
248  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 248, __extension__ __PRETTY_FUNCTION__));
249  return cast_convert_val<X, Y,
250                          typename simplify_type<Y>::SimpleType>::doit(Val);
251}
252 
253template <class X, class Y>
254inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
255  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 255, __extension__ __PRETTY_FUNCTION__));
10
←
Within the expansion of the macro 'assert':
→
a
Assuming the condition is true
256  return cast_convert_val<X, Y*,
11
←
Calling 'cast_convert_val::doit'→
12
←
Returning from 'cast_convert_val::doit'→
257                          typename simplify_type<Y*>::SimpleType>::doit(Val);
258}
259 
260template <class X, class Y>
261inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
262cast(std::unique_ptr<Y> &&Val) {
263  assert(isa<X>(Val.get()) && "cast<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val.get()) &&
 "cast<Ty>() argument of incompatible type!") ? void (0
) : __assert_fail ("isa<X>(Val.get()) && \"cast<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 263, __extension__ __PRETTY_FUNCTION__));
264  using ret_type = typename cast_retty<X, std::unique_ptr<Y>>::ret_type;
265  return ret_type(
266      cast_convert_val<X, Y *, typename simplify_type<Y *>::SimpleType>::doit(
267          Val.release()));
268}
269 
270// cast_or_null<X> - Functionally identical to cast, except that a null value is
271// accepted.
272//
273template <class X, class Y>
274LLVM_NODISCARD[[clang::warn_unused_result]] inline
275    typename std::enable_if<!is_simple_type<Y>::value,
276                            typename cast_retty<X, const Y>::ret_type>::type
277    cast_or_null(const Y &Val) {
278  if (!Val)
279    return nullptr;
280  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast_or_null<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 280, __extension__ __PRETTY_FUNCTION__));
281  return cast<X>(Val);
282}
283 
284template <class X, class Y>
285LLVM_NODISCARD[[clang::warn_unused_result]] inline
286    typename std::enable_if<!is_simple_type<Y>::value,
287                            typename cast_retty<X, Y>::ret_type>::type
288    cast_or_null(Y &Val) {
289  if (!Val)
290    return nullptr;
291  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast_or_null<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 291, __extension__ __PRETTY_FUNCTION__));
292  return cast<X>(Val);
293}
294 
295template <class X, class Y>
296LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y *>::ret_type
297cast_or_null(Y *Val) {
298  if (!Val) return nullptr;
7
←
Taking false branch→
299  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast_or_null<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/Support/Casting.h"
, 299, __extension__ __PRETTY_FUNCTION__));
8
←
Within the expansion of the macro 'assert':
→
300  return cast<X>(Val);
9
←
Calling 'cast<clang::Expr, clang::Stmt>'→
13
←
Returning from 'cast<clang::Expr, clang::Stmt>'→
301}
302 
303template <class X, class Y>
304inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
305cast_or_null(std::unique_ptr<Y> &&Val) {
306  if (!Val)
307    return nullptr;
308  return cast<X>(std::move(Val));
309}
310 
311// dyn_cast<X> - Return the argument parameter cast to the specified type.  This
312// casting operator returns null if the argument is of the wrong type, so it can
313// be used to test for a type as well as cast if successful.  This should be
314// used in the context of an if statement like this:
315//
316//  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
317//
318 
319template <class X, class Y>
320LLVM_NODISCARD[[clang::warn_unused_result]] inline
321    typename std::enable_if<!is_simple_type<Y>::value,
322                            typename cast_retty<X, const Y>::ret_type>::type
323    dyn_cast(const Y &Val) {
324  return isa<X>(Val) ? cast<X>(Val) : nullptr;
325}
326 
327template <class X, class Y>
328LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
329  return isa<X>(Val) ? cast<X>(Val) : nullptr;
330}
331 
332template <class X, class Y>
333LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
334  return isa<X>(Val) ? cast<X>(Val) : nullptr;
335}
336 
337// dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null
338// value is accepted.
339//
340template <class X, class Y>
341LLVM_NODISCARD[[clang::warn_unused_result]] inline
342    typename std::enable_if<!is_simple_type<Y>::value,
343                            typename cast_retty<X, const Y>::ret_type>::type
344    dyn_cast_or_null(const Y &Val) {
345  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
346}
347 
348template <class X, class Y>
349LLVM_NODISCARD[[clang::warn_unused_result]] inline
350    typename std::enable_if<!is_simple_type<Y>::value,
351                            typename cast_retty<X, Y>::ret_type>::type
352    dyn_cast_or_null(Y &Val) {
353  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
354}
355 
356template <class X, class Y>
357LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y *>::ret_type
358dyn_cast_or_null(Y *Val) {
359  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
360}
361 
362// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,
363// taking ownership of the input pointer iff isa<X>(Val) is true.  If the
364// cast is successful, From refers to nullptr on exit and the casted value
365// is returned.  If the cast is unsuccessful, the function returns nullptr
366// and From is unchanged.
367template <class X, class Y>
368LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast(std::unique_ptr<Y> &Val)
369    -> decltype(cast<X>(Val)) {
370  if (!isa<X>(Val))
371    return nullptr;
372  return cast<X>(std::move(Val));
373}
374 
375template <class X, class Y>
376LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val)
377    -> decltype(cast<X>(Val)) {
378  return unique_dyn_cast<X, Y>(Val);
379}
380 
381// dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast, except that
382// a null value is accepted.
383template <class X, class Y>
384LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &Val)
385    -> decltype(cast<X>(Val)) {
386  if (!Val)
387    return nullptr;
388  return unique_dyn_cast<X, Y>(Val);
389}
390 
391template <class X, class Y>
392LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val)
393    -> decltype(cast<X>(Val)) {
394  return unique_dyn_cast_or_null<X, Y>(Val);
395}
396 
397} // end namespace llvm
398 
399#endif // LLVM_SUPPORT_CASTING_H

←

/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h

1//===--- Expr.h - Classes for representing expressions ----------*- C++ -*-===//
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 defines the Expr interface and subclasses.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_CLANG_AST_EXPR_H
15#define LLVM_CLANG_AST_EXPR_H

17#include "clang/AST/APValue.h"
18#include "clang/AST/ASTVector.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclAccessPair.h"
21#include "clang/AST/OperationKinds.h"
22#include "clang/AST/Stmt.h"
23#include "clang/AST/TemplateBase.h"
24#include "clang/AST/Type.h"
25#include "clang/Basic/CharInfo.h"
26#include "clang/Basic/LangOptions.h"
27#include "clang/Basic/SyncScope.h"
28#include "clang/Basic/TypeTraits.h"
29#include "llvm/ADT/APFloat.h"
30#include "llvm/ADT/APSInt.h"
31#include "llvm/ADT/SmallVector.h"
32#include "llvm/ADT/StringRef.h"
33#include "llvm/Support/AtomicOrdering.h"
34#include "llvm/Support/Compiler.h"

36namespace clang {
class APValue;
class ASTContext;
class BlockDecl;
class CXXBaseSpecifier;
class CXXMemberCallExpr;
class CXXOperatorCallExpr;
class CastExpr;
class Decl;
class IdentifierInfo;
class MaterializeTemporaryExpr;
class NamedDecl;
class ObjCPropertyRefExpr;
class OpaqueValueExpr;
class ParmVarDecl;
class StringLiteral;
class TargetInfo;
class ValueDecl;

55/// A simple array of base specifiers.
56typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;

58/// An adjustment to be made to the temporary created when emitting a
59/// reference binding, which accesses a particular subobject of that temporary.
60struct SubobjectAdjustment {
enum {
  DerivedToBaseAdjustment,
  FieldAdjustment,
  MemberPointerAdjustment
} Kind;

struct DTB {
  const CastExpr *BasePath;
  const CXXRecordDecl *DerivedClass;
};

struct P {
  const MemberPointerType *MPT;
  Expr *RHS;
};

union {
  struct DTB DerivedToBase;
  FieldDecl *Field;
  struct P Ptr;
};

SubobjectAdjustment(const CastExpr *BasePath,
                    const CXXRecordDecl *DerivedClass)
  : Kind(DerivedToBaseAdjustment) {
  DerivedToBase.BasePath = BasePath;
  DerivedToBase.DerivedClass = DerivedClass;
}

SubobjectAdjustment(FieldDecl *Field)
  : Kind(FieldAdjustment) {
  this->Field = Field;
}

SubobjectAdjustment(const MemberPointerType *MPT, Expr *RHS)
  : Kind(MemberPointerAdjustment) {
  this->Ptr.MPT = MPT;
  this->Ptr.RHS = RHS;
}
100};

102/// Expr - This represents one expression.  Note that Expr's are subclasses of
103/// Stmt.  This allows an expression to be transparently used any place a Stmt
104/// is required.
105///
106class Expr : public Stmt {
QualType TR;

109protected:
Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK,
     bool TD, bool VD, bool ID, bool ContainsUnexpandedParameterPack)
  : Stmt(SC)
{
  ExprBits.TypeDependent = TD;
  ExprBits.ValueDependent = VD;
  ExprBits.InstantiationDependent = ID;
  ExprBits.ValueKind = VK;
  ExprBits.ObjectKind = OK;
  assert(ExprBits.ObjectKind == OK && "truncated kind")(static_cast <bool> (ExprBits.ObjectKind == OK &&
 "truncated kind") ? void (0) : __assert_fail ("ExprBits.ObjectKind == OK && \"truncated kind\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 119, __extension__ __PRETTY_FUNCTION__));
  ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
  setType(T);
}

/// Construct an empty expression.
explicit Expr(StmtClass SC, EmptyShell) : Stmt(SC) { }

127public:
QualType getType() const { return TR; }
void setType(QualType t) {
  // In C++, the type of an expression is always adjusted so that it
  // will not have reference type (C++ [expr]p6). Use
  // QualType::getNonReferenceType() to retrieve the non-reference
  // type. Additionally, inspect Expr::isLvalue to determine whether
  // an expression that is adjusted in this manner should be
  // considered an lvalue.
  assert((t.isNull() || !t->isReferenceType()) &&(static_cast <bool> ((t.isNull() || !t->isReferenceType
()) && "Expressions can't have reference type") ? void
 (0) : __assert_fail ("(t.isNull() || !t->isReferenceType()) && \"Expressions can't have reference type\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 137, __extension__ __PRETTY_FUNCTION__))
         "Expressions can't have reference type")(static_cast <bool> ((t.isNull() || !t->isReferenceType
()) && "Expressions can't have reference type") ? void
 (0) : __assert_fail ("(t.isNull() || !t->isReferenceType()) && \"Expressions can't have reference type\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 137, __extension__ __PRETTY_FUNCTION__));

  TR = t;
}

/// isValueDependent - Determines whether this expression is
/// value-dependent (C++ [temp.dep.constexpr]). For example, the
/// array bound of "Chars" in the following example is
/// value-dependent.
/// @code
/// template<int Size, char (&Chars)[Size]> struct meta_string;
/// @endcode
bool isValueDependent() const { return ExprBits.ValueDependent; }

/// Set whether this expression is value-dependent or not.
void setValueDependent(bool VD) {
  ExprBits.ValueDependent = VD;
}

/// isTypeDependent - Determines whether this expression is
/// type-dependent (C++ [temp.dep.expr]), which means that its type
/// could change from one template instantiation to the next. For
/// example, the expressions "x" and "x + y" are type-dependent in
/// the following code, but "y" is not type-dependent:
/// @code
/// template<typename T>
/// void add(T x, int y) {
///   x + y;
/// }
/// @endcode
bool isTypeDependent() const { return ExprBits.TypeDependent; }

/// Set whether this expression is type-dependent or not.
void setTypeDependent(bool TD) {
  ExprBits.TypeDependent = TD;
}

/// Whether this expression is instantiation-dependent, meaning that
/// it depends in some way on a template parameter, even if neither its type
/// nor (constant) value can change due to the template instantiation.
///
/// In the following example, the expression \c sizeof(sizeof(T() + T())) is
/// instantiation-dependent (since it involves a template parameter \c T), but
/// is neither type- nor value-dependent, since the type of the inner
/// \c sizeof is known (\c std::size_t) and therefore the size of the outer
/// \c sizeof is known.
///
/// \code
/// template<typename T>
/// void f(T x, T y) {
///   sizeof(sizeof(T() + T());
/// }
/// \endcode
///
bool isInstantiationDependent() const {
  return ExprBits.InstantiationDependent;
}

/// Set whether this expression is instantiation-dependent or not.
void setInstantiationDependent(bool ID) {
  ExprBits.InstantiationDependent = ID;
}

/// Whether this expression contains an unexpanded parameter
/// pack (for C++11 variadic templates).
///
/// Given the following function template:
///
/// \code
/// template<typename F, typename ...Types>
/// void forward(const F &f, Types &&...args) {
///   f(static_cast<Types&&>(args)...);
/// }
/// \endcode
///
/// The expressions \c args and \c static_cast<Types&&>(args) both
/// contain parameter packs.
bool containsUnexpandedParameterPack() const {
  return ExprBits.ContainsUnexpandedParameterPack;
}

/// Set the bit that describes whether this expression
/// contains an unexpanded parameter pack.
void setContainsUnexpandedParameterPack(bool PP = true) {
  ExprBits.ContainsUnexpandedParameterPack = PP;
}

/// getExprLoc - Return the preferred location for the arrow when diagnosing
/// a problem with a generic expression.
SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__));

/// isUnusedResultAWarning - Return true if this immediate expression should
/// be warned about if the result is unused.  If so, fill in expr, location,
/// and ranges with expr to warn on and source locations/ranges appropriate
/// for a warning.
bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc,
                            SourceRange &R1, SourceRange &R2,
                            ASTContext &Ctx) const;

/// isLValue - True if this expression is an "l-value" according to
/// the rules of the current language.  C and C++ give somewhat
/// different rules for this concept, but in general, the result of
/// an l-value expression identifies a specific object whereas the
/// result of an r-value expression is a value detached from any
/// specific storage.
///
/// C++11 divides the concept of "r-value" into pure r-values
/// ("pr-values") and so-called expiring values ("x-values"), which
/// identify specific objects that can be safely cannibalized for
/// their resources.  This is an unfortunate abuse of terminology on
/// the part of the C++ committee.  In Clang, when we say "r-value",
/// we generally mean a pr-value.
bool isLValue() const { return getValueKind() == VK_LValue; }
bool isRValue() const { return getValueKind() == VK_RValue; }
bool isXValue() const { return getValueKind() == VK_XValue; }
bool isGLValue() const { return getValueKind() != VK_RValue; }

enum LValueClassification {
  LV_Valid,
  LV_NotObjectType,
  LV_IncompleteVoidType,
  LV_DuplicateVectorComponents,
  LV_InvalidExpression,
  LV_InvalidMessageExpression,
  LV_MemberFunction,
  LV_SubObjCPropertySetting,
  LV_ClassTemporary,
  LV_ArrayTemporary
};
/// Reasons why an expression might not be an l-value.
LValueClassification ClassifyLValue(ASTContext &Ctx) const;

enum isModifiableLvalueResult {
  MLV_Valid,
  MLV_NotObjectType,
  MLV_IncompleteVoidType,
  MLV_DuplicateVectorComponents,
  MLV_InvalidExpression,
  MLV_LValueCast,           // Specialized form of MLV_InvalidExpression.
  MLV_IncompleteType,
  MLV_ConstQualified,
  MLV_ConstQualifiedField,
  MLV_ConstAddrSpace,
  MLV_ArrayType,
  MLV_NoSetterProperty,
  MLV_MemberFunction,
  MLV_SubObjCPropertySetting,
  MLV_InvalidMessageExpression,
  MLV_ClassTemporary,
  MLV_ArrayTemporary
};
/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
/// does not have an incomplete type, does not have a const-qualified type,
/// and if it is a structure or union, does not have any member (including,
/// recursively, any member or element of all contained aggregates or unions)
/// with a const-qualified type.
///
/// \param Loc [in,out] - A source location which *may* be filled
/// in with the location of the expression making this a
/// non-modifiable lvalue, if specified.
isModifiableLvalueResult
isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc = nullptr) const;

/// The return type of classify(). Represents the C++11 expression
///        taxonomy.
class Classification {
public:
  /// The various classification results. Most of these mean prvalue.
  enum Kinds {
    CL_LValue,
    CL_XValue,
    CL_Function, // Functions cannot be lvalues in C.
    CL_Void, // Void cannot be an lvalue in C.
    CL_AddressableVoid, // Void expression whose address can be taken in C.
    CL_DuplicateVectorComponents, // A vector shuffle with dupes.
    CL_MemberFunction, // An expression referring to a member function
    CL_SubObjCPropertySetting,
    CL_ClassTemporary, // A temporary of class type, or subobject thereof.
    CL_ArrayTemporary, // A temporary of array type.
    CL_ObjCMessageRValue, // ObjC message is an rvalue
    CL_PRValue // A prvalue for any other reason, of any other type
  };
  /// The results of modification testing.
  enum ModifiableType {
    CM_Untested, // testModifiable was false.
    CM_Modifiable,
    CM_RValue, // Not modifiable because it's an rvalue
    CM_Function, // Not modifiable because it's a function; C++ only
    CM_LValueCast, // Same as CM_RValue, but indicates GCC cast-as-lvalue ext
    CM_NoSetterProperty,// Implicit assignment to ObjC property without setter
    CM_ConstQualified,
    CM_ConstQualifiedField,
    CM_ConstAddrSpace,
    CM_ArrayType,
    CM_IncompleteType
  };

private:
  friend class Expr;

  unsigned short Kind;
  unsigned short Modifiable;

  explicit Classification(Kinds k, ModifiableType m)
    : Kind(k), Modifiable(m)
  {}

public:
  Classification() {}

  Kinds getKind() const { return static_cast<Kinds>(Kind); }
  ModifiableType getModifiable() const {
    assert(Modifiable != CM_Untested && "Did not test for modifiability.")(static_cast <bool> (Modifiable != CM_Untested &&
 "Did not test for modifiability.") ? void (0) : __assert_fail
 ("Modifiable != CM_Untested && \"Did not test for modifiability.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 349, __extension__ __PRETTY_FUNCTION__));
    return static_cast<ModifiableType>(Modifiable);
  }
  bool isLValue() const { return Kind == CL_LValue; }
  bool isXValue() const { return Kind == CL_XValue; }
  bool isGLValue() const { return Kind <= CL_XValue; }
  bool isPRValue() const { return Kind >= CL_Function; }
  bool isRValue() const { return Kind >= CL_XValue; }
  bool isModifiable() const { return getModifiable() == CM_Modifiable; }

  /// Create a simple, modifiably lvalue
  static Classification makeSimpleLValue() {
    return Classification(CL_LValue, CM_Modifiable);
  }

};
/// Classify - Classify this expression according to the C++11
///        expression taxonomy.
///
/// C++11 defines ([basic.lval]) a new taxonomy of expressions to replace the
/// old lvalue vs rvalue. This function determines the type of expression this
/// is. There are three expression types:
/// - lvalues are classical lvalues as in C++03.
/// - prvalues are equivalent to rvalues in C++03.
/// - xvalues are expressions yielding unnamed rvalue references, e.g. a
///   function returning an rvalue reference.
/// lvalues and xvalues are collectively referred to as glvalues, while
/// prvalues and xvalues together form rvalues.
Classification Classify(ASTContext &Ctx) const {
  return ClassifyImpl(Ctx, nullptr);
}

/// ClassifyModifiable - Classify this expression according to the
///        C++11 expression taxonomy, and see if it is valid on the left side
///        of an assignment.
///
/// This function extends classify in that it also tests whether the
/// expression is modifiable (C99 6.3.2.1p1).
/// \param Loc A source location that might be filled with a relevant location
///            if the expression is not modifiable.
Classification ClassifyModifiable(ASTContext &Ctx, SourceLocation &Loc) const{
  return ClassifyImpl(Ctx, &Loc);
}

/// getValueKindForType - Given a formal return or parameter type,
/// give its value kind.
static ExprValueKind getValueKindForType(QualType T) {
  if (const ReferenceType *RT = T->getAs<ReferenceType>())
    return (isa<LValueReferenceType>(RT)
              ? VK_LValue
              : (RT->getPointeeType()->isFunctionType()
                   ? VK_LValue : VK_XValue));
  return VK_RValue;
}

/// getValueKind - The value kind that this expression produces.
ExprValueKind getValueKind() const {
  return static_cast<ExprValueKind>(ExprBits.ValueKind);
}

/// getObjectKind - The object kind that this expression produces.
/// Object kinds are meaningful only for expressions that yield an
/// l-value or x-value.
ExprObjectKind getObjectKind() const {
  return static_cast<ExprObjectKind>(ExprBits.ObjectKind);
}

bool isOrdinaryOrBitFieldObject() const {
  ExprObjectKind OK = getObjectKind();
  return (OK == OK_Ordinary || OK == OK_BitField);
}

/// setValueKind - Set the value kind produced by this expression.
void setValueKind(ExprValueKind Cat) { ExprBits.ValueKind = Cat; }

/// setObjectKind - Set the object kind produced by this expression.
void setObjectKind(ExprObjectKind Cat) { ExprBits.ObjectKind = Cat; }

427private:
Classification ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const;

430public:

/// Returns true if this expression is a gl-value that
/// potentially refers to a bit-field.
///
/// In C++, whether a gl-value refers to a bitfield is essentially
/// an aspect of the value-kind type system.
bool refersToBitField() const { return getObjectKind() == OK_BitField; }

/// If this expression refers to a bit-field, retrieve the
/// declaration of that bit-field.
///
/// Note that this returns a non-null pointer in subtly different
/// places than refersToBitField returns true.  In particular, this can
/// return a non-null pointer even for r-values loaded from
/// bit-fields, but it will return null for a conditional bit-field.
FieldDecl *getSourceBitField();

const FieldDecl *getSourceBitField() const {
  return const_cast<Expr*>(this)->getSourceBitField();
}

Decl *getReferencedDeclOfCallee();
const Decl *getReferencedDeclOfCallee() const {
  return const_cast<Expr*>(this)->getReferencedDeclOfCallee();
}

/// If this expression is an l-value for an Objective C
/// property, find the underlying property reference expression.
const ObjCPropertyRefExpr *getObjCProperty() const;

/// Check if this expression is the ObjC 'self' implicit parameter.
bool isObjCSelfExpr() const;

/// Returns whether this expression refers to a vector element.
bool refersToVectorElement() const;

/// Returns whether this expression refers to a global register
/// variable.
bool refersToGlobalRegisterVar() const;

/// Returns whether this expression has a placeholder type.
bool hasPlaceholderType() const {
  return getType()->isPlaceholderType();
}

/// Returns whether this expression has a specific placeholder type.
bool hasPlaceholderType(BuiltinType::Kind K) const {
  assert(BuiltinType::isPlaceholderTypeKind(K))(static_cast <bool> (BuiltinType::isPlaceholderTypeKind
(K)) ? void (0) : __assert_fail ("BuiltinType::isPlaceholderTypeKind(K)"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 478, __extension__ __PRETTY_FUNCTION__));
  if (const BuiltinType *BT = dyn_cast<BuiltinType>(getType()))
    return BT->getKind() == K;
  return false;
}

/// isKnownToHaveBooleanValue - Return true if this is an integer expression
/// that is known to return 0 or 1.  This happens for _Bool/bool expressions
/// but also int expressions which are produced by things like comparisons in
/// C.
bool isKnownToHaveBooleanValue() const;

/// isIntegerConstantExpr - Return true if this expression is a valid integer
/// constant expression, and, if so, return its value in Result.  If not a
/// valid i-c-e, return false and fill in Loc (if specified) with the location
/// of the invalid expression.
///
/// Note: This does not perform the implicit conversions required by C++11
/// [expr.const]p5.
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx,
                           SourceLocation *Loc = nullptr,
                           bool isEvaluated = true) const;
bool isIntegerConstantExpr(const ASTContext &Ctx,
                           SourceLocation *Loc = nullptr) const;

/// isCXX98IntegralConstantExpr - Return true if this expression is an
/// integral constant expression in C++98. Can only be used in C++.
bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const;

/// isCXX11ConstantExpr - Return true if this expression is a constant
/// expression in C++11. Can only be used in C++.
///
/// Note: This does not perform the implicit conversions required by C++11
/// [expr.const]p5.
bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result = nullptr,
                         SourceLocation *Loc = nullptr) const;

/// isPotentialConstantExpr - Return true if this function's definition
/// might be usable in a constant expression in C++11, if it were marked
/// constexpr. Return false if the function can never produce a constant
/// expression, along with diagnostics describing why not.
static bool isPotentialConstantExpr(const FunctionDecl *FD,
                                    SmallVectorImpl<
                                      PartialDiagnosticAt> &Diags);

/// isPotentialConstantExprUnevaluted - Return true if this expression might
/// be usable in a constant expression in C++11 in an unevaluated context, if
/// it were in function FD marked constexpr. Return false if the function can
/// never produce a constant expression, along with diagnostics describing
/// why not.
static bool isPotentialConstantExprUnevaluated(Expr *E,
                                               const FunctionDecl *FD,
                                               SmallVectorImpl<
                                                 PartialDiagnosticAt> &Diags);

/// isConstantInitializer - Returns true if this expression can be emitted to
/// IR as a constant, and thus can be used as a constant initializer in C.
/// If this expression is not constant and Culprit is non-null,
/// it is used to store the address of first non constant expr.
bool isConstantInitializer(ASTContext &Ctx, bool ForRef,
                           const Expr **Culprit = nullptr) const;

/// EvalStatus is a struct with detailed info about an evaluation in progress.
struct EvalStatus {
  /// Whether the evaluated expression has side effects.
  /// For example, (f() && 0) can be folded, but it still has side effects.
  bool HasSideEffects;

  /// Whether the evaluation hit undefined behavior.
  /// For example, 1.0 / 0.0 can be folded to Inf, but has undefined behavior.
  /// Likewise, INT_MAX + 1 can be folded to INT_MIN, but has UB.
  bool HasUndefinedBehavior;

  /// Diag - If this is non-null, it will be filled in with a stack of notes
  /// indicating why evaluation failed (or why it failed to produce a constant
  /// expression).
  /// If the expression is unfoldable, the notes will indicate why it's not
  /// foldable. If the expression is foldable, but not a constant expression,
  /// the notes will describes why it isn't a constant expression. If the
  /// expression *is* a constant expression, no notes will be produced.
  SmallVectorImpl<PartialDiagnosticAt> *Diag;

  EvalStatus()
      : HasSideEffects(false), HasUndefinedBehavior(false), Diag(nullptr) {}

  // hasSideEffects - Return true if the evaluated expression has
  // side effects.
  bool hasSideEffects() const {
    return HasSideEffects;
  }
};

/// EvalResult is a struct with detailed info about an evaluated expression.
struct EvalResult : EvalStatus {
  /// Val - This is the value the expression can be folded to.
  APValue Val;

  // isGlobalLValue - Return true if the evaluated lvalue expression
  // is global.
  bool isGlobalLValue() const;
};

/// EvaluateAsRValue - Return true if this is a constant which we can fold to
/// an rvalue using any crazy technique (that has nothing to do with language
/// standards) that we want to, even if the expression has side-effects. If
/// this function returns true, it returns the folded constant in Result. If
/// the expression is a glvalue, an lvalue-to-rvalue conversion will be
/// applied.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const;

/// EvaluateAsBooleanCondition - Return true if this is a constant
/// which we can fold and convert to a boolean condition using
/// any crazy technique that we want to, even if the expression has
/// side-effects.
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx) const;

enum SideEffectsKind {
  SE_NoSideEffects,          ///< Strictly evaluate the expression.
  SE_AllowUndefinedBehavior, ///< Allow UB that we can give a value, but not
                             ///< arbitrary unmodeled side effects.
  SE_AllowSideEffects        ///< Allow any unmodeled side effect.
};

/// EvaluateAsInt - Return true if this is a constant which we can fold and
/// convert to an integer, using any crazy technique that we want to.
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx,
                   SideEffectsKind AllowSideEffects = SE_NoSideEffects) const;

/// EvaluateAsFloat - Return true if this is a constant which we can fold and
/// convert to a floating point value, using any crazy technique that we
/// want to.
bool
EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx,
                SideEffectsKind AllowSideEffects = SE_NoSideEffects) const;

/// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
/// constant folded without side-effects, but discard the result.
bool isEvaluatable(const ASTContext &Ctx,
                   SideEffectsKind AllowSideEffects = SE_NoSideEffects) const;

/// HasSideEffects - This routine returns true for all those expressions
/// which have any effect other than producing a value. Example is a function
/// call, volatile variable read, or throwing an exception. If
/// IncludePossibleEffects is false, this call treats certain expressions with
/// potential side effects (such as function call-like expressions,
/// instantiation-dependent expressions, or invocations from a macro) as not
/// having side effects.
bool HasSideEffects(const ASTContext &Ctx,
                    bool IncludePossibleEffects = true) const;

/// Determine whether this expression involves a call to any function
/// that is not trivial.
bool hasNonTrivialCall(const ASTContext &Ctx) const;

/// EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded
/// integer. This must be called on an expression that constant folds to an
/// integer.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx,
                  SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;

void EvaluateForOverflow(const ASTContext &Ctx) const;

/// EvaluateAsLValue - Evaluate an expression to see if we can fold it to an
/// lvalue with link time known address, with no side-effects.
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const;

/// EvaluateAsInitializer - Evaluate an expression as if it were the
/// initializer of the given declaration. Returns true if the initializer
/// can be folded to a constant, and produces any relevant notes. In C++11,
/// notes will be produced if the expression is not a constant expression.
bool EvaluateAsInitializer(APValue &Result, const ASTContext &Ctx,
                           const VarDecl *VD,
                           SmallVectorImpl<PartialDiagnosticAt> &Notes) const;

/// EvaluateWithSubstitution - Evaluate an expression as if from the context
/// of a call to the given function with the given arguments, inside an
/// unevaluated context. Returns true if the expression could be folded to a
/// constant.
bool EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx,
                              const FunctionDecl *Callee,
                              ArrayRef<const Expr*> Args,
                              const Expr *This = nullptr) const;

/// Indicates how the constant expression will be used.
enum ConstExprUsage { EvaluateForCodeGen, EvaluateForMangling };

/// Evaluate an expression that is required to be a constant expression.
bool EvaluateAsConstantExpr(EvalResult &Result, ConstExprUsage Usage,
                            const ASTContext &Ctx) const;

/// If the current Expr is a pointer, this will try to statically
/// determine the number of bytes available where the pointer is pointing.
/// Returns true if all of the above holds and we were able to figure out the
/// size, false otherwise.
///
/// \param Type - How to evaluate the size of the Expr, as defined by the
/// "type" parameter of __builtin_object_size
bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
                           unsigned Type) const;

/// Enumeration used to describe the kind of Null pointer constant
/// returned from \c isNullPointerConstant().
enum NullPointerConstantKind {
  /// Expression is not a Null pointer constant.
  NPCK_NotNull = 0,

  /// Expression is a Null pointer constant built from a zero integer
  /// expression that is not a simple, possibly parenthesized, zero literal.
  /// C++ Core Issue 903 will classify these expressions as "not pointers"
  /// once it is adopted.
  /// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
  NPCK_ZeroExpression,

  /// Expression is a Null pointer constant built from a literal zero.
  NPCK_ZeroLiteral,

  /// Expression is a C++11 nullptr.
  NPCK_CXX11_nullptr,

  /// Expression is a GNU-style __null constant.
  NPCK_GNUNull
};

/// Enumeration used to describe how \c isNullPointerConstant()
/// should cope with value-dependent expressions.
enum NullPointerConstantValueDependence {
  /// Specifies that the expression should never be value-dependent.
  NPC_NeverValueDependent = 0,

  /// Specifies that a value-dependent expression of integral or
  /// dependent type should be considered a null pointer constant.
  NPC_ValueDependentIsNull,

  /// Specifies that a value-dependent expression should be considered
  /// to never be a null pointer constant.
  NPC_ValueDependentIsNotNull
};

/// isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to
/// a Null pointer constant. The return value can further distinguish the
/// kind of NULL pointer constant that was detected.
NullPointerConstantKind isNullPointerConstant(
    ASTContext &Ctx,
    NullPointerConstantValueDependence NPC) const;

/// isOBJCGCCandidate - Return true if this expression may be used in a read/
/// write barrier.
bool isOBJCGCCandidate(ASTContext &Ctx) const;

/// Returns true if this expression is a bound member function.
bool isBoundMemberFunction(ASTContext &Ctx) const;

/// Given an expression of bound-member type, find the type
/// of the member.  Returns null if this is an *overloaded* bound
/// member expression.
static QualType findBoundMemberType(const Expr *expr);

/// IgnoreImpCasts - Skip past any implicit casts which might
/// surround this expression.  Only skips ImplicitCastExprs.
Expr *IgnoreImpCasts() LLVM_READONLY__attribute__((__pure__));

/// IgnoreImplicit - Skip past any implicit AST nodes which might
/// surround this expression.
Expr *IgnoreImplicit() LLVM_READONLY__attribute__((__pure__)) {
  return cast<Expr>(Stmt::IgnoreImplicit());
}

const Expr *IgnoreImplicit() const LLVM_READONLY__attribute__((__pure__)) {
  return const_cast<Expr*>(this)->IgnoreImplicit();
}

/// IgnoreParens - Ignore parentheses.  If this Expr is a ParenExpr, return
///  its subexpression.  If that subexpression is also a ParenExpr,
///  then this method recursively returns its subexpression, and so forth.
///  Otherwise, the method returns the current Expr.
Expr *IgnoreParens() LLVM_READONLY__attribute__((__pure__));

/// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
/// or CastExprs, returning their operand.
Expr *IgnoreParenCasts() LLVM_READONLY__attribute__((__pure__));

/// Ignore casts.  Strip off any CastExprs, returning their operand.
Expr *IgnoreCasts() LLVM_READONLY__attribute__((__pure__));

/// IgnoreParenImpCasts - Ignore parentheses and implicit casts.  Strip off
/// any ParenExpr or ImplicitCastExprs, returning their operand.
Expr *IgnoreParenImpCasts() LLVM_READONLY__attribute__((__pure__));

/// IgnoreConversionOperator - Ignore conversion operator. If this Expr is a
/// call to a conversion operator, return the argument.
Expr *IgnoreConversionOperator() LLVM_READONLY__attribute__((__pure__));

const Expr *IgnoreConversionOperator() const LLVM_READONLY__attribute__((__pure__)) {
  return const_cast<Expr*>(this)->IgnoreConversionOperator();
}

const Expr *IgnoreParenImpCasts() const LLVM_READONLY__attribute__((__pure__)) {
  return const_cast<Expr*>(this)->IgnoreParenImpCasts();
}

/// Ignore parentheses and lvalue casts.  Strip off any ParenExpr and
/// CastExprs that represent lvalue casts, returning their operand.
Expr *IgnoreParenLValueCasts() LLVM_READONLY__attribute__((__pure__));

const Expr *IgnoreParenLValueCasts() const LLVM_READONLY__attribute__((__pure__)) {
  return const_cast<Expr*>(this)->IgnoreParenLValueCasts();
}

/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
/// value (including ptr->int casts of the same size).  Strip off any
/// ParenExpr or CastExprs, returning their operand.
Expr *IgnoreParenNoopCasts(ASTContext &Ctx) LLVM_READONLY__attribute__((__pure__));

/// Ignore parentheses and derived-to-base casts.
Expr *ignoreParenBaseCasts() LLVM_READONLY__attribute__((__pure__));

const Expr *ignoreParenBaseCasts() const LLVM_READONLY__attribute__((__pure__)) {
  return const_cast<Expr*>(this)->ignoreParenBaseCasts();
}

/// Determine whether this expression is a default function argument.
///
/// Default arguments are implicitly generated in the abstract syntax tree
/// by semantic analysis for function calls, object constructions, etc. in
/// C++. Default arguments are represented by \c CXXDefaultArgExpr nodes;
/// this routine also looks through any implicit casts to determine whether
/// the expression is a default argument.
bool isDefaultArgument() const;

/// Determine whether the result of this expression is a
/// temporary object of the given class type.
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const;

/// Whether this expression is an implicit reference to 'this' in C++.
bool isImplicitCXXThis() const;

const Expr *IgnoreImpCasts() const LLVM_READONLY__attribute__((__pure__)) {
  return const_cast<Expr*>(this)->IgnoreImpCasts();
}
const Expr *IgnoreParens() const LLVM_READONLY__attribute__((__pure__)) {
  return const_cast<Expr*>(this)->IgnoreParens();
}
const Expr *IgnoreParenCasts() const LLVM_READONLY__attribute__((__pure__)) {
  return const_cast<Expr*>(this)->IgnoreParenCasts();
}
/// Strip off casts, but keep parentheses.
const Expr *IgnoreCasts() const LLVM_READONLY__attribute__((__pure__)) {
  return const_cast<Expr*>(this)->IgnoreCasts();
}

const Expr *IgnoreParenNoopCasts(ASTContext &Ctx) const LLVM_READONLY__attribute__((__pure__)) {
  return const_cast<Expr*>(this)->IgnoreParenNoopCasts(Ctx);
}

static bool hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs);

/// For an expression of class type or pointer to class type,
/// return the most derived class decl the expression is known to refer to.
///
/// If this expression is a cast, this method looks through it to find the
/// most derived decl that can be inferred from the expression.
/// This is valid because derived-to-base conversions have undefined
/// behavior if the object isn't dynamically of the derived type.
const CXXRecordDecl *getBestDynamicClassType() const;

/// Get the inner expression that determines the best dynamic class.
/// If this is a prvalue, we guarantee that it is of the most-derived type
/// for the object itself.
const Expr *getBestDynamicClassTypeExpr() const;

/// Walk outwards from an expression we want to bind a reference to and
/// find the expression whose lifetime needs to be extended. Record
/// the LHSs of comma expressions and adjustments needed along the path.
const Expr *skipRValueSubobjectAdjustments(
    SmallVectorImpl<const Expr *> &CommaLHS,
    SmallVectorImpl<SubobjectAdjustment> &Adjustments) const;
const Expr *skipRValueSubobjectAdjustments() const {
  SmallVector<const Expr *, 8> CommaLHSs;
  SmallVector<SubobjectAdjustment, 8> Adjustments;
  return skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstExprConstant &&
         T->getStmtClass() <= lastExprConstant;
}
864};

866//===----------------------------------------------------------------------===//
867// Primary Expressions.
868//===----------------------------------------------------------------------===//

870/// OpaqueValueExpr - An expression referring to an opaque object of a
871/// fixed type and value class.  These don't correspond to concrete
872/// syntax; instead they're used to express operations (usually copy
873/// operations) on values whose source is generally obvious from
874/// context.
875class OpaqueValueExpr : public Expr {
friend class ASTStmtReader;
Expr *SourceExpr;
SourceLocation Loc;

880public:
OpaqueValueExpr(SourceLocation Loc, QualType T, ExprValueKind VK,
                ExprObjectKind OK = OK_Ordinary,
                Expr *SourceExpr = nullptr)
  : Expr(OpaqueValueExprClass, T, VK, OK,
         T->isDependentType() ||
         (SourceExpr && SourceExpr->isTypeDependent()),
         T->isDependentType() || 
         (SourceExpr && SourceExpr->isValueDependent()),
         T->isInstantiationDependentType() ||
         (SourceExpr && SourceExpr->isInstantiationDependent()),
         false),
    SourceExpr(SourceExpr), Loc(Loc) {
  setIsUnique(false);
}

/// Given an expression which invokes a copy constructor --- i.e.  a
/// CXXConstructExpr, possibly wrapped in an ExprWithCleanups ---
/// find the OpaqueValueExpr that's the source of the construction.
static const OpaqueValueExpr *findInCopyConstruct(const Expr *expr);

explicit OpaqueValueExpr(EmptyShell Empty)
  : Expr(OpaqueValueExprClass, Empty) { }

/// Retrieve the location of this expression.
SourceLocation getLocation() const { return Loc; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceExpr ? SourceExpr->getLocStart() : Loc;
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceExpr ? SourceExpr->getLocEnd() : Loc;
}
SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  if (SourceExpr) return SourceExpr->getExprLoc();
  return Loc;
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

/// The source expression of an opaque value expression is the
/// expression which originally generated the value.  This is
/// provided as a convenience for analyses that don't wish to
/// precisely model the execution behavior of the program.
///
/// The source expression is typically set when building the
/// expression which binds the opaque value expression in the first
/// place.
Expr *getSourceExpr() const { return SourceExpr; }

void setIsUnique(bool V) {
  assert((!V || SourceExpr) &&(static_cast <bool> ((!V || SourceExpr) && "unique OVEs are expected to have source expressions"
) ? void (0) : __assert_fail ("(!V || SourceExpr) && \"unique OVEs are expected to have source expressions\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 938, __extension__ __PRETTY_FUNCTION__))
         "unique OVEs are expected to have source expressions")(static_cast <bool> ((!V || SourceExpr) && "unique OVEs are expected to have source expressions"
) ? void (0) : __assert_fail ("(!V || SourceExpr) && \"unique OVEs are expected to have source expressions\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 938, __extension__ __PRETTY_FUNCTION__));
  OpaqueValueExprBits.IsUnique = V;
}

bool isUnique() const { return OpaqueValueExprBits.IsUnique; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == OpaqueValueExprClass;
}
947};

949/// A reference to a declared variable, function, enum, etc.
950/// [C99 6.5.1p2]
951///
952/// This encodes all the information about how a declaration is referenced
953/// within an expression.
954///
955/// There are several optional constructs attached to DeclRefExprs only when
956/// they apply in order to conserve memory. These are laid out past the end of
957/// the object, and flags in the DeclRefExprBitfield track whether they exist:
958///
959///   DeclRefExprBits.HasQualifier:
960///       Specifies when this declaration reference expression has a C++
961///       nested-name-specifier.
962///   DeclRefExprBits.HasFoundDecl:
963///       Specifies when this declaration reference expression has a record of
964///       a NamedDecl (different from the referenced ValueDecl) which was found
965///       during name lookup and/or overload resolution.
966///   DeclRefExprBits.HasTemplateKWAndArgsInfo:
967///       Specifies when this declaration reference expression has an explicit
968///       C++ template keyword and/or template argument list.
969///   DeclRefExprBits.RefersToEnclosingVariableOrCapture
970///       Specifies when this declaration reference expression (validly)
971///       refers to an enclosed local or a captured variable.
972class DeclRefExpr final
  : public Expr,
    private llvm::TrailingObjects<DeclRefExpr, NestedNameSpecifierLoc,
                                  NamedDecl *, ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc> {
/// The declaration that we are referencing.
ValueDecl *D;

/// The location of the declaration name itself.
SourceLocation Loc;

/// Provides source/type location info for the declaration name
/// embedded in D.
DeclarationNameLoc DNLoc;

size_t numTrailingObjects(OverloadToken<NestedNameSpecifierLoc>) const {
  return hasQualifier() ? 1 : 0;
}

size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
  return hasFoundDecl() ? 1 : 0;
}

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return hasTemplateKWAndArgsInfo() ? 1 : 0;
}

/// Test whether there is a distinct FoundDecl attached to the end of
/// this DRE.
bool hasFoundDecl() const { return DeclRefExprBits.HasFoundDecl; }

DeclRefExpr(const ASTContext &Ctx,
            NestedNameSpecifierLoc QualifierLoc,
            SourceLocation TemplateKWLoc,
            ValueDecl *D, bool RefersToEnlosingVariableOrCapture,
            const DeclarationNameInfo &NameInfo,
            NamedDecl *FoundD,
            const TemplateArgumentListInfo *TemplateArgs,
            QualType T, ExprValueKind VK);

/// Construct an empty declaration reference expression.
explicit DeclRefExpr(EmptyShell Empty)
  : Expr(DeclRefExprClass, Empty) { }

/// Computes the type- and value-dependence flags for this
/// declaration reference expression.
void computeDependence(const ASTContext &C);

1020public:
DeclRefExpr(ValueDecl *D, bool RefersToEnclosingVariableOrCapture, QualType T,
            ExprValueKind VK, SourceLocation L,
            const DeclarationNameLoc &LocInfo = DeclarationNameLoc())
  : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false),
    D(D), Loc(L), DNLoc(LocInfo) {
  DeclRefExprBits.HasQualifier = 0;
  DeclRefExprBits.HasTemplateKWAndArgsInfo = 0;
  DeclRefExprBits.HasFoundDecl = 0;
  DeclRefExprBits.HadMultipleCandidates = 0;
  DeclRefExprBits.RefersToEnclosingVariableOrCapture =
      RefersToEnclosingVariableOrCapture;
  computeDependence(D->getASTContext());
}

static DeclRefExpr *
Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
       SourceLocation TemplateKWLoc, ValueDecl *D,
       bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc,
       QualType T, ExprValueKind VK, NamedDecl *FoundD = nullptr,
       const TemplateArgumentListInfo *TemplateArgs = nullptr);

static DeclRefExpr *
Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
       SourceLocation TemplateKWLoc, ValueDecl *D,
       bool RefersToEnclosingVariableOrCapture,
       const DeclarationNameInfo &NameInfo, QualType T, ExprValueKind VK,
       NamedDecl *FoundD = nullptr,
       const TemplateArgumentListInfo *TemplateArgs = nullptr);

/// Construct an empty declaration reference expression.
static DeclRefExpr *CreateEmpty(const ASTContext &Context,
                                bool HasQualifier,
                                bool HasFoundDecl,
                                bool HasTemplateKWAndArgsInfo,
                                unsigned NumTemplateArgs);

ValueDecl *getDecl() { return D; }
const ValueDecl *getDecl() const { return D; }
void setDecl(ValueDecl *NewD) { D = NewD; }

DeclarationNameInfo getNameInfo() const {
  return DeclarationNameInfo(getDecl()->getDeclName(), Loc, DNLoc);
}

SourceLocation getLocation() const { return Loc; }
void setLocation(SourceLocation L) { Loc = L; }
SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__));

/// Determine whether this declaration reference was preceded by a
/// C++ nested-name-specifier, e.g., \c N::foo.
bool hasQualifier() const { return DeclRefExprBits.HasQualifier; }

/// If the name was qualified, retrieves the nested-name-specifier
/// that precedes the name, with source-location information.
NestedNameSpecifierLoc getQualifierLoc() const {
  if (!hasQualifier())
    return NestedNameSpecifierLoc();
  return *getTrailingObjects<NestedNameSpecifierLoc>();
}

/// If the name was qualified, retrieves the nested-name-specifier
/// that precedes the name. Otherwise, returns NULL.
NestedNameSpecifier *getQualifier() const {
  return getQualifierLoc().getNestedNameSpecifier();
}

/// Get the NamedDecl through which this reference occurred.
///
/// This Decl may be different from the ValueDecl actually referred to in the
/// presence of using declarations, etc. It always returns non-NULL, and may
/// simple return the ValueDecl when appropriate.

NamedDecl *getFoundDecl() {
  return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
}

/// Get the NamedDecl through which this reference occurred.
/// See non-const variant.
const NamedDecl *getFoundDecl() const {
  return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
}

bool hasTemplateKWAndArgsInfo() const {
  return DeclRefExprBits.HasTemplateKWAndArgsInfo;
}

/// Retrieve the location of the template keyword preceding
/// this name, if any.
SourceLocation getTemplateKeywordLoc() const {
  if (!hasTemplateKWAndArgsInfo()) return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
}

/// Retrieve the location of the left angle bracket starting the
/// explicit template argument list following the name, if any.
SourceLocation getLAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo()) return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
}

/// Retrieve the location of the right angle bracket ending the
/// explicit template argument list following the name, if any.
SourceLocation getRAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo()) return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
}

/// Determines whether the name in this declaration reference
/// was preceded by the template keyword.
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }

/// Determines whether this declaration reference was followed by an
/// explicit template argument list.
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }

/// Copies the template arguments (if present) into the given
/// structure.
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
  if (hasExplicitTemplateArgs())
    getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
        getTrailingObjects<TemplateArgumentLoc>(), List);
}

/// Retrieve the template arguments provided as part of this
/// template-id.
const TemplateArgumentLoc *getTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return nullptr;

  return getTrailingObjects<TemplateArgumentLoc>();
}

/// Retrieve the number of template arguments provided as part of this
/// template-id.
unsigned getNumTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return 0;

  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
}

ArrayRef<TemplateArgumentLoc> template_arguments() const {
  return {getTemplateArgs(), getNumTemplateArgs()};
}

/// Returns true if this expression refers to a function that
/// was resolved from an overloaded set having size greater than 1.
bool hadMultipleCandidates() const {
  return DeclRefExprBits.HadMultipleCandidates;
}
/// Sets the flag telling whether this expression refers to
/// a function that was resolved from an overloaded set having size
/// greater than 1.
void setHadMultipleCandidates(bool V = true) {
  DeclRefExprBits.HadMultipleCandidates = V;
}

/// Does this DeclRefExpr refer to an enclosing local or a captured
/// variable?
bool refersToEnclosingVariableOrCapture() const {
  return DeclRefExprBits.RefersToEnclosingVariableOrCapture;
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DeclRefExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

friend TrailingObjects;
friend class ASTStmtReader;
friend class ASTStmtWriter;
1201};

1203/// [C99 6.4.2.2] - A predefined identifier such as __func__.
1204class PredefinedExpr : public Expr {
1205public:
enum IdentType {
  Func,
  Function,
  LFunction, // Same as Function, but as wide string.
  FuncDName,
  FuncSig,
  LFuncSig, // Same as FuncSig, but as as wide string
  PrettyFunction,
  /// The same as PrettyFunction, except that the
  /// 'virtual' keyword is omitted for virtual member functions.
  PrettyFunctionNoVirtual
};

1219private:
SourceLocation Loc;
IdentType Type;
Stmt *FnName;

1224public:
PredefinedExpr(SourceLocation L, QualType FNTy, IdentType IT,
               StringLiteral *SL);

/// Construct an empty predefined expression.
explicit PredefinedExpr(EmptyShell Empty)
    : Expr(PredefinedExprClass, Empty), Loc(), Type(Func), FnName(nullptr) {}

IdentType getIdentType() const { return Type; }

SourceLocation getLocation() const { return Loc; }
void setLocation(SourceLocation L) { Loc = L; }

StringLiteral *getFunctionName();
const StringLiteral *getFunctionName() const {
  return const_cast<PredefinedExpr *>(this)->getFunctionName();
}

static StringRef getIdentTypeName(IdentType IT);
static std::string ComputeName(IdentType IT, const Decl *CurrentDecl);

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == PredefinedExprClass;
}

// Iterators
child_range children() { return child_range(&FnName, &FnName + 1); }
const_child_range children() const {
  return const_child_range(&FnName, &FnName + 1);
}

friend class ASTStmtReader;
1259};

1261/// Used by IntegerLiteral/FloatingLiteral to store the numeric without
1262/// leaking memory.
1263///
1264/// For large floats/integers, APFloat/APInt will allocate memory from the heap
1265/// to represent these numbers.  Unfortunately, when we use a BumpPtrAllocator
1266/// to allocate IntegerLiteral/FloatingLiteral nodes the memory associated with
1267/// the APFloat/APInt values will never get freed. APNumericStorage uses
1268/// ASTContext's allocator for memory allocation.
1269class APNumericStorage {
union {
  uint64_t VAL;    ///< Used to store the <= 64 bits integer value.
  uint64_t *pVal;  ///< Used to store the >64 bits integer value.
};
unsigned BitWidth;

bool hasAllocation() const { return llvm::APInt::getNumWords(BitWidth) > 1; }

APNumericStorage(const APNumericStorage &) = delete;
void operator=(const APNumericStorage &) = delete;

1281protected:
APNumericStorage() : VAL(0), BitWidth(0) { }

llvm::APInt getIntValue() const {
  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
  if (NumWords > 1)
    return llvm::APInt(BitWidth, NumWords, pVal);
  else
    return llvm::APInt(BitWidth, VAL);
}
void setIntValue(const ASTContext &C, const llvm::APInt &Val);
1292};

1294class APIntStorage : private APNumericStorage {
1295public:
llvm::APInt getValue() const { return getIntValue(); }
void setValue(const ASTContext &C, const llvm::APInt &Val) {
  setIntValue(C, Val);
}
1300};

1302class APFloatStorage : private APNumericStorage {
1303public:
llvm::APFloat getValue(const llvm::fltSemantics &Semantics) const {
  return llvm::APFloat(Semantics, getIntValue());
}
void setValue(const ASTContext &C, const llvm::APFloat &Val) {
  setIntValue(C, Val.bitcastToAPInt());
}
1310};

1312class IntegerLiteral : public Expr, public APIntStorage {
SourceLocation Loc;

/// Construct an empty integer literal.
explicit IntegerLiteral(EmptyShell Empty)
  : Expr(IntegerLiteralClass, Empty) { }

1319public:
// type should be IntTy, LongTy, LongLongTy, UnsignedIntTy, UnsignedLongTy,
// or UnsignedLongLongTy
IntegerLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
               SourceLocation l);

/// Returns a new integer literal with value 'V' and type 'type'.
/// \param type - either IntTy, LongTy, LongLongTy, UnsignedIntTy,
/// UnsignedLongTy, or UnsignedLongLongTy which should match the size of V
/// \param V - the value that the returned integer literal contains.
static IntegerLiteral *Create(const ASTContext &C, const llvm::APInt &V,
                              QualType type, SourceLocation l);
/// Returns a new empty integer literal.
static IntegerLiteral *Create(const ASTContext &C, EmptyShell Empty);

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

/// Retrieve the location of the literal.
SourceLocation getLocation() const { return Loc; }

void setLocation(SourceLocation Location) { Loc = Location; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == IntegerLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1353};

1355class FixedPointLiteral : public Expr, public APIntStorage {
SourceLocation Loc;
unsigned Scale;

/// \brief Construct an empty integer literal.
explicit FixedPointLiteral(EmptyShell Empty)
    : Expr(FixedPointLiteralClass, Empty) {}

public:
FixedPointLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
                  SourceLocation l, unsigned Scale);

// Store the int as is without any bit shifting.
static FixedPointLiteral *CreateFromRawInt(const ASTContext &C,
                                           const llvm::APInt &V,
                                           QualType type, SourceLocation l,
                                           unsigned Scale);

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

/// \brief Retrieve the location of the literal.
SourceLocation getLocation() const { return Loc; }

void setLocation(SourceLocation Location) { Loc = Location; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == FixedPointLiteralClass;
}

std::string getValueAsString(unsigned Radix) const;

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1394};

1396class CharacterLiteral : public Expr {
1397public:
enum CharacterKind {
  Ascii,
  Wide,
  UTF8,
  UTF16,
  UTF32
};

1406private:
unsigned Value;
SourceLocation Loc;
1409public:
// type should be IntTy
CharacterLiteral(unsigned value, CharacterKind kind, QualType type,
                 SourceLocation l)
  : Expr(CharacterLiteralClass, type, VK_RValue, OK_Ordinary, false, false,
         false, false),
    Value(value), Loc(l) {
  CharacterLiteralBits.Kind = kind;
}

/// Construct an empty character literal.
CharacterLiteral(EmptyShell Empty) : Expr(CharacterLiteralClass, Empty) { }

SourceLocation getLocation() const { return Loc; }
CharacterKind getKind() const {
  return static_cast<CharacterKind>(CharacterLiteralBits.Kind);
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

unsigned getValue() const { return Value; }

void setLocation(SourceLocation Location) { Loc = Location; }
void setKind(CharacterKind kind) { CharacterLiteralBits.Kind = kind; }
void setValue(unsigned Val) { Value = Val; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CharacterLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1447};

1449class FloatingLiteral : public Expr, private APFloatStorage {
SourceLocation Loc;

FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, bool isexact,
                QualType Type, SourceLocation L);

/// Construct an empty floating-point literal.
explicit FloatingLiteral(const ASTContext &C, EmptyShell Empty);

1458public:
static FloatingLiteral *Create(const ASTContext &C, const llvm::APFloat &V,
                               bool isexact, QualType Type, SourceLocation L);
static FloatingLiteral *Create(const ASTContext &C, EmptyShell Empty);

llvm::APFloat getValue() const {
  return APFloatStorage::getValue(getSemantics());
}
void setValue(const ASTContext &C, const llvm::APFloat &Val) {
  assert(&getSemantics() == &Val.getSemantics() && "Inconsistent semantics")(static_cast <bool> (&getSemantics() == &Val.getSemantics
() && "Inconsistent semantics") ? void (0) : __assert_fail
 ("&getSemantics() == &Val.getSemantics() && \"Inconsistent semantics\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1467, __extension__ __PRETTY_FUNCTION__));
  APFloatStorage::setValue(C, Val);
}

/// Get a raw enumeration value representing the floating-point semantics of
/// this literal (32-bit IEEE, x87, ...), suitable for serialisation.
APFloatSemantics getRawSemantics() const {
  return static_cast<APFloatSemantics>(FloatingLiteralBits.Semantics);
}

/// Set the raw enumeration value representing the floating-point semantics of
/// this literal (32-bit IEEE, x87, ...), suitable for serialisation.
void setRawSemantics(APFloatSemantics Sem) {
  FloatingLiteralBits.Semantics = Sem;
}

/// Return the APFloat semantics this literal uses.
const llvm::fltSemantics &getSemantics() const;

/// Set the APFloat semantics this literal uses.
void setSemantics(const llvm::fltSemantics &Sem);

bool isExact() const { return FloatingLiteralBits.IsExact; }
void setExact(bool E) { FloatingLiteralBits.IsExact = E; }

/// getValueAsApproximateDouble - This returns the value as an inaccurate
/// double.  Note that this may cause loss of precision, but is useful for
/// debugging dumps, etc.
double getValueAsApproximateDouble() const;

SourceLocation getLocation() const { return Loc; }
void setLocation(SourceLocation L) { Loc = L; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == FloatingLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1514};

1516/// ImaginaryLiteral - We support imaginary integer and floating point literals,
1517/// like "1.0i".  We represent these as a wrapper around FloatingLiteral and
1518/// IntegerLiteral classes.  Instances of this class always have a Complex type
1519/// whose element type matches the subexpression.
1520///
1521class ImaginaryLiteral : public Expr {
Stmt *Val;
1523public:
ImaginaryLiteral(Expr *val, QualType Ty)
  : Expr(ImaginaryLiteralClass, Ty, VK_RValue, OK_Ordinary, false, false,
         false, false),
    Val(val) {}

/// Build an empty imaginary literal.
explicit ImaginaryLiteral(EmptyShell Empty)
  : Expr(ImaginaryLiteralClass, Empty) { }

const Expr *getSubExpr() const { return cast<Expr>(Val); }
Expr *getSubExpr() { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Val->getLocStart(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Val->getLocEnd(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ImaginaryLiteralClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
1549};

1551/// StringLiteral - This represents a string literal expression, e.g. "foo"
1552/// or L"bar" (wide strings).  The actual string is returned by getBytes()
1553/// is NOT null-terminated, and the length of the string is determined by
1554/// calling getByteLength().  The C type for a string is always a
1555/// ConstantArrayType.  In C++, the char type is const qualified, in C it is
1556/// not.
1557///
1558/// Note that strings in C can be formed by concatenation of multiple string
1559/// literal pptokens in translation phase #6.  This keeps track of the locations
1560/// of each of these pieces.
1561///
1562/// Strings in C can also be truncated and extended by assigning into arrays,
1563/// e.g. with constructs like:
1564///   char X[2] = "foobar";
1565/// In this case, getByteLength() will return 6, but the string literal will
1566/// have type "char[2]".
1567class StringLiteral : public Expr {
1568public:
enum StringKind {
  Ascii,
  Wide,
  UTF8,
  UTF16,
  UTF32
};

1577private:
friend class ASTStmtReader;

union {
  const char *asChar;
  const uint16_t *asUInt16;
  const uint32_t *asUInt32;
} StrData;
unsigned Length;
unsigned CharByteWidth : 4;
unsigned Kind : 3;
unsigned IsPascal : 1;
unsigned NumConcatenated;
SourceLocation TokLocs[1];

StringLiteral(QualType Ty) :
  Expr(StringLiteralClass, Ty, VK_LValue, OK_Ordinary, false, false, false,
       false) {}

static int mapCharByteWidth(TargetInfo const &target,StringKind k);

1598public:
/// This is the "fully general" constructor that allows representation of
/// strings formed from multiple concatenated tokens.
static StringLiteral *Create(const ASTContext &C, StringRef Str,
                             StringKind Kind, bool Pascal, QualType Ty,
                             const SourceLocation *Loc, unsigned NumStrs);

/// Simple constructor for string literals made from one token.
static StringLiteral *Create(const ASTContext &C, StringRef Str,
                             StringKind Kind, bool Pascal, QualType Ty,
                             SourceLocation Loc) {
  return Create(C, Str, Kind, Pascal, Ty, &Loc, 1);
}

/// Construct an empty string literal.
static StringLiteral *CreateEmpty(const ASTContext &C, unsigned NumStrs);

StringRef getString() const {
  assert(CharByteWidth==1(static_cast <bool> (CharByteWidth==1 && "This function is used in places that assume strings use char"
) ? void (0) : __assert_fail ("CharByteWidth==1 && \"This function is used in places that assume strings use char\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1617, __extension__ __PRETTY_FUNCTION__))
         && "This function is used in places that assume strings use char")(static_cast <bool> (CharByteWidth==1 && "This function is used in places that assume strings use char"
) ? void (0) : __assert_fail ("CharByteWidth==1 && \"This function is used in places that assume strings use char\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1617, __extension__ __PRETTY_FUNCTION__));
  return StringRef(StrData.asChar, getByteLength());
}

/// Allow access to clients that need the byte representation, such as
/// ASTWriterStmt::VisitStringLiteral().
StringRef getBytes() const {
  // FIXME: StringRef may not be the right type to use as a result for this.
  if (CharByteWidth == 1)
    return StringRef(StrData.asChar, getByteLength());
  if (CharByteWidth == 4)
    return StringRef(reinterpret_cast<const char*>(StrData.asUInt32),
                     getByteLength());
  assert(CharByteWidth == 2 && "unsupported CharByteWidth")(static_cast <bool> (CharByteWidth == 2 && "unsupported CharByteWidth"
) ? void (0) : __assert_fail ("CharByteWidth == 2 && \"unsupported CharByteWidth\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1630, __extension__ __PRETTY_FUNCTION__));
  return StringRef(reinterpret_cast<const char*>(StrData.asUInt16),
                   getByteLength());
}

void outputString(raw_ostream &OS) const;

uint32_t getCodeUnit(size_t i) const {
  assert(i < Length && "out of bounds access")(static_cast <bool> (i < Length && "out of bounds access"
) ? void (0) : __assert_fail ("i < Length && \"out of bounds access\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1638, __extension__ __PRETTY_FUNCTION__));
  if (CharByteWidth == 1)
    return static_cast<unsigned char>(StrData.asChar[i]);
  if (CharByteWidth == 4)
    return StrData.asUInt32[i];
  assert(CharByteWidth == 2 && "unsupported CharByteWidth")(static_cast <bool> (CharByteWidth == 2 && "unsupported CharByteWidth"
) ? void (0) : __assert_fail ("CharByteWidth == 2 && \"unsupported CharByteWidth\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1643, __extension__ __PRETTY_FUNCTION__));
  return StrData.asUInt16[i];
}

unsigned getByteLength() const { return CharByteWidth*Length; }
unsigned getLength() const { return Length; }
unsigned getCharByteWidth() const { return CharByteWidth; }

/// Sets the string data to the given string data.
void setString(const ASTContext &C, StringRef Str,
               StringKind Kind, bool IsPascal);

StringKind getKind() const { return static_cast<StringKind>(Kind); }


bool isAscii() const { return Kind == Ascii; }
bool isWide() const { return Kind == Wide; }
bool isUTF8() const { return Kind == UTF8; }
bool isUTF16() const { return Kind == UTF16; }
bool isUTF32() const { return Kind == UTF32; }
bool isPascal() const { return IsPascal; }

bool containsNonAscii() const {
  StringRef Str = getString();
  for (unsigned i = 0, e = Str.size(); i != e; ++i)
    if (!isASCII(Str[i]))
      return true;
  return false;
}

bool containsNonAsciiOrNull() const {
  StringRef Str = getString();
  for (unsigned i = 0, e = Str.size(); i != e; ++i)
    if (!isASCII(Str[i]) || !Str[i])
      return true;
  return false;
}

/// getNumConcatenated - Get the number of string literal tokens that were
/// concatenated in translation phase #6 to form this string literal.
unsigned getNumConcatenated() const { return NumConcatenated; }

SourceLocation getStrTokenLoc(unsigned TokNum) const {
  assert(TokNum < NumConcatenated && "Invalid tok number")(static_cast <bool> (TokNum < NumConcatenated &&
 "Invalid tok number") ? void (0) : __assert_fail ("TokNum < NumConcatenated && \"Invalid tok number\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1686, __extension__ __PRETTY_FUNCTION__));
  return TokLocs[TokNum];
}
void setStrTokenLoc(unsigned TokNum, SourceLocation L) {
  assert(TokNum < NumConcatenated && "Invalid tok number")(static_cast <bool> (TokNum < NumConcatenated &&
 "Invalid tok number") ? void (0) : __assert_fail ("TokNum < NumConcatenated && \"Invalid tok number\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1690, __extension__ __PRETTY_FUNCTION__));
  TokLocs[TokNum] = L;
}

/// getLocationOfByte - Return a source location that points to the specified
/// byte of this string literal.
///
/// Strings are amazingly complex.  They can be formed from multiple tokens
/// and can have escape sequences in them in addition to the usual trigraph
/// and escaped newline business.  This routine handles this complexity.
///
SourceLocation
getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
                  const LangOptions &Features, const TargetInfo &Target,
                  unsigned *StartToken = nullptr,
                  unsigned *StartTokenByteOffset = nullptr) const;

typedef const SourceLocation *tokloc_iterator;
tokloc_iterator tokloc_begin() const { return TokLocs; }
tokloc_iterator tokloc_end() const { return TokLocs + NumConcatenated; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return TokLocs[0]; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return TokLocs[NumConcatenated - 1];
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == StringLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1727};

1729/// ParenExpr - This represents a parethesized expression, e.g. "(1)".  This
1730/// AST node is only formed if full location information is requested.
1731class ParenExpr : public Expr {
SourceLocation L, R;
Stmt *Val;
1734public:
ParenExpr(SourceLocation l, SourceLocation r, Expr *val)
  : Expr(ParenExprClass, val->getType(),
         val->getValueKind(), val->getObjectKind(),
         val->isTypeDependent(), val->isValueDependent(),
         val->isInstantiationDependent(),
         val->containsUnexpandedParameterPack()),
    L(l), R(r), Val(val) {}

/// Construct an empty parenthesized expression.
explicit ParenExpr(EmptyShell Empty)
  : Expr(ParenExprClass, Empty) { }

const Expr *getSubExpr() const { return cast<Expr>(Val); }
Expr *getSubExpr() { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return L; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return R; }

/// Get the location of the left parentheses '('.
SourceLocation getLParen() const { return L; }
void setLParen(SourceLocation Loc) { L = Loc; }

/// Get the location of the right parentheses ')'.
SourceLocation getRParen() const { return R; }
void setRParen(SourceLocation Loc) { R = Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ParenExprClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
1771};

1773/// UnaryOperator - This represents the unary-expression's (except sizeof and
1774/// alignof), the postinc/postdec operators from postfix-expression, and various
1775/// extensions.
1776///
1777/// Notes on various nodes:
1778///
1779/// Real/Imag - These return the real/imag part of a complex operand.  If
1780///   applied to a non-complex value, the former returns its operand and the
1781///   later returns zero in the type of the operand.
1782///
1783class UnaryOperator : public Expr {
1784public:
typedef UnaryOperatorKind Opcode;

1787private:
unsigned Opc : 5;
unsigned CanOverflow : 1;
SourceLocation Loc;
Stmt *Val;
1792public:
UnaryOperator(Expr *input, Opcode opc, QualType type, ExprValueKind VK,
              ExprObjectKind OK, SourceLocation l, bool CanOverflow)
    : Expr(UnaryOperatorClass, type, VK, OK,
           input->isTypeDependent() || type->isDependentType(),
           input->isValueDependent(),
           (input->isInstantiationDependent() ||
            type->isInstantiationDependentType()),
           input->containsUnexpandedParameterPack()),
      Opc(opc), CanOverflow(CanOverflow), Loc(l), Val(input) {}

/// Build an empty unary operator.
explicit UnaryOperator(EmptyShell Empty)
  : Expr(UnaryOperatorClass, Empty), Opc(UO_AddrOf) { }

Opcode getOpcode() const { return static_cast<Opcode>(Opc); }
void setOpcode(Opcode O) { Opc = O; }

Expr *getSubExpr() const { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

/// getOperatorLoc - Return the location of the operator.
SourceLocation getOperatorLoc() const { return Loc; }
void setOperatorLoc(SourceLocation L) { Loc = L; }

/// Returns true if the unary operator can cause an overflow. For instance,
///   signed int i = INT_MAX; i++;
///   signed char c = CHAR_MAX; c++;
/// Due to integer promotions, c++ is promoted to an int before the postfix
/// increment, and the result is an int that cannot overflow. However, i++
/// can overflow.
bool canOverflow() const { return CanOverflow; }
void setCanOverflow(bool C) { CanOverflow = C; }

/// isPostfix - Return true if this is a postfix operation, like x++.
static bool isPostfix(Opcode Op) {
  return Op == UO_PostInc || Op == UO_PostDec;
}

/// isPrefix - Return true if this is a prefix operation, like --x.
static bool isPrefix(Opcode Op) {
  return Op == UO_PreInc || Op == UO_PreDec;
}

bool isPrefix() const { return isPrefix(getOpcode()); }
bool isPostfix() const { return isPostfix(getOpcode()); }

static bool isIncrementOp(Opcode Op) {
  return Op == UO_PreInc || Op == UO_PostInc;
}
bool isIncrementOp() const {
  return isIncrementOp(getOpcode());
}

static bool isDecrementOp(Opcode Op) {
  return Op == UO_PreDec || Op == UO_PostDec;
}
bool isDecrementOp() const {
  return isDecrementOp(getOpcode());
}

static bool isIncrementDecrementOp(Opcode Op) { return Op <= UO_PreDec; }
bool isIncrementDecrementOp() const {
  return isIncrementDecrementOp(getOpcode());
}

static bool isArithmeticOp(Opcode Op) {
  return Op >= UO_Plus && Op <= UO_LNot;
}
bool isArithmeticOp() const { return isArithmeticOp(getOpcode()); }

/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
/// corresponds to, e.g. "sizeof" or "[pre]++"
static StringRef getOpcodeStr(Opcode Op);

/// Retrieve the unary opcode that corresponds to the given
/// overloaded operator.
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix);

/// Retrieve the overloaded operator kind that corresponds to
/// the given unary opcode.
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc);

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return isPostfix() ? Val->getLocStart() : Loc;
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return isPostfix() ? Loc : Val->getLocEnd();
}
SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnaryOperatorClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
1892};

1894/// Helper class for OffsetOfExpr.

1896// __builtin_offsetof(type, identifier(.identifier|[expr])*)
1897class OffsetOfNode {
1898public:
/// The kind of offsetof node we have.
enum Kind {
  /// An index into an array.
  Array = 0x00,
  /// A field.
  Field = 0x01,
  /// A field in a dependent type, known only by its name.
  Identifier = 0x02,
  /// An implicit indirection through a C++ base class, when the
  /// field found is in a base class.
  Base = 0x03
};

1912private:
enum { MaskBits = 2, Mask = 0x03 };

/// The source range that covers this part of the designator.
SourceRange Range;

/// The data describing the designator, which comes in three
/// different forms, depending on the lower two bits.
///   - An unsigned index into the array of Expr*'s stored after this node
///     in memory, for [constant-expression] designators.
///   - A FieldDecl*, for references to a known field.
///   - An IdentifierInfo*, for references to a field with a given name
///     when the class type is dependent.
///   - A CXXBaseSpecifier*, for references that look at a field in a
///     base class.
uintptr_t Data;

1929public:
/// Create an offsetof node that refers to an array element.
OffsetOfNode(SourceLocation LBracketLoc, unsigned Index,
             SourceLocation RBracketLoc)
    : Range(LBracketLoc, RBracketLoc), Data((Index << 2) | Array) {}

/// Create an offsetof node that refers to a field.
OffsetOfNode(SourceLocation DotLoc, FieldDecl *Field, SourceLocation NameLoc)
    : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
      Data(reinterpret_cast<uintptr_t>(Field) | OffsetOfNode::Field) {}

/// Create an offsetof node that refers to an identifier.
OffsetOfNode(SourceLocation DotLoc, IdentifierInfo *Name,
             SourceLocation NameLoc)
    : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
      Data(reinterpret_cast<uintptr_t>(Name) | Identifier) {}

/// Create an offsetof node that refers into a C++ base class.
explicit OffsetOfNode(const CXXBaseSpecifier *Base)
    : Range(), Data(reinterpret_cast<uintptr_t>(Base) | OffsetOfNode::Base) {}

/// Determine what kind of offsetof node this is.
Kind getKind() const { return static_cast<Kind>(Data & Mask); }

/// For an array element node, returns the index into the array
/// of expressions.
unsigned getArrayExprIndex() const {
  assert(getKind() == Array)(static_cast <bool> (getKind() == Array) ? void (0) : __assert_fail
 ("getKind() == Array", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1956, __extension__ __PRETTY_FUNCTION__));
  return Data >> 2;
}

/// For a field offsetof node, returns the field.
FieldDecl *getField() const {
  assert(getKind() == Field)(static_cast <bool> (getKind() == Field) ? void (0) : __assert_fail
 ("getKind() == Field", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1962, __extension__ __PRETTY_FUNCTION__));
  return reinterpret_cast<FieldDecl *>(Data & ~(uintptr_t)Mask);
}

/// For a field or identifier offsetof node, returns the name of
/// the field.
IdentifierInfo *getFieldName() const;

/// For a base class node, returns the base specifier.
CXXBaseSpecifier *getBase() const {
  assert(getKind() == Base)(static_cast <bool> (getKind() == Base) ? void (0) : __assert_fail
 ("getKind() == Base", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 1972, __extension__ __PRETTY_FUNCTION__));
  return reinterpret_cast<CXXBaseSpecifier *>(Data & ~(uintptr_t)Mask);
}

/// Retrieve the source range that covers this offsetof node.
///
/// For an array element node, the source range contains the locations of
/// the square brackets. For a field or identifier node, the source range
/// contains the location of the period (if there is one) and the
/// identifier.
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
1985};

1987/// OffsetOfExpr - [C99 7.17] - This represents an expression of the form
1988/// offsetof(record-type, member-designator). For example, given:
1989/// @code
1990/// struct S {
1991///   float f;
1992///   double d;
1993/// };
1994/// struct T {
1995///   int i;
1996///   struct S s[10];
1997/// };
1998/// @endcode
1999/// we can represent and evaluate the expression @c offsetof(struct T, s[2].d).

2001class OffsetOfExpr final
  : public Expr,
    private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> {
SourceLocation OperatorLoc, RParenLoc;
// Base type;
TypeSourceInfo *TSInfo;
// Number of sub-components (i.e. instances of OffsetOfNode).
unsigned NumComps;
// Number of sub-expressions (i.e. array subscript expressions).
unsigned NumExprs;

size_t numTrailingObjects(OverloadToken<OffsetOfNode>) const {
  return NumComps;
}

OffsetOfExpr(const ASTContext &C, QualType type,
             SourceLocation OperatorLoc, TypeSourceInfo *tsi,
             ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs,
             SourceLocation RParenLoc);

explicit OffsetOfExpr(unsigned numComps, unsigned numExprs)
  : Expr(OffsetOfExprClass, EmptyShell()),
    TSInfo(nullptr), NumComps(numComps), NumExprs(numExprs) {}

2025public:

static OffsetOfExpr *Create(const ASTContext &C, QualType type,
                            SourceLocation OperatorLoc, TypeSourceInfo *tsi,
                            ArrayRef<OffsetOfNode> comps,
                            ArrayRef<Expr*> exprs, SourceLocation RParenLoc);

static OffsetOfExpr *CreateEmpty(const ASTContext &C,
                                 unsigned NumComps, unsigned NumExprs);

/// getOperatorLoc - Return the location of the operator.
SourceLocation getOperatorLoc() const { return OperatorLoc; }
void setOperatorLoc(SourceLocation L) { OperatorLoc = L; }

/// Return the location of the right parentheses.
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation R) { RParenLoc = R; }

TypeSourceInfo *getTypeSourceInfo() const {
  return TSInfo;
}
void setTypeSourceInfo(TypeSourceInfo *tsi) {
  TSInfo = tsi;
}

const OffsetOfNode &getComponent(unsigned Idx) const {
  assert(Idx < NumComps && "Subscript out of range")(static_cast <bool> (Idx < NumComps && "Subscript out of range"
) ? void (0) : __assert_fail ("Idx < NumComps && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2051, __extension__ __PRETTY_FUNCTION__));
  return getTrailingObjects<OffsetOfNode>()[Idx];
}

void setComponent(unsigned Idx, OffsetOfNode ON) {
  assert(Idx < NumComps && "Subscript out of range")(static_cast <bool> (Idx < NumComps && "Subscript out of range"
) ? void (0) : __assert_fail ("Idx < NumComps && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2056, __extension__ __PRETTY_FUNCTION__));
  getTrailingObjects<OffsetOfNode>()[Idx] = ON;
}

unsigned getNumComponents() const {
  return NumComps;
}

Expr* getIndexExpr(unsigned Idx) {
  assert(Idx < NumExprs && "Subscript out of range")(static_cast <bool> (Idx < NumExprs && "Subscript out of range"
) ? void (0) : __assert_fail ("Idx < NumExprs && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2065, __extension__ __PRETTY_FUNCTION__));
  return getTrailingObjects<Expr *>()[Idx];
}

const Expr *getIndexExpr(unsigned Idx) const {
  assert(Idx < NumExprs && "Subscript out of range")(static_cast <bool> (Idx < NumExprs && "Subscript out of range"
) ? void (0) : __assert_fail ("Idx < NumExprs && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2070, __extension__ __PRETTY_FUNCTION__));
  return getTrailingObjects<Expr *>()[Idx];
}

void setIndexExpr(unsigned Idx, Expr* E) {
  assert(Idx < NumComps && "Subscript out of range")(static_cast <bool> (Idx < NumComps && "Subscript out of range"
) ? void (0) : __assert_fail ("Idx < NumComps && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2075, __extension__ __PRETTY_FUNCTION__));
  getTrailingObjects<Expr *>()[Idx] = E;
}

unsigned getNumExpressions() const {
  return NumExprs;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return OperatorLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == OffsetOfExprClass;
}

// Iterators
child_range children() {
  Stmt **begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
  return child_range(begin, begin + NumExprs);
}
const_child_range children() const {
  Stmt *const *begin =
      reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
  return const_child_range(begin, begin + NumExprs);
}
friend TrailingObjects;
2101};

2103/// UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated)
2104/// expression operand.  Used for sizeof/alignof (C99 6.5.3.4) and
2105/// vec_step (OpenCL 1.1 6.11.12).
2106class UnaryExprOrTypeTraitExpr : public Expr {
union {
  TypeSourceInfo *Ty;
  Stmt *Ex;
} Argument;
SourceLocation OpLoc, RParenLoc;

2113public:
UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo,
                         QualType resultType, SourceLocation op,
                         SourceLocation rp) :
    Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary,
         false, // Never type-dependent (C++ [temp.dep.expr]p3).
         // Value-dependent if the argument is type-dependent.
         TInfo->getType()->isDependentType(),
         TInfo->getType()->isInstantiationDependentType(),
         TInfo->getType()->containsUnexpandedParameterPack()),
    OpLoc(op), RParenLoc(rp) {
  UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
  UnaryExprOrTypeTraitExprBits.IsType = true;
  Argument.Ty = TInfo;
}

UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, Expr *E,
                         QualType resultType, SourceLocation op,
                         SourceLocation rp);

/// Construct an empty sizeof/alignof expression.
explicit UnaryExprOrTypeTraitExpr(EmptyShell Empty)
  : Expr(UnaryExprOrTypeTraitExprClass, Empty) { }

UnaryExprOrTypeTrait getKind() const {
  return static_cast<UnaryExprOrTypeTrait>(UnaryExprOrTypeTraitExprBits.Kind);
}
void setKind(UnaryExprOrTypeTrait K) { UnaryExprOrTypeTraitExprBits.Kind = K;}

bool isArgumentType() const { return UnaryExprOrTypeTraitExprBits.IsType; }
QualType getArgumentType() const {
  return getArgumentTypeInfo()->getType();
}
TypeSourceInfo *getArgumentTypeInfo() const {
  assert(isArgumentType() && "calling getArgumentType() when arg is expr")(static_cast <bool> (isArgumentType() && "calling getArgumentType() when arg is expr"
) ? void (0) : __assert_fail ("isArgumentType() && \"calling getArgumentType() when arg is expr\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2147, __extension__ __PRETTY_FUNCTION__));
  return Argument.Ty;
}
Expr *getArgumentExpr() {
  assert(!isArgumentType() && "calling getArgumentExpr() when arg is type")(static_cast <bool> (!isArgumentType() && "calling getArgumentExpr() when arg is type"
) ? void (0) : __assert_fail ("!isArgumentType() && \"calling getArgumentExpr() when arg is type\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2151, __extension__ __PRETTY_FUNCTION__));
  return static_cast<Expr*>(Argument.Ex);
}
const Expr *getArgumentExpr() const {
  return const_cast<UnaryExprOrTypeTraitExpr*>(this)->getArgumentExpr();
}

void setArgument(Expr *E) {
  Argument.Ex = E;
  UnaryExprOrTypeTraitExprBits.IsType = false;
}
void setArgument(TypeSourceInfo *TInfo) {
  Argument.Ty = TInfo;
  UnaryExprOrTypeTraitExprBits.IsType = true;
}

/// Gets the argument type, or the type of the argument expression, whichever
/// is appropriate.
QualType getTypeOfArgument() const {
  return isArgumentType() ? getArgumentType() : getArgumentExpr()->getType();
}

SourceLocation getOperatorLoc() const { return OpLoc; }
void setOperatorLoc(SourceLocation L) { OpLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return OpLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnaryExprOrTypeTraitExprClass;
}

// Iterators
child_range children();
const_child_range children() const;
2189};

2191//===----------------------------------------------------------------------===//
2192// Postfix Operators.
2193//===----------------------------------------------------------------------===//

2195/// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
2196class ArraySubscriptExpr : public Expr {
enum { LHS, RHS, END_EXPR=2 };
Stmt* SubExprs[END_EXPR];
SourceLocation RBracketLoc;
2200public:
ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t,
                   ExprValueKind VK, ExprObjectKind OK,
                   SourceLocation rbracketloc)
: Expr(ArraySubscriptExprClass, t, VK, OK,
       lhs->isTypeDependent() || rhs->isTypeDependent(),
       lhs->isValueDependent() || rhs->isValueDependent(),
       (lhs->isInstantiationDependent() ||
        rhs->isInstantiationDependent()),
       (lhs->containsUnexpandedParameterPack() ||
        rhs->containsUnexpandedParameterPack())),
  RBracketLoc(rbracketloc) {
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
}

/// Create an empty array subscript expression.
explicit ArraySubscriptExpr(EmptyShell Shell)
  : Expr(ArraySubscriptExprClass, Shell) { }

/// An array access can be written A[4] or 4[A] (both are equivalent).
/// - getBase() and getIdx() always present the normalized view: A[4].
///    In this case getBase() returns "A" and getIdx() returns "4".
/// - getLHS() and getRHS() present the syntactic view. e.g. for
///    4[A] getLHS() returns "4".
/// Note: Because vector element access is also written A[4] we must
/// predicate the format conversion in getBase and getIdx only on the
/// the type of the RHS, as it is possible for the LHS to be a vector of
/// integer type
Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); }
const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
void setLHS(Expr *E) { SubExprs[LHS] = E; }

Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); }
const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
void setRHS(Expr *E) { SubExprs[RHS] = E; }

Expr *getBase() {
  return getRHS()->getType()->isIntegerType() ? getLHS() : getRHS();
}

const Expr *getBase() const {
  return getRHS()->getType()->isIntegerType() ? getLHS() : getRHS();
}

Expr *getIdx() {
  return getRHS()->getType()->isIntegerType() ? getRHS() : getLHS();
}

const Expr *getIdx() const {
  return getRHS()->getType()->isIntegerType() ? getRHS() : getLHS();
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getLHS()->getLocStart();
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RBracketLoc; }

SourceLocation getRBracketLoc() const { return RBracketLoc; }
void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->getExprLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ArraySubscriptExprClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
2276};

2278/// CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
2279/// CallExpr itself represents a normal function call, e.g., "f(x, 2)",
2280/// while its subclasses may represent alternative syntax that (semantically)
2281/// results in a function call. For example, CXXOperatorCallExpr is
2282/// a subclass for overloaded operator calls that use operator syntax, e.g.,
2283/// "str1 + str2" to resolve to a function call.
2284class CallExpr : public Expr {
enum { FN=0, PREARGS_START=1 };
Stmt **SubExprs;
unsigned NumArgs;
SourceLocation RParenLoc;

void updateDependenciesFromArg(Expr *Arg);

2292protected:
// These versions of the constructor are for derived classes.
CallExpr(const ASTContext &C, StmtClass SC, Expr *fn,
         ArrayRef<Expr *> preargs, ArrayRef<Expr *> args, QualType t,
         ExprValueKind VK, SourceLocation rparenloc);
CallExpr(const ASTContext &C, StmtClass SC, Expr *fn, ArrayRef<Expr *> args,
         QualType t, ExprValueKind VK, SourceLocation rparenloc);
CallExpr(const ASTContext &C, StmtClass SC, unsigned NumPreArgs,
         EmptyShell Empty);

Stmt *getPreArg(unsigned i) {
  assert(i < getNumPreArgs() && "Prearg access out of range!")(static_cast <bool> (i < getNumPreArgs() && "Prearg access out of range!"
) ? void (0) : __assert_fail ("i < getNumPreArgs() && \"Prearg access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2303, __extension__ __PRETTY_FUNCTION__));
  return SubExprs[PREARGS_START+i];
}
const Stmt *getPreArg(unsigned i) const {
  assert(i < getNumPreArgs() && "Prearg access out of range!")(static_cast <bool> (i < getNumPreArgs() && "Prearg access out of range!"
) ? void (0) : __assert_fail ("i < getNumPreArgs() && \"Prearg access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2307, __extension__ __PRETTY_FUNCTION__));
  return SubExprs[PREARGS_START+i];
}
void setPreArg(unsigned i, Stmt *PreArg) {
  assert(i < getNumPreArgs() && "Prearg access out of range!")(static_cast <bool> (i < getNumPreArgs() && "Prearg access out of range!"
) ? void (0) : __assert_fail ("i < getNumPreArgs() && \"Prearg access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2311, __extension__ __PRETTY_FUNCTION__));
  SubExprs[PREARGS_START+i] = PreArg;
}

unsigned getNumPreArgs() const { return CallExprBits.NumPreArgs; }

2317public:
CallExpr(const ASTContext& C, Expr *fn, ArrayRef<Expr*> args, QualType t,
         ExprValueKind VK, SourceLocation rparenloc);

/// Build an empty call expression.
CallExpr(const ASTContext &C, StmtClass SC, EmptyShell Empty);

const Expr *getCallee() const { return cast<Expr>(SubExprs[FN]); }
Expr *getCallee() { return cast<Expr>(SubExprs[FN]); }
void setCallee(Expr *F) { SubExprs[FN] = F; }

Decl *getCalleeDecl();
const Decl *getCalleeDecl() const {
  return const_cast<CallExpr*>(this)->getCalleeDecl();
}

/// If the callee is a FunctionDecl, return it. Otherwise return 0.
FunctionDecl *getDirectCallee();
const FunctionDecl *getDirectCallee() const {
  return const_cast<CallExpr*>(this)->getDirectCallee();
}

/// getNumArgs - Return the number of actual arguments to this call.
///
unsigned getNumArgs() const { return NumArgs; }

/// Retrieve the call arguments.
Expr **getArgs() {
  return reinterpret_cast<Expr **>(SubExprs+getNumPreArgs()+PREARGS_START);
}
const Expr *const *getArgs() const {
  return reinterpret_cast<Expr **>(SubExprs + getNumPreArgs() +
                                   PREARGS_START);
}

/// getArg - Return the specified argument.
Expr *getArg(unsigned Arg) {
  assert(Arg < NumArgs && "Arg access out of range!")(static_cast <bool> (Arg < NumArgs && "Arg access out of range!"
) ? void (0) : __assert_fail ("Arg < NumArgs && \"Arg access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2354, __extension__ __PRETTY_FUNCTION__));
  return cast_or_null<Expr>(SubExprs[Arg + getNumPreArgs() + PREARGS_START]);
}
const Expr *getArg(unsigned Arg) const {
  assert(Arg < NumArgs && "Arg access out of range!")(static_cast <bool> (Arg < NumArgs && "Arg access out of range!"
) ? void (0) : __assert_fail ("Arg < NumArgs && \"Arg access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2358, __extension__ __PRETTY_FUNCTION__));
  return cast_or_null<Expr>(SubExprs[Arg + getNumPreArgs() + PREARGS_START]);
}

/// setArg - Set the specified argument.
void setArg(unsigned Arg, Expr *ArgExpr) {
  assert(Arg < NumArgs && "Arg access out of range!")(static_cast <bool> (Arg < NumArgs && "Arg access out of range!"
) ? void (0) : __assert_fail ("Arg < NumArgs && \"Arg access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2364, __extension__ __PRETTY_FUNCTION__));
  SubExprs[Arg+getNumPreArgs()+PREARGS_START] = ArgExpr;
}

/// setNumArgs - This changes the number of arguments present in this call.
/// Any orphaned expressions are deleted by this, and any new operands are set
/// to null.
void setNumArgs(const ASTContext& C, unsigned NumArgs);

typedef ExprIterator arg_iterator;
typedef ConstExprIterator const_arg_iterator;
typedef llvm::iterator_range<arg_iterator> arg_range;
typedef llvm::iterator_range<const_arg_iterator> arg_const_range;

arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
arg_const_range arguments() const {
  return arg_const_range(arg_begin(), arg_end());
}

arg_iterator arg_begin() { return SubExprs+PREARGS_START+getNumPreArgs(); }
arg_iterator arg_end() {
  return SubExprs+PREARGS_START+getNumPreArgs()+getNumArgs();
}
const_arg_iterator arg_begin() const {
  return SubExprs+PREARGS_START+getNumPreArgs();
}
const_arg_iterator arg_end() const {
  return SubExprs+PREARGS_START+getNumPreArgs()+getNumArgs();
}

/// This method provides fast access to all the subexpressions of
/// a CallExpr without going through the slower virtual child_iterator
/// interface.  This provides efficient reverse iteration of the
/// subexpressions.  This is currently used for CFG construction.
ArrayRef<Stmt*> getRawSubExprs() {
  return llvm::makeArrayRef(SubExprs,
                            getNumPreArgs() + PREARGS_START + getNumArgs());
}

/// getNumCommas - Return the number of commas that must have been present in
/// this function call.
unsigned getNumCommas() const { return NumArgs ? NumArgs - 1 : 0; }

/// getBuiltinCallee - If this is a call to a builtin, return the builtin ID
/// of the callee. If not, return 0.
unsigned getBuiltinCallee() const;

/// Returns \c true if this is a call to a builtin which does not
/// evaluate side-effects within its arguments.
bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const;

/// getCallReturnType - Get the return type of the call expr. This is not
/// always the type of the expr itself, if the return type is a reference
/// type.
QualType getCallReturnType(const ASTContext &Ctx) const;

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__));

/// Return true if this is a call to __assume() or __builtin_assume() with
/// a non-value-dependent constant parameter evaluating as false.
bool isBuiltinAssumeFalse(const ASTContext &Ctx) const;

bool isCallToStdMove() const {
  const FunctionDecl* FD = getDirectCallee();
  return getNumArgs() == 1 && FD && FD->isInStdNamespace() &&
         FD->getIdentifier() && FD->getIdentifier()->isStr("move");
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstCallExprConstant &&
         T->getStmtClass() <= lastCallExprConstant;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0],
                     &SubExprs[0]+NumArgs+getNumPreArgs()+PREARGS_START);
}

const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + NumArgs +
                                             getNumPreArgs() + PREARGS_START);
}
2451};

2453/// Extra data stored in some MemberExpr objects.
2454struct MemberExprNameQualifier {
/// The nested-name-specifier that qualifies the name, including
/// source-location information.
NestedNameSpecifierLoc QualifierLoc;

/// The DeclAccessPair through which the MemberDecl was found due to
/// name qualifiers.
DeclAccessPair FoundDecl;
2462};

2464/// MemberExpr - [C99 6.5.2.3] Structure and Union Members.  X->F and X.F.
2465///
2466class MemberExpr final
  : public Expr,
    private llvm::TrailingObjects<MemberExpr, MemberExprNameQualifier,
                                  ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc> {
/// Base - the expression for the base pointer or structure references.  In
/// X.F, this is "X".
Stmt *Base;

/// MemberDecl - This is the decl being referenced by the field/member name.
/// In X.F, this is the decl referenced by F.
ValueDecl *MemberDecl;

/// MemberDNLoc - Provides source/type location info for the
/// declaration name embedded in MemberDecl.
DeclarationNameLoc MemberDNLoc;

/// MemberLoc - This is the location of the member name.
SourceLocation MemberLoc;

/// This is the location of the -> or . in the expression.
SourceLocation OperatorLoc;

/// IsArrow - True if this is "X->F", false if this is "X.F".
bool IsArrow : 1;

/// True if this member expression used a nested-name-specifier to
/// refer to the member, e.g., "x->Base::f", or found its member via a using
/// declaration.  When true, a MemberExprNameQualifier
/// structure is allocated immediately after the MemberExpr.
bool HasQualifierOrFoundDecl : 1;

/// True if this member expression specified a template keyword
/// and/or a template argument list explicitly, e.g., x->f<int>,
/// x->template f, x->template f<int>.
/// When true, an ASTTemplateKWAndArgsInfo structure and its
/// TemplateArguments (if any) are present.
bool HasTemplateKWAndArgsInfo : 1;

/// True if this member expression refers to a method that
/// was resolved from an overloaded set having size greater than 1.
bool HadMultipleCandidates : 1;

size_t numTrailingObjects(OverloadToken<MemberExprNameQualifier>) const {
  return HasQualifierOrFoundDecl ? 1 : 0;
}

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return HasTemplateKWAndArgsInfo ? 1 : 0;
}

2517public:
MemberExpr(Expr *base, bool isarrow, SourceLocation operatorloc,
           ValueDecl *memberdecl, const DeclarationNameInfo &NameInfo,
           QualType ty, ExprValueKind VK, ExprObjectKind OK)
    : Expr(MemberExprClass, ty, VK, OK, base->isTypeDependent(),
           base->isValueDependent(), base->isInstantiationDependent(),
           base->containsUnexpandedParameterPack()),
      Base(base), MemberDecl(memberdecl), MemberDNLoc(NameInfo.getInfo()),
      MemberLoc(NameInfo.getLoc()), OperatorLoc(operatorloc),
      IsArrow(isarrow), HasQualifierOrFoundDecl(false),
      HasTemplateKWAndArgsInfo(false), HadMultipleCandidates(false) {
  assert(memberdecl->getDeclName() == NameInfo.getName())(static_cast <bool> (memberdecl->getDeclName() == NameInfo
.getName()) ? void (0) : __assert_fail ("memberdecl->getDeclName() == NameInfo.getName()"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2528, __extension__ __PRETTY_FUNCTION__));
}

// NOTE: this constructor should be used only when it is known that
// the member name can not provide additional syntactic info
// (i.e., source locations for C++ operator names or type source info
// for constructors, destructors and conversion operators).
MemberExpr(Expr *base, bool isarrow, SourceLocation operatorloc,
           ValueDecl *memberdecl, SourceLocation l, QualType ty,
           ExprValueKind VK, ExprObjectKind OK)
    : Expr(MemberExprClass, ty, VK, OK, base->isTypeDependent(),
           base->isValueDependent(), base->isInstantiationDependent(),
           base->containsUnexpandedParameterPack()),
      Base(base), MemberDecl(memberdecl), MemberDNLoc(), MemberLoc(l),
      OperatorLoc(operatorloc), IsArrow(isarrow),
      HasQualifierOrFoundDecl(false), HasTemplateKWAndArgsInfo(false),
      HadMultipleCandidates(false) {}

static MemberExpr *Create(const ASTContext &C, Expr *base, bool isarrow,
                          SourceLocation OperatorLoc,
                          NestedNameSpecifierLoc QualifierLoc,
                          SourceLocation TemplateKWLoc, ValueDecl *memberdecl,
                          DeclAccessPair founddecl,
                          DeclarationNameInfo MemberNameInfo,
                          const TemplateArgumentListInfo *targs, QualType ty,
                          ExprValueKind VK, ExprObjectKind OK);

void setBase(Expr *E) { Base = E; }
Expr *getBase() const { return cast<Expr>(Base); }

/// Retrieve the member declaration to which this expression refers.
///
/// The returned declaration will be a FieldDecl or (in C++) a VarDecl (for
/// static data members), a CXXMethodDecl, or an EnumConstantDecl.
ValueDecl *getMemberDecl() const { return MemberDecl; }
void setMemberDecl(ValueDecl *D) { MemberDecl = D; }

/// Retrieves the declaration found by lookup.
DeclAccessPair getFoundDecl() const {
  if (!HasQualifierOrFoundDecl)
    return DeclAccessPair::make(getMemberDecl(),
                                getMemberDecl()->getAccess());
  return getTrailingObjects<MemberExprNameQualifier>()->FoundDecl;
}

/// Determines whether this member expression actually had
/// a C++ nested-name-specifier prior to the name of the member, e.g.,
/// x->Base::foo.
bool hasQualifier() const { return getQualifier() != nullptr; }

/// If the member name was qualified, retrieves the
/// nested-name-specifier that precedes the member name, with source-location
/// information.
NestedNameSpecifierLoc getQualifierLoc() const {
  if (!HasQualifierOrFoundDecl)
    return NestedNameSpecifierLoc();

  return getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc;
}

/// If the member name was qualified, retrieves the
/// nested-name-specifier that precedes the member name. Otherwise, returns
/// NULL.
NestedNameSpecifier *getQualifier() const {
  return getQualifierLoc().getNestedNameSpecifier();
}

/// Retrieve the location of the template keyword preceding
/// the member name, if any.
SourceLocation getTemplateKeywordLoc() const {
  if (!HasTemplateKWAndArgsInfo) return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
}

/// Retrieve the location of the left angle bracket starting the
/// explicit template argument list following the member name, if any.
SourceLocation getLAngleLoc() const {
  if (!HasTemplateKWAndArgsInfo) return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
}

/// Retrieve the location of the right angle bracket ending the
/// explicit template argument list following the member name, if any.
SourceLocation getRAngleLoc() const {
  if (!HasTemplateKWAndArgsInfo) return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
}

/// Determines whether the member name was preceded by the template keyword.
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }

/// Determines whether the member name was followed by an
/// explicit template argument list.
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }

/// Copies the template arguments (if present) into the given
/// structure.
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
  if (hasExplicitTemplateArgs())
    getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
        getTrailingObjects<TemplateArgumentLoc>(), List);
}

/// Retrieve the template arguments provided as part of this
/// template-id.
const TemplateArgumentLoc *getTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return nullptr;

  return getTrailingObjects<TemplateArgumentLoc>();
}

/// Retrieve the number of template arguments provided as part of this
/// template-id.
unsigned getNumTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return 0;

  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
}

ArrayRef<TemplateArgumentLoc> template_arguments() const {
  return {getTemplateArgs(), getNumTemplateArgs()};
}

/// Retrieve the member declaration name info.
DeclarationNameInfo getMemberNameInfo() const {
  return DeclarationNameInfo(MemberDecl->getDeclName(),
                             MemberLoc, MemberDNLoc);
}

SourceLocation getOperatorLoc() const LLVM_READONLY__attribute__((__pure__)) { return OperatorLoc; }

bool isArrow() const { return IsArrow; }
void setArrow(bool A) { IsArrow = A; }

/// getMemberLoc - Return the location of the "member", in X->F, it is the
/// location of 'F'.
SourceLocation getMemberLoc() const { return MemberLoc; }
void setMemberLoc(SourceLocation L) { MemberLoc = L; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__));

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) { return MemberLoc; }

/// Determine whether the base of this explicit is implicit.
bool isImplicitAccess() const {
  return getBase() && getBase()->isImplicitCXXThis();
}

/// Returns true if this member expression refers to a method that
/// was resolved from an overloaded set having size greater than 1.
bool hadMultipleCandidates() const {
  return HadMultipleCandidates;
}
/// Sets the flag telling whether this expression refers to
/// a method that was resolved from an overloaded set having size
/// greater than 1.
void setHadMultipleCandidates(bool V = true) {
  HadMultipleCandidates = V;
}

/// Returns true if virtual dispatch is performed.
/// If the member access is fully qualified, (i.e. X::f()), virtual
/// dispatching is not performed. In -fapple-kext mode qualified
/// calls to virtual method will still go through the vtable.
bool performsVirtualDispatch(const LangOptions &LO) const {
  return LO.AppleKext || !hasQualifier();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == MemberExprClass;
}

// Iterators
child_range children() { return child_range(&Base, &Base+1); }
const_child_range children() const {
  return const_child_range(&Base, &Base + 1);
}

friend TrailingObjects;
friend class ASTReader;
friend class ASTStmtWriter;
2712};

2714/// CompoundLiteralExpr - [C99 6.5.2.5]
2715///
2716class CompoundLiteralExpr : public Expr {
/// LParenLoc - If non-null, this is the location of the left paren in a
/// compound literal like "(int){4}".  This can be null if this is a
/// synthesized compound expression.
SourceLocation LParenLoc;

/// The type as written.  This can be an incomplete array type, in
/// which case the actual expression type will be different.
/// The int part of the pair stores whether this expr is file scope.
llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfoAndScope;
Stmt *Init;
2727public:
CompoundLiteralExpr(SourceLocation lparenloc, TypeSourceInfo *tinfo,
                    QualType T, ExprValueKind VK, Expr *init, bool fileScope)
  : Expr(CompoundLiteralExprClass, T, VK, OK_Ordinary,
         tinfo->getType()->isDependentType(),
         init->isValueDependent(),
         (init->isInstantiationDependent() ||
          tinfo->getType()->isInstantiationDependentType()),
         init->containsUnexpandedParameterPack()),
    LParenLoc(lparenloc), TInfoAndScope(tinfo, fileScope), Init(init) {}

/// Construct an empty compound literal.
explicit CompoundLiteralExpr(EmptyShell Empty)
  : Expr(CompoundLiteralExprClass, Empty) { }

const Expr *getInitializer() const { return cast<Expr>(Init); }
Expr *getInitializer() { return cast<Expr>(Init); }
void setInitializer(Expr *E) { Init = E; }

bool isFileScope() const { return TInfoAndScope.getInt(); }
void setFileScope(bool FS) { TInfoAndScope.setInt(FS); }

SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }

TypeSourceInfo *getTypeSourceInfo() const {
  return TInfoAndScope.getPointer();
}
void setTypeSourceInfo(TypeSourceInfo *tinfo) {
  TInfoAndScope.setPointer(tinfo);
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  // FIXME: Init should never be null.
  if (!Init)
    return SourceLocation();
  if (LParenLoc.isInvalid())
    return Init->getLocStart();
  return LParenLoc;
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  // FIXME: Init should never be null.
  if (!Init)
    return SourceLocation();
  return Init->getLocEnd();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CompoundLiteralExprClass;
}

// Iterators
child_range children() { return child_range(&Init, &Init+1); }
const_child_range children() const {
  return const_child_range(&Init, &Init + 1);
}
2783};

2785/// CastExpr - Base class for type casts, including both implicit
2786/// casts (ImplicitCastExpr) and explicit casts that have some
2787/// representation in the source code (ExplicitCastExpr's derived
2788/// classes).
2789class CastExpr : public Expr {
2790private:
Stmt *Op;

bool CastConsistency() const;

const CXXBaseSpecifier * const *path_buffer() const {
  return const_cast<CastExpr*>(this)->path_buffer();
}
CXXBaseSpecifier **path_buffer();

void setBasePathSize(unsigned basePathSize) {
  CastExprBits.BasePathSize = basePathSize;
  assert(CastExprBits.BasePathSize == basePathSize &&(static_cast <bool> (CastExprBits.BasePathSize == basePathSize
 && "basePathSize doesn't fit in bits of CastExprBits.BasePathSize!"
) ? void (0) : __assert_fail ("CastExprBits.BasePathSize == basePathSize && \"basePathSize doesn't fit in bits of CastExprBits.BasePathSize!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2803, __extension__ __PRETTY_FUNCTION__))
         "basePathSize doesn't fit in bits of CastExprBits.BasePathSize!")(static_cast <bool> (CastExprBits.BasePathSize == basePathSize
 && "basePathSize doesn't fit in bits of CastExprBits.BasePathSize!"
) ? void (0) : __assert_fail ("CastExprBits.BasePathSize == basePathSize && \"basePathSize doesn't fit in bits of CastExprBits.BasePathSize!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2803, __extension__ __PRETTY_FUNCTION__));
}

2806protected:
CastExpr(StmtClass SC, QualType ty, ExprValueKind VK, const CastKind kind,
         Expr *op, unsigned BasePathSize)
    : Expr(SC, ty, VK, OK_Ordinary,
           // Cast expressions are type-dependent if the type is
           // dependent (C++ [temp.dep.expr]p3).
           ty->isDependentType(),
           // Cast expressions are value-dependent if the type is
           // dependent or if the subexpression is value-dependent.
           ty->isDependentType() || (op && op->isValueDependent()),
           (ty->isInstantiationDependentType() ||
            (op && op->isInstantiationDependent())),
           // An implicit cast expression doesn't (lexically) contain an
           // unexpanded pack, even if its target type does.
           ((SC != ImplicitCastExprClass &&
             ty->containsUnexpandedParameterPack()) ||
            (op && op->containsUnexpandedParameterPack()))),
      Op(op) {
  CastExprBits.Kind = kind;
  CastExprBits.PartOfExplicitCast = false;
  setBasePathSize(BasePathSize);
  assert(CastConsistency())(static_cast <bool> (CastConsistency()) ? void (0) : __assert_fail
 ("CastConsistency()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2827, __extension__ __PRETTY_FUNCTION__));
}

/// Construct an empty cast.
CastExpr(StmtClass SC, EmptyShell Empty, unsigned BasePathSize)
  : Expr(SC, Empty) {
  CastExprBits.PartOfExplicitCast = false;
  setBasePathSize(BasePathSize);
}

2837public:
CastKind getCastKind() const { return (CastKind) CastExprBits.Kind; }
void setCastKind(CastKind K) { CastExprBits.Kind = K; }

static const char *getCastKindName(CastKind CK);
const char *getCastKindName() const { return getCastKindName(getCastKind()); }

Expr *getSubExpr() { return cast<Expr>(Op); }
const Expr *getSubExpr() const { return cast<Expr>(Op); }
void setSubExpr(Expr *E) { Op = E; }

/// Retrieve the cast subexpression as it was written in the source
/// code, looking through any implicit casts or other intermediate nodes
/// introduced by semantic analysis.
Expr *getSubExprAsWritten();
const Expr *getSubExprAsWritten() const {
  return const_cast<CastExpr *>(this)->getSubExprAsWritten();
}

/// If this cast applies a user-defined conversion, retrieve the conversion
/// function that it invokes.
NamedDecl *getConversionFunction() const;

typedef CXXBaseSpecifier **path_iterator;
typedef const CXXBaseSpecifier * const *path_const_iterator;
bool path_empty() const { return CastExprBits.BasePathSize == 0; }
unsigned path_size() const { return CastExprBits.BasePathSize; }
path_iterator path_begin() { return path_buffer(); }
path_iterator path_end() { return path_buffer() + path_size(); }
path_const_iterator path_begin() const { return path_buffer(); }
path_const_iterator path_end() const { return path_buffer() + path_size(); }

const FieldDecl *getTargetUnionField() const {
  assert(getCastKind() == CK_ToUnion)(static_cast <bool> (getCastKind() == CK_ToUnion) ? void
 (0) : __assert_fail ("getCastKind() == CK_ToUnion", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 2870, __extension__ __PRETTY_FUNCTION__));
  return getTargetFieldForToUnionCast(getType(), getSubExpr()->getType());
}

static const FieldDecl *getTargetFieldForToUnionCast(QualType unionType,
                                                     QualType opType);
static const FieldDecl *getTargetFieldForToUnionCast(const RecordDecl *RD,
                                                     QualType opType);

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstCastExprConstant &&
         T->getStmtClass() <= lastCastExprConstant;
}

// Iterators
child_range children() { return child_range(&Op, &Op+1); }
const_child_range children() const { return const_child_range(&Op, &Op + 1); }
2887};

2889/// ImplicitCastExpr - Allows us to explicitly represent implicit type
2890/// conversions, which have no direct representation in the original
2891/// source code. For example: converting T[]->T*, void f()->void
2892/// (*f)(), float->double, short->int, etc.
2893///
2894/// In C, implicit casts always produce rvalues. However, in C++, an
2895/// implicit cast whose result is being bound to a reference will be
2896/// an lvalue or xvalue. For example:
2897///
2898/// @code
2899/// class Base { };
2900/// class Derived : public Base { };
2901/// Derived &&ref();
2902/// void f(Derived d) {
2903///   Base& b = d; // initializer is an ImplicitCastExpr
2904///                // to an lvalue of type Base
2905///   Base&& r = ref(); // initializer is an ImplicitCastExpr
2906///                     // to an xvalue of type Base
2907/// }
2908/// @endcode
2909class ImplicitCastExpr final
  : public CastExpr,
    private llvm::TrailingObjects<ImplicitCastExpr, CXXBaseSpecifier *> {
2912private:
ImplicitCastExpr(QualType ty, CastKind kind, Expr *op,
                 unsigned BasePathLength, ExprValueKind VK)
  : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, BasePathLength) {
}

/// Construct an empty implicit cast.
explicit ImplicitCastExpr(EmptyShell Shell, unsigned PathSize)
  : CastExpr(ImplicitCastExprClass, Shell, PathSize) { }

2922public:
enum OnStack_t { OnStack };
ImplicitCastExpr(OnStack_t _, QualType ty, CastKind kind, Expr *op,
                 ExprValueKind VK)
  : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, 0) {
}

bool isPartOfExplicitCast() const { return CastExprBits.PartOfExplicitCast; }
void setIsPartOfExplicitCast(bool PartOfExplicitCast) {
  CastExprBits.PartOfExplicitCast = PartOfExplicitCast;
}

static ImplicitCastExpr *Create(const ASTContext &Context, QualType T,
                                CastKind Kind, Expr *Operand,
                                const CXXCastPath *BasePath,
                                ExprValueKind Cat);

static ImplicitCastExpr *CreateEmpty(const ASTContext &Context,
                                     unsigned PathSize);

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getSubExpr()->getLocStart();
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return getSubExpr()->getLocEnd();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ImplicitCastExprClass;
}

friend TrailingObjects;
friend class CastExpr;
2955};

2957inline Expr *Expr::IgnoreImpCasts() {
Expr *e = this;
while (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
  e = ice->getSubExpr();
return e;
2962}

2964/// ExplicitCastExpr - An explicit cast written in the source
2965/// code.
2966///
2967/// This class is effectively an abstract class, because it provides
2968/// the basic representation of an explicitly-written cast without
2969/// specifying which kind of cast (C cast, functional cast, static
2970/// cast, etc.) was written; specific derived classes represent the
2971/// particular style of cast and its location information.
2972///
2973/// Unlike implicit casts, explicit cast nodes have two different
2974/// types: the type that was written into the source code, and the
2975/// actual type of the expression as determined by semantic
2976/// analysis. These types may differ slightly. For example, in C++ one
2977/// can cast to a reference type, which indicates that the resulting
2978/// expression will be an lvalue or xvalue. The reference type, however,
2979/// will not be used as the type of the expression.
2980class ExplicitCastExpr : public CastExpr {
/// TInfo - Source type info for the (written) type
/// this expression is casting to.
TypeSourceInfo *TInfo;

2985protected:
ExplicitCastExpr(StmtClass SC, QualType exprTy, ExprValueKind VK,
                 CastKind kind, Expr *op, unsigned PathSize,
                 TypeSourceInfo *writtenTy)
  : CastExpr(SC, exprTy, VK, kind, op, PathSize), TInfo(writtenTy) {}

/// Construct an empty explicit cast.
ExplicitCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize)
  : CastExpr(SC, Shell, PathSize) { }

2995public:
/// getTypeInfoAsWritten - Returns the type source info for the type
/// that this expression is casting to.
TypeSourceInfo *getTypeInfoAsWritten() const { return TInfo; }
void setTypeInfoAsWritten(TypeSourceInfo *writtenTy) { TInfo = writtenTy; }

/// getTypeAsWritten - Returns the type that this expression is
/// casting to, as written in the source code.
QualType getTypeAsWritten() const { return TInfo->getType(); }

static bool classof(const Stmt *T) {
   return T->getStmtClass() >= firstExplicitCastExprConstant &&
          T->getStmtClass() <= lastExplicitCastExprConstant;
}
3009};

3011/// CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style
3012/// cast in C++ (C++ [expr.cast]), which uses the syntax
3013/// (Type)expr. For example: @c (int)f.
3014class CStyleCastExpr final
  : public ExplicitCastExpr,
    private llvm::TrailingObjects<CStyleCastExpr, CXXBaseSpecifier *> {
SourceLocation LPLoc; // the location of the left paren
SourceLocation RPLoc; // the location of the right paren

CStyleCastExpr(QualType exprTy, ExprValueKind vk, CastKind kind, Expr *op,
               unsigned PathSize, TypeSourceInfo *writtenTy,
               SourceLocation l, SourceLocation r)
  : ExplicitCastExpr(CStyleCastExprClass, exprTy, vk, kind, op, PathSize,
                     writtenTy), LPLoc(l), RPLoc(r) {}

/// Construct an empty C-style explicit cast.
explicit CStyleCastExpr(EmptyShell Shell, unsigned PathSize)
  : ExplicitCastExpr(CStyleCastExprClass, Shell, PathSize) { }

3030public:
static CStyleCastExpr *Create(const ASTContext &Context, QualType T,
                              ExprValueKind VK, CastKind K,
                              Expr *Op, const CXXCastPath *BasePath,
                              TypeSourceInfo *WrittenTy, SourceLocation L,
                              SourceLocation R);

static CStyleCastExpr *CreateEmpty(const ASTContext &Context,
                                   unsigned PathSize);

SourceLocation getLParenLoc() const { return LPLoc; }
void setLParenLoc(SourceLocation L) { LPLoc = L; }

SourceLocation getRParenLoc() const { return RPLoc; }
void setRParenLoc(SourceLocation L) { RPLoc = L; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return LPLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return getSubExpr()->getLocEnd();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CStyleCastExprClass;
}

friend TrailingObjects;
friend class CastExpr;
3057};

3059/// A builtin binary operation expression such as "x + y" or "x <= y".
3060///
3061/// This expression node kind describes a builtin binary operation,
3062/// such as "x + y" for integer values "x" and "y". The operands will
3063/// already have been converted to appropriate types (e.g., by
3064/// performing promotions or conversions).
3065///
3066/// In C++, where operators may be overloaded, a different kind of
3067/// expression node (CXXOperatorCallExpr) is used to express the
3068/// invocation of an overloaded operator with operator syntax. Within
3069/// a C++ template, whether BinaryOperator or CXXOperatorCallExpr is
3070/// used to store an expression "x + y" depends on the subexpressions
3071/// for x and y. If neither x or y is type-dependent, and the "+"
3072/// operator resolves to a built-in operation, BinaryOperator will be
3073/// used to express the computation (x and y may still be
3074/// value-dependent). If either x or y is type-dependent, or if the
3075/// "+" resolves to an overloaded operator, CXXOperatorCallExpr will
3076/// be used to express the computation.
3077class BinaryOperator : public Expr {
3078public:
typedef BinaryOperatorKind Opcode;

3081private:
unsigned Opc : 6;

// This is only meaningful for operations on floating point types and 0
// otherwise.
unsigned FPFeatures : 2;
SourceLocation OpLoc;

enum { LHS, RHS, END_EXPR };
Stmt* SubExprs[END_EXPR];
3091public:

BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
               ExprValueKind VK, ExprObjectKind OK,
               SourceLocation opLoc, FPOptions FPFeatures)
  : Expr(BinaryOperatorClass, ResTy, VK, OK,
         lhs->isTypeDependent() || rhs->isTypeDependent(),
         lhs->isValueDependent() || rhs->isValueDependent(),
         (lhs->isInstantiationDependent() ||
          rhs->isInstantiationDependent()),
         (lhs->containsUnexpandedParameterPack() ||
          rhs->containsUnexpandedParameterPack())),
    Opc(opc), FPFeatures(FPFeatures.getInt()), OpLoc(opLoc) {
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
  assert(!isCompoundAssignmentOp() &&(static_cast <bool> (!isCompoundAssignmentOp() &&
 "Use CompoundAssignOperator for compound assignments") ? void
 (0) : __assert_fail ("!isCompoundAssignmentOp() && \"Use CompoundAssignOperator for compound assignments\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3107, __extension__ __PRETTY_FUNCTION__))
         "Use CompoundAssignOperator for compound assignments")(static_cast <bool> (!isCompoundAssignmentOp() &&
 "Use CompoundAssignOperator for compound assignments") ? void
 (0) : __assert_fail ("!isCompoundAssignmentOp() && \"Use CompoundAssignOperator for compound assignments\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3107, __extension__ __PRETTY_FUNCTION__));
}

/// Construct an empty binary operator.
explicit BinaryOperator(EmptyShell Empty)
  : Expr(BinaryOperatorClass, Empty), Opc(BO_Comma) { }

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) { return OpLoc; }
SourceLocation getOperatorLoc() const { return OpLoc; }
void setOperatorLoc(SourceLocation L) { OpLoc = L; }

Opcode getOpcode() const { return static_cast<Opcode>(Opc); }
void setOpcode(Opcode O) { Opc = O; }

Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
void setLHS(Expr *E) { SubExprs[LHS] = E; }
Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
void setRHS(Expr *E) { SubExprs[RHS] = E; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getLHS()->getLocStart();
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return getRHS()->getLocEnd();
}

/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
/// corresponds to, e.g. "<<=".
static StringRef getOpcodeStr(Opcode Op);

StringRef getOpcodeStr() const { return getOpcodeStr(getOpcode()); }

/// Retrieve the binary opcode that corresponds to the given
/// overloaded operator.
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO);

/// Retrieve the overloaded operator kind that corresponds to
/// the given binary opcode.
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc);

/// predicates to categorize the respective opcodes.
bool isPtrMemOp() const { return Opc == BO_PtrMemD || Opc == BO_PtrMemI; }
static bool isMultiplicativeOp(Opcode Opc) {
  return Opc >= BO_Mul && Opc <= BO_Rem;
}
bool isMultiplicativeOp() const { return isMultiplicativeOp(getOpcode()); }
static bool isAdditiveOp(Opcode Opc) { return Opc == BO_Add || Opc==BO_Sub; }
bool isAdditiveOp() const { return isAdditiveOp(getOpcode()); }
static bool isShiftOp(Opcode Opc) { return Opc == BO_Shl || Opc == BO_Shr; }
bool isShiftOp() const { return isShiftOp(getOpcode()); }

static bool isBitwiseOp(Opcode Opc) { return Opc >= BO_And && Opc <= BO_Or; }
bool isBitwiseOp() const { return isBitwiseOp(getOpcode()); }

static bool isRelationalOp(Opcode Opc) { return Opc >= BO_LT && Opc<=BO_GE; }
bool isRelationalOp() const { return isRelationalOp(getOpcode()); }

static bool isEqualityOp(Opcode Opc) { return Opc == BO_EQ || Opc == BO_NE; }
bool isEqualityOp() const { return isEqualityOp(getOpcode()); }

static bool isComparisonOp(Opcode Opc) { return Opc >= BO_Cmp && Opc<=BO_NE; }
bool isComparisonOp() const { return isComparisonOp(getOpcode()); }

static Opcode negateComparisonOp(Opcode Opc) {
  switch (Opc) {
  default:
    llvm_unreachable("Not a comparison operator.")::llvm::llvm_unreachable_internal("Not a comparison operator."
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3173);
  case BO_LT: return BO_GE;
  case BO_GT: return BO_LE;
  case BO_LE: return BO_GT;
  case BO_GE: return BO_LT;
  case BO_EQ: return BO_NE;
  case BO_NE: return BO_EQ;
  }
}

static Opcode reverseComparisonOp(Opcode Opc) {
  switch (Opc) {
  default:
    llvm_unreachable("Not a comparison operator.")::llvm::llvm_unreachable_internal("Not a comparison operator."
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3186);
  case BO_LT: return BO_GT;
  case BO_GT: return BO_LT;
  case BO_LE: return BO_GE;
  case BO_GE: return BO_LE;
  case BO_EQ:
  case BO_NE:
    return Opc;
  }
}

static bool isLogicalOp(Opcode Opc) { return Opc == BO_LAnd || Opc==BO_LOr; }
bool isLogicalOp() const { return isLogicalOp(getOpcode()); }

static bool isAssignmentOp(Opcode Opc) {
  return Opc >= BO_Assign && Opc <= BO_OrAssign;
}
bool isAssignmentOp() const { return isAssignmentOp(getOpcode()); }

static bool isCompoundAssignmentOp(Opcode Opc) {
  return Opc > BO_Assign && Opc <= BO_OrAssign;
}
bool isCompoundAssignmentOp() const {
  return isCompoundAssignmentOp(getOpcode());
}
static Opcode getOpForCompoundAssignment(Opcode Opc) {
  assert(isCompoundAssignmentOp(Opc))(static_cast <bool> (isCompoundAssignmentOp(Opc)) ? void
 (0) : __assert_fail ("isCompoundAssignmentOp(Opc)", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3212, __extension__ __PRETTY_FUNCTION__));
  if (Opc >= BO_AndAssign)
    return Opcode(unsigned(Opc) - BO_AndAssign + BO_And);
  else
    return Opcode(unsigned(Opc) - BO_MulAssign + BO_Mul);
}

static bool isShiftAssignOp(Opcode Opc) {
  return Opc == BO_ShlAssign || Opc == BO_ShrAssign;
}
bool isShiftAssignOp() const {
  return isShiftAssignOp(getOpcode());
}

// Return true if a binary operator using the specified opcode and operands
// would match the 'p = (i8*)nullptr + n' idiom for casting a pointer-sized
// integer to a pointer.
static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc,
                                             Expr *LHS, Expr *RHS);

static bool classof(const Stmt *S) {
  return S->getStmtClass() >= firstBinaryOperatorConstant &&
         S->getStmtClass() <= lastBinaryOperatorConstant;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}

// Set the FP contractability status of this operator. Only meaningful for
// operations on floating point types.
void setFPFeatures(FPOptions F) { FPFeatures = F.getInt(); }

FPOptions getFPFeatures() const { return FPOptions(FPFeatures); }

// Get the FP contractability status of this operator. Only meaningful for
// operations on floating point types.
bool isFPContractableWithinStatement() const {
  return FPOptions(FPFeatures).allowFPContractWithinStatement();
}

3257protected:
BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
               ExprValueKind VK, ExprObjectKind OK,
               SourceLocation opLoc, FPOptions FPFeatures, bool dead2)
  : Expr(CompoundAssignOperatorClass, ResTy, VK, OK,
         lhs->isTypeDependent() || rhs->isTypeDependent(),
         lhs->isValueDependent() || rhs->isValueDependent(),
         (lhs->isInstantiationDependent() ||
          rhs->isInstantiationDependent()),
         (lhs->containsUnexpandedParameterPack() ||
          rhs->containsUnexpandedParameterPack())),
    Opc(opc), FPFeatures(FPFeatures.getInt()), OpLoc(opLoc) {
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
}

BinaryOperator(StmtClass SC, EmptyShell Empty)
  : Expr(SC, Empty), Opc(BO_MulAssign) { }
3275};

3277/// CompoundAssignOperator - For compound assignments (e.g. +=), we keep
3278/// track of the type the operation is performed in.  Due to the semantics of
3279/// these operators, the operands are promoted, the arithmetic performed, an
3280/// implicit conversion back to the result type done, then the assignment takes
3281/// place.  This captures the intermediate type which the computation is done
3282/// in.
3283class CompoundAssignOperator : public BinaryOperator {
QualType ComputationLHSType;
QualType ComputationResultType;
3286public:
CompoundAssignOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResType,
                       ExprValueKind VK, ExprObjectKind OK,
                       QualType CompLHSType, QualType CompResultType,
                       SourceLocation OpLoc, FPOptions FPFeatures)
  : BinaryOperator(lhs, rhs, opc, ResType, VK, OK, OpLoc, FPFeatures,
                   true),
    ComputationLHSType(CompLHSType),
    ComputationResultType(CompResultType) {
  assert(isCompoundAssignmentOp() &&(static_cast <bool> (isCompoundAssignmentOp() &&
 "Only should be used for compound assignments") ? void (0) :
 __assert_fail ("isCompoundAssignmentOp() && \"Only should be used for compound assignments\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3296, __extension__ __PRETTY_FUNCTION__))
         "Only should be used for compound assignments")(static_cast <bool> (isCompoundAssignmentOp() &&
 "Only should be used for compound assignments") ? void (0) :
 __assert_fail ("isCompoundAssignmentOp() && \"Only should be used for compound assignments\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3296, __extension__ __PRETTY_FUNCTION__));
}

/// Build an empty compound assignment operator expression.
explicit CompoundAssignOperator(EmptyShell Empty)
  : BinaryOperator(CompoundAssignOperatorClass, Empty) { }

// The two computation types are the type the LHS is converted
// to for the computation and the type of the result; the two are
// distinct in a few cases (specifically, int+=ptr and ptr-=ptr).
QualType getComputationLHSType() const { return ComputationLHSType; }
void setComputationLHSType(QualType T) { ComputationLHSType = T; }

QualType getComputationResultType() const { return ComputationResultType; }
void setComputationResultType(QualType T) { ComputationResultType = T; }

static bool classof(const Stmt *S) {
  return S->getStmtClass() == CompoundAssignOperatorClass;
}
3315};

3317/// AbstractConditionalOperator - An abstract base class for
3318/// ConditionalOperator and BinaryConditionalOperator.
3319class AbstractConditionalOperator : public Expr {
SourceLocation QuestionLoc, ColonLoc;
friend class ASTStmtReader;

3323protected:
AbstractConditionalOperator(StmtClass SC, QualType T,
                            ExprValueKind VK, ExprObjectKind OK,
                            bool TD, bool VD, bool ID,
                            bool ContainsUnexpandedParameterPack,
                            SourceLocation qloc,
                            SourceLocation cloc)
  : Expr(SC, T, VK, OK, TD, VD, ID, ContainsUnexpandedParameterPack),
    QuestionLoc(qloc), ColonLoc(cloc) {}

AbstractConditionalOperator(StmtClass SC, EmptyShell Empty)
  : Expr(SC, Empty) { }

3336public:
// getCond - Return the expression representing the condition for
//   the ?: operator.
Expr *getCond() const;

// getTrueExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to true.
Expr *getTrueExpr() const;

// getFalseExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to false.  This is
//   the same as getRHS.
Expr *getFalseExpr() const;

SourceLocation getQuestionLoc() const { return QuestionLoc; }
SourceLocation getColonLoc() const { return ColonLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConditionalOperatorClass ||
         T->getStmtClass() == BinaryConditionalOperatorClass;
}
3357};

3359/// ConditionalOperator - The ?: ternary operator.  The GNU "missing
3360/// middle" extension is a BinaryConditionalOperator.
3361class ConditionalOperator : public AbstractConditionalOperator {
enum { COND, LHS, RHS, END_EXPR };
Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.

friend class ASTStmtReader;
3366public:
ConditionalOperator(Expr *cond, SourceLocation QLoc, Expr *lhs,
                    SourceLocation CLoc, Expr *rhs,
                    QualType t, ExprValueKind VK, ExprObjectKind OK)
  : AbstractConditionalOperator(ConditionalOperatorClass, t, VK, OK,
         // FIXME: the type of the conditional operator doesn't
         // depend on the type of the conditional, but the standard
         // seems to imply that it could. File a bug!
         (lhs->isTypeDependent() || rhs->isTypeDependent()),
         (cond->isValueDependent() || lhs->isValueDependent() ||
          rhs->isValueDependent()),
         (cond->isInstantiationDependent() ||
          lhs->isInstantiationDependent() ||
          rhs->isInstantiationDependent()),
         (cond->containsUnexpandedParameterPack() ||
          lhs->containsUnexpandedParameterPack() ||
          rhs->containsUnexpandedParameterPack()),
                                QLoc, CLoc) {
  SubExprs[COND] = cond;
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
}

/// Build an empty conditional operator.
explicit ConditionalOperator(EmptyShell Empty)
  : AbstractConditionalOperator(ConditionalOperatorClass, Empty) { }

// getCond - Return the expression representing the condition for
//   the ?: operator.
Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }

// getTrueExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to true.
Expr *getTrueExpr() const { return cast<Expr>(SubExprs[LHS]); }

// getFalseExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to false.  This is
//   the same as getRHS.
Expr *getFalseExpr() const { return cast<Expr>(SubExprs[RHS]); }

Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getCond()->getLocStart();
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return getRHS()->getLocEnd();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConditionalOperatorClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
3427};

3429/// BinaryConditionalOperator - The GNU extension to the conditional
3430/// operator which allows the middle operand to be omitted.
3431///
3432/// This is a different expression kind on the assumption that almost
3433/// every client ends up needing to know that these are different.
3434class BinaryConditionalOperator : public AbstractConditionalOperator {
enum { COMMON, COND, LHS, RHS, NUM_SUBEXPRS };

/// - the common condition/left-hand-side expression, which will be
///   evaluated as the opaque value
/// - the condition, expressed in terms of the opaque value
/// - the left-hand-side, expressed in terms of the opaque value
/// - the right-hand-side
Stmt *SubExprs[NUM_SUBEXPRS];
OpaqueValueExpr *OpaqueValue;

friend class ASTStmtReader;
3446public:
BinaryConditionalOperator(Expr *common, OpaqueValueExpr *opaqueValue,
                          Expr *cond, Expr *lhs, Expr *rhs,
                          SourceLocation qloc, SourceLocation cloc,
                          QualType t, ExprValueKind VK, ExprObjectKind OK)
  : AbstractConditionalOperator(BinaryConditionalOperatorClass, t, VK, OK,
         (common->isTypeDependent() || rhs->isTypeDependent()),
         (common->isValueDependent() || rhs->isValueDependent()),
         (common->isInstantiationDependent() ||
          rhs->isInstantiationDependent()),
         (common->containsUnexpandedParameterPack() ||
          rhs->containsUnexpandedParameterPack()),
                                qloc, cloc),
    OpaqueValue(opaqueValue) {
  SubExprs[COMMON] = common;
  SubExprs[COND] = cond;
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
  assert(OpaqueValue->getSourceExpr() == common && "Wrong opaque value")(static_cast <bool> (OpaqueValue->getSourceExpr() ==
 common && "Wrong opaque value") ? void (0) : __assert_fail
 ("OpaqueValue->getSourceExpr() == common && \"Wrong opaque value\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3464, __extension__ __PRETTY_FUNCTION__));
}

/// Build an empty conditional operator.
explicit BinaryConditionalOperator(EmptyShell Empty)
  : AbstractConditionalOperator(BinaryConditionalOperatorClass, Empty) { }

/// getCommon - Return the common expression, written to the
///   left of the condition.  The opaque value will be bound to the
///   result of this expression.
Expr *getCommon() const { return cast<Expr>(SubExprs[COMMON]); }

/// getOpaqueValue - Return the opaque value placeholder.
OpaqueValueExpr *getOpaqueValue() const { return OpaqueValue; }

/// getCond - Return the condition expression; this is defined
///   in terms of the opaque value.
Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }

/// getTrueExpr - Return the subexpression which will be
///   evaluated if the condition evaluates to true;  this is defined
///   in terms of the opaque value.
Expr *getTrueExpr() const {
  return cast<Expr>(SubExprs[LHS]);
}

/// getFalseExpr - Return the subexpression which will be
///   evaluated if the condnition evaluates to false; this is
///   defined in terms of the opaque value.
Expr *getFalseExpr() const {
  return cast<Expr>(SubExprs[RHS]);
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getCommon()->getLocStart();
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return getFalseExpr()->getLocEnd();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == BinaryConditionalOperatorClass;
}

// Iterators
child_range children() {
  return child_range(SubExprs, SubExprs + NUM_SUBEXPRS);
}
const_child_range children() const {
  return const_child_range(SubExprs, SubExprs + NUM_SUBEXPRS);
}
3515};

3517inline Expr *AbstractConditionalOperator::getCond() const {
if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
  return co->getCond();
return cast<BinaryConditionalOperator>(this)->getCond();
3521}

3523inline Expr *AbstractConditionalOperator::getTrueExpr() const {
if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
  return co->getTrueExpr();
return cast<BinaryConditionalOperator>(this)->getTrueExpr();
3527}

3529inline Expr *AbstractConditionalOperator::getFalseExpr() const {
if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
  return co->getFalseExpr();
return cast<BinaryConditionalOperator>(this)->getFalseExpr();
3533}

3535/// AddrLabelExpr - The GNU address of label extension, representing &&label.
3536class AddrLabelExpr : public Expr {
SourceLocation AmpAmpLoc, LabelLoc;
LabelDecl *Label;
3539public:
AddrLabelExpr(SourceLocation AALoc, SourceLocation LLoc, LabelDecl *L,
              QualType t)
  : Expr(AddrLabelExprClass, t, VK_RValue, OK_Ordinary, false, false, false,
         false),
    AmpAmpLoc(AALoc), LabelLoc(LLoc), Label(L) {}

/// Build an empty address of a label expression.
explicit AddrLabelExpr(EmptyShell Empty)
  : Expr(AddrLabelExprClass, Empty) { }

SourceLocation getAmpAmpLoc() const { return AmpAmpLoc; }
void setAmpAmpLoc(SourceLocation L) { AmpAmpLoc = L; }
SourceLocation getLabelLoc() const { return LabelLoc; }
void setLabelLoc(SourceLocation L) { LabelLoc = L; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return AmpAmpLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return LabelLoc; }

LabelDecl *getLabel() const { return Label; }
void setLabel(LabelDecl *L) { Label = L; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == AddrLabelExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
3572};

3574/// StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
3575/// The StmtExpr contains a single CompoundStmt node, which it evaluates and
3576/// takes the value of the last subexpression.
3577///
3578/// A StmtExpr is always an r-value; values "returned" out of a
3579/// StmtExpr will be copied.
3580class StmtExpr : public Expr {
Stmt *SubStmt;
SourceLocation LParenLoc, RParenLoc;
3583public:
// FIXME: Does type-dependence need to be computed differently?
// FIXME: Do we need to compute instantiation instantiation-dependence for
// statements? (ugh!)
StmtExpr(CompoundStmt *substmt, QualType T,
         SourceLocation lp, SourceLocation rp) :
  Expr(StmtExprClass, T, VK_RValue, OK_Ordinary,
       T->isDependentType(), false, false, false),
  SubStmt(substmt), LParenLoc(lp), RParenLoc(rp) { }

/// Build an empty statement expression.
explicit StmtExpr(EmptyShell Empty) : Expr(StmtExprClass, Empty) { }

CompoundStmt *getSubStmt() { return cast<CompoundStmt>(SubStmt); }
const CompoundStmt *getSubStmt() const { return cast<CompoundStmt>(SubStmt); }
void setSubStmt(CompoundStmt *S) { SubStmt = S; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return LParenLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == StmtExprClass;
}

// Iterators
child_range children() { return child_range(&SubStmt, &SubStmt+1); }
const_child_range children() const {
  return const_child_range(&SubStmt, &SubStmt + 1);
}
3617};

3619/// ShuffleVectorExpr - clang-specific builtin-in function
3620/// __builtin_shufflevector.
3621/// This AST node represents a operator that does a constant
3622/// shuffle, similar to LLVM's shufflevector instruction. It takes
3623/// two vectors and a variable number of constant indices,
3624/// and returns the appropriately shuffled vector.
3625class ShuffleVectorExpr : public Expr {
SourceLocation BuiltinLoc, RParenLoc;

// SubExprs - the list of values passed to the __builtin_shufflevector
// function. The first two are vectors, and the rest are constant
// indices.  The number of values in this list is always
// 2+the number of indices in the vector type.
Stmt **SubExprs;
unsigned NumExprs;

3635public:
ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args, QualType Type,
                  SourceLocation BLoc, SourceLocation RP);

/// Build an empty vector-shuffle expression.
explicit ShuffleVectorExpr(EmptyShell Empty)
  : Expr(ShuffleVectorExprClass, Empty), SubExprs(nullptr) { }

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ShuffleVectorExprClass;
}

/// getNumSubExprs - Return the size of the SubExprs array.  This includes the
/// constant expression, the actual arguments passed in, and the function
/// pointers.
unsigned getNumSubExprs() const { return NumExprs; }

/// Retrieve the array of expressions.
Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }

/// getExpr - Return the Expr at the specified index.
Expr *getExpr(unsigned Index) {
  assert((Index < NumExprs) && "Arg access out of range!")(static_cast <bool> ((Index < NumExprs) && "Arg access out of range!"
) ? void (0) : __assert_fail ("(Index < NumExprs) && \"Arg access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3666, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[Index]);
}
const Expr *getExpr(unsigned Index) const {
  assert((Index < NumExprs) && "Arg access out of range!")(static_cast <bool> ((Index < NumExprs) && "Arg access out of range!"
) ? void (0) : __assert_fail ("(Index < NumExprs) && \"Arg access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3670, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[Index]);
}

void setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs);

llvm::APSInt getShuffleMaskIdx(const ASTContext &Ctx, unsigned N) const {
  assert((N < NumExprs - 2) && "Shuffle idx out of range!")(static_cast <bool> ((N < NumExprs - 2) && "Shuffle idx out of range!"
) ? void (0) : __assert_fail ("(N < NumExprs - 2) && \"Shuffle idx out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3677, __extension__ __PRETTY_FUNCTION__));
  return getExpr(N+2)->EvaluateKnownConstInt(Ctx);
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+NumExprs);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + NumExprs);
}
3688};

3690/// ConvertVectorExpr - Clang builtin function __builtin_convertvector
3691/// This AST node provides support for converting a vector type to another
3692/// vector type of the same arity.
3693class ConvertVectorExpr : public Expr {
3694private:
Stmt *SrcExpr;
TypeSourceInfo *TInfo;
SourceLocation BuiltinLoc, RParenLoc;

friend class ASTReader;
friend class ASTStmtReader;
explicit ConvertVectorExpr(EmptyShell Empty) : Expr(ConvertVectorExprClass, Empty) {}

3703public:
ConvertVectorExpr(Expr* SrcExpr, TypeSourceInfo *TI, QualType DstType,
           ExprValueKind VK, ExprObjectKind OK,
           SourceLocation BuiltinLoc, SourceLocation RParenLoc)
  : Expr(ConvertVectorExprClass, DstType, VK, OK,
         DstType->isDependentType(),
         DstType->isDependentType() || SrcExpr->isValueDependent(),
         (DstType->isInstantiationDependentType() ||
          SrcExpr->isInstantiationDependent()),
         (DstType->containsUnexpandedParameterPack() ||
          SrcExpr->containsUnexpandedParameterPack())),
SrcExpr(SrcExpr), TInfo(TI), BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {}

/// getSrcExpr - Return the Expr to be converted.
Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }

/// getTypeSourceInfo - Return the destination type.
TypeSourceInfo *getTypeSourceInfo() const {
  return TInfo;
}
void setTypeSourceInfo(TypeSourceInfo *ti) {
  TInfo = ti;
}

/// getBuiltinLoc - Return the location of the __builtin_convertvector token.
SourceLocation getBuiltinLoc() const { return BuiltinLoc; }

/// getRParenLoc - Return the location of final right parenthesis.
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConvertVectorExprClass;
}

// Iterators
child_range children() { return child_range(&SrcExpr, &SrcExpr+1); }
const_child_range children() const {
  return const_child_range(&SrcExpr, &SrcExpr + 1);
}
3745};

3747/// ChooseExpr - GNU builtin-in function __builtin_choose_expr.
3748/// This AST node is similar to the conditional operator (?:) in C, with
3749/// the following exceptions:
3750/// - the test expression must be a integer constant expression.
3751/// - the expression returned acts like the chosen subexpression in every
3752///   visible way: the type is the same as that of the chosen subexpression,
3753///   and all predicates (whether it's an l-value, whether it's an integer
3754///   constant expression, etc.) return the same result as for the chosen
3755///   sub-expression.
3756class ChooseExpr : public Expr {
enum { COND, LHS, RHS, END_EXPR };
Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
SourceLocation BuiltinLoc, RParenLoc;
bool CondIsTrue;
3761public:
ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs,
           QualType t, ExprValueKind VK, ExprObjectKind OK,
           SourceLocation RP, bool condIsTrue,
           bool TypeDependent, bool ValueDependent)
  : Expr(ChooseExprClass, t, VK, OK, TypeDependent, ValueDependent,
         (cond->isInstantiationDependent() ||
          lhs->isInstantiationDependent() ||
          rhs->isInstantiationDependent()),
         (cond->containsUnexpandedParameterPack() ||
          lhs->containsUnexpandedParameterPack() ||
          rhs->containsUnexpandedParameterPack())),
    BuiltinLoc(BLoc), RParenLoc(RP), CondIsTrue(condIsTrue) {
    SubExprs[COND] = cond;
    SubExprs[LHS] = lhs;
    SubExprs[RHS] = rhs;
  }

/// Build an empty __builtin_choose_expr.
explicit ChooseExpr(EmptyShell Empty) : Expr(ChooseExprClass, Empty) { }

/// isConditionTrue - Return whether the condition is true (i.e. not
/// equal to zero).
bool isConditionTrue() const {
  assert(!isConditionDependent() &&(static_cast <bool> (!isConditionDependent() &&
 "Dependent condition isn't true or false") ? void (0) : __assert_fail
 ("!isConditionDependent() && \"Dependent condition isn't true or false\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3786, __extension__ __PRETTY_FUNCTION__))
         "Dependent condition isn't true or false")(static_cast <bool> (!isConditionDependent() &&
 "Dependent condition isn't true or false") ? void (0) : __assert_fail
 ("!isConditionDependent() && \"Dependent condition isn't true or false\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 3786, __extension__ __PRETTY_FUNCTION__));
  return CondIsTrue;
}
void setIsConditionTrue(bool isTrue) { CondIsTrue = isTrue; }

bool isConditionDependent() const {
  return getCond()->isTypeDependent() || getCond()->isValueDependent();
}

/// getChosenSubExpr - Return the subexpression chosen according to the
/// condition.
Expr *getChosenSubExpr() const {
  return isConditionTrue() ? getLHS() : getRHS();
}

Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
void setCond(Expr *E) { SubExprs[COND] = E; }
Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
void setLHS(Expr *E) { SubExprs[LHS] = E; }
Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
void setRHS(Expr *E) { SubExprs[RHS] = E; }

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ChooseExprClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
3828};

3830/// GNUNullExpr - Implements the GNU __null extension, which is a name
3831/// for a null pointer constant that has integral type (e.g., int or
3832/// long) and is the same size and alignment as a pointer. The __null
3833/// extension is typically only used by system headers, which define
3834/// NULL as __null in C++ rather than using 0 (which is an integer
3835/// that may not match the size of a pointer).
3836class GNUNullExpr : public Expr {
/// TokenLoc - The location of the __null keyword.
SourceLocation TokenLoc;

3840public:
GNUNullExpr(QualType Ty, SourceLocation Loc)
  : Expr(GNUNullExprClass, Ty, VK_RValue, OK_Ordinary, false, false, false,
         false),
    TokenLoc(Loc) { }

/// Build an empty GNU __null expression.
explicit GNUNullExpr(EmptyShell Empty) : Expr(GNUNullExprClass, Empty) { }

/// getTokenLocation - The location of the __null token.
SourceLocation getTokenLocation() const { return TokenLoc; }
void setTokenLocation(SourceLocation L) { TokenLoc = L; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return TokenLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return TokenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == GNUNullExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
3867};

3869/// Represents a call to the builtin function \c __builtin_va_arg.
3870class VAArgExpr : public Expr {
Stmt *Val;
llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfo;
SourceLocation BuiltinLoc, RParenLoc;
3874public:
VAArgExpr(SourceLocation BLoc, Expr *e, TypeSourceInfo *TInfo,
          SourceLocation RPLoc, QualType t, bool IsMS)
    : Expr(VAArgExprClass, t, VK_RValue, OK_Ordinary, t->isDependentType(),
           false, (TInfo->getType()->isInstantiationDependentType() ||
                   e->isInstantiationDependent()),
           (TInfo->getType()->containsUnexpandedParameterPack() ||
            e->containsUnexpandedParameterPack())),
      Val(e), TInfo(TInfo, IsMS), BuiltinLoc(BLoc), RParenLoc(RPLoc) {}

/// Create an empty __builtin_va_arg expression.
explicit VAArgExpr(EmptyShell Empty)
    : Expr(VAArgExprClass, Empty), Val(nullptr), TInfo(nullptr, false) {}

const Expr *getSubExpr() const { return cast<Expr>(Val); }
Expr *getSubExpr() { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

/// Returns whether this is really a Win64 ABI va_arg expression.
bool isMicrosoftABI() const { return TInfo.getInt(); }
void setIsMicrosoftABI(bool IsMS) { TInfo.setInt(IsMS); }

TypeSourceInfo *getWrittenTypeInfo() const { return TInfo.getPointer(); }
void setWrittenTypeInfo(TypeSourceInfo *TI) { TInfo.setPointer(TI); }

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == VAArgExprClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
3917};

3919/// Describes an C or C++ initializer list.
3920///
3921/// InitListExpr describes an initializer list, which can be used to
3922/// initialize objects of different types, including
3923/// struct/class/union types, arrays, and vectors. For example:
3924///
3925/// @code
3926/// struct foo x = { 1, { 2, 3 } };
3927/// @endcode
3928///
3929/// Prior to semantic analysis, an initializer list will represent the
3930/// initializer list as written by the user, but will have the
3931/// placeholder type "void". This initializer list is called the
3932/// syntactic form of the initializer, and may contain C99 designated
3933/// initializers (represented as DesignatedInitExprs), initializations
3934/// of subobject members without explicit braces, and so on. Clients
3935/// interested in the original syntax of the initializer list should
3936/// use the syntactic form of the initializer list.
3937///
3938/// After semantic analysis, the initializer list will represent the
3939/// semantic form of the initializer, where the initializations of all
3940/// subobjects are made explicit with nested InitListExpr nodes and
3941/// C99 designators have been eliminated by placing the designated
3942/// initializations into the subobject they initialize. Additionally,
3943/// any "holes" in the initialization, where no initializer has been
3944/// specified for a particular subobject, will be replaced with
3945/// implicitly-generated ImplicitValueInitExpr expressions that
3946/// value-initialize the subobjects. Note, however, that the
3947/// initializer lists may still have fewer initializers than there are
3948/// elements to initialize within the object.
3949///
3950/// After semantic analysis has completed, given an initializer list,
3951/// method isSemanticForm() returns true if and only if this is the
3952/// semantic form of the initializer list (note: the same AST node
3953/// may at the same time be the syntactic form).
3954/// Given the semantic form of the initializer list, one can retrieve
3955/// the syntactic form of that initializer list (when different)
3956/// using method getSyntacticForm(); the method returns null if applied
3957/// to a initializer list which is already in syntactic form.
3958/// Similarly, given the syntactic form (i.e., an initializer list such
3959/// that isSemanticForm() returns false), one can retrieve the semantic
3960/// form using method getSemanticForm().
3961/// Since many initializer lists have the same syntactic and semantic forms,
3962/// getSyntacticForm() may return NULL, indicating that the current
3963/// semantic initializer list also serves as its syntactic form.
3964class InitListExpr : public Expr {
// FIXME: Eliminate this vector in favor of ASTContext allocation
typedef ASTVector<Stmt *> InitExprsTy;
InitExprsTy InitExprs;
SourceLocation LBraceLoc, RBraceLoc;

/// The alternative form of the initializer list (if it exists).
/// The int part of the pair stores whether this initializer list is
/// in semantic form. If not null, the pointer points to:
///   - the syntactic form, if this is in semantic form;
///   - the semantic form, if this is in syntactic form.
llvm::PointerIntPair<InitListExpr *, 1, bool> AltForm;

/// Either:
///  If this initializer list initializes an array with more elements than
///  there are initializers in the list, specifies an expression to be used
///  for value initialization of the rest of the elements.
/// Or
///  If this initializer list initializes a union, specifies which
///  field within the union will be initialized.
llvm::PointerUnion<Expr *, FieldDecl *> ArrayFillerOrUnionFieldInit;

3986public:
InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
             ArrayRef<Expr*> initExprs, SourceLocation rbraceloc);

/// Build an empty initializer list.
explicit InitListExpr(EmptyShell Empty)
  : Expr(InitListExprClass, Empty), AltForm(nullptr, true) { }

unsigned getNumInits() const { return InitExprs.size(); }

/// Retrieve the set of initializers.
Expr **getInits() { return reinterpret_cast<Expr **>(InitExprs.data()); }

/// Retrieve the set of initializers.
Expr * const *getInits() const {
  return reinterpret_cast<Expr * const *>(InitExprs.data());
}

ArrayRef<Expr *> inits() {
  return llvm::makeArrayRef(getInits(), getNumInits());
}

ArrayRef<Expr *> inits() const {
  return llvm::makeArrayRef(getInits(), getNumInits());
}

const Expr *getInit(unsigned Init) const {
  assert(Init < getNumInits() && "Initializer access out of range!")(static_cast <bool> (Init < getNumInits() &&
 "Initializer access out of range!") ? void (0) : __assert_fail
 ("Init < getNumInits() && \"Initializer access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4013, __extension__ __PRETTY_FUNCTION__));
  return cast_or_null<Expr>(InitExprs[Init]);
}

Expr *getInit(unsigned Init) {
  assert(Init < getNumInits() && "Initializer access out of range!")(static_cast <bool> (Init < getNumInits() &&
 "Initializer access out of range!") ? void (0) : __assert_fail
 ("Init < getNumInits() && \"Initializer access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4018, __extension__ __PRETTY_FUNCTION__));
  return cast_or_null<Expr>(InitExprs[Init]);
}

void setInit(unsigned Init, Expr *expr) {
  assert(Init < getNumInits() && "Initializer access out of range!")(static_cast <bool> (Init < getNumInits() &&
 "Initializer access out of range!") ? void (0) : __assert_fail
 ("Init < getNumInits() && \"Initializer access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4023, __extension__ __PRETTY_FUNCTION__));
  InitExprs[Init] = expr;

  if (expr) {
    ExprBits.TypeDependent |= expr->isTypeDependent();
    ExprBits.ValueDependent |= expr->isValueDependent();
    ExprBits.InstantiationDependent |= expr->isInstantiationDependent();
    ExprBits.ContainsUnexpandedParameterPack |=
        expr->containsUnexpandedParameterPack();
  }
}

/// Reserve space for some number of initializers.
void reserveInits(const ASTContext &C, unsigned NumInits);

/// Specify the number of initializers
///
/// If there are more than @p NumInits initializers, the remaining
/// initializers will be destroyed. If there are fewer than @p
/// NumInits initializers, NULL expressions will be added for the
/// unknown initializers.
void resizeInits(const ASTContext &Context, unsigned NumInits);

/// Updates the initializer at index @p Init with the new
/// expression @p expr, and returns the old expression at that
/// location.
///
/// When @p Init is out of range for this initializer list, the
/// initializer list will be extended with NULL expressions to
/// accommodate the new entry.
Expr *updateInit(const ASTContext &C, unsigned Init, Expr *expr);

/// If this initializer list initializes an array with more elements
/// than there are initializers in the list, specifies an expression to be
/// used for value initialization of the rest of the elements.
Expr *getArrayFiller() {
  return ArrayFillerOrUnionFieldInit.dyn_cast<Expr *>();
}
const Expr *getArrayFiller() const {
  return const_cast<InitListExpr *>(this)->getArrayFiller();
}
void setArrayFiller(Expr *filler);

/// Return true if this is an array initializer and its array "filler"
/// has been set.
bool hasArrayFiller() const { return getArrayFiller(); }

/// If this initializes a union, specifies which field in the
/// union to initialize.
///
/// Typically, this field is the first named field within the
/// union. However, a designated initializer can specify the
/// initialization of a different field within the union.
FieldDecl *getInitializedFieldInUnion() {
  return ArrayFillerOrUnionFieldInit.dyn_cast<FieldDecl *>();
}
const FieldDecl *getInitializedFieldInUnion() const {
  return const_cast<InitListExpr *>(this)->getInitializedFieldInUnion();
}
void setInitializedFieldInUnion(FieldDecl *FD) {
  assert((FD == nullptr(static_cast <bool> ((FD == nullptr || getInitializedFieldInUnion
() == nullptr || getInitializedFieldInUnion() == FD) &&
 "Only one field of a union may be initialized at a time!") ?
 void (0) : __assert_fail ("(FD == nullptr || getInitializedFieldInUnion() == nullptr || getInitializedFieldInUnion() == FD) && \"Only one field of a union may be initialized at a time!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4086, __extension__ __PRETTY_FUNCTION__))
          || getInitializedFieldInUnion() == nullptr(static_cast <bool> ((FD == nullptr || getInitializedFieldInUnion
() == nullptr || getInitializedFieldInUnion() == FD) &&
 "Only one field of a union may be initialized at a time!") ?
 void (0) : __assert_fail ("(FD == nullptr || getInitializedFieldInUnion() == nullptr || getInitializedFieldInUnion() == FD) && \"Only one field of a union may be initialized at a time!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4086, __extension__ __PRETTY_FUNCTION__))
          || getInitializedFieldInUnion() == FD)(static_cast <bool> ((FD == nullptr || getInitializedFieldInUnion
() == nullptr || getInitializedFieldInUnion() == FD) &&
 "Only one field of a union may be initialized at a time!") ?
 void (0) : __assert_fail ("(FD == nullptr || getInitializedFieldInUnion() == nullptr || getInitializedFieldInUnion() == FD) && \"Only one field of a union may be initialized at a time!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4086, __extension__ __PRETTY_FUNCTION__))
         && "Only one field of a union may be initialized at a time!")(static_cast <bool> ((FD == nullptr || getInitializedFieldInUnion
() == nullptr || getInitializedFieldInUnion() == FD) &&
 "Only one field of a union may be initialized at a time!") ?
 void (0) : __assert_fail ("(FD == nullptr || getInitializedFieldInUnion() == nullptr || getInitializedFieldInUnion() == FD) && \"Only one field of a union may be initialized at a time!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4086, __extension__ __PRETTY_FUNCTION__));
  ArrayFillerOrUnionFieldInit = FD;
}

// Explicit InitListExpr's originate from source code (and have valid source
// locations). Implicit InitListExpr's are created by the semantic analyzer.
bool isExplicit() const {
  return LBraceLoc.isValid() && RBraceLoc.isValid();
}

// Is this an initializer for an array of characters, initialized by a string
// literal or an @encode?
bool isStringLiteralInit() const;

/// Is this a transparent initializer list (that is, an InitListExpr that is
/// purely syntactic, and whose semantics are that of the sole contained
/// initializer)?
bool isTransparent() const;

/// Is this the zero initializer {0} in a language which considers it
/// idiomatic?
bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const;

SourceLocation getLBraceLoc() const { return LBraceLoc; }
void setLBraceLoc(SourceLocation Loc) { LBraceLoc = Loc; }
SourceLocation getRBraceLoc() const { return RBraceLoc; }
void setRBraceLoc(SourceLocation Loc) { RBraceLoc = Loc; }

bool isSemanticForm() const { return AltForm.getInt(); }
InitListExpr *getSemanticForm() const {
  return isSemanticForm() ? nullptr : AltForm.getPointer();
}
bool isSyntacticForm() const {
  return !AltForm.getInt() || !AltForm.getPointer();
}
InitListExpr *getSyntacticForm() const {
  return isSemanticForm() ? AltForm.getPointer() : nullptr;
}

void setSyntacticForm(InitListExpr *Init) {
  AltForm.setPointer(Init);
  AltForm.setInt(true);
  Init->AltForm.setPointer(this);
  Init->AltForm.setInt(false);
}

bool hadArrayRangeDesignator() const {
  return InitListExprBits.HadArrayRangeDesignator != 0;
}
void sawArrayRangeDesignator(bool ARD = true) {
  InitListExprBits.HadArrayRangeDesignator = ARD;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == InitListExprClass;
}

// Iterators
child_range children() {
  const_child_range CCR = const_cast<const InitListExpr *>(this)->children();
  return child_range(cast_away_const(CCR.begin()),
                     cast_away_const(CCR.end()));
}

const_child_range children() const {
  // FIXME: This does not include the array filler expression.
  if (InitExprs.empty())
    return const_child_range(const_child_iterator(), const_child_iterator());
  return const_child_range(&InitExprs[0], &InitExprs[0] + InitExprs.size());
}

typedef InitExprsTy::iterator iterator;
typedef InitExprsTy::const_iterator const_iterator;
typedef InitExprsTy::reverse_iterator reverse_iterator;
typedef InitExprsTy::const_reverse_iterator const_reverse_iterator;

iterator begin() { return InitExprs.begin(); }
const_iterator begin() const { return InitExprs.begin(); }
iterator end() { return InitExprs.end(); }
const_iterator end() const { return InitExprs.end(); }
reverse_iterator rbegin() { return InitExprs.rbegin(); }
const_reverse_iterator rbegin() const { return InitExprs.rbegin(); }
reverse_iterator rend() { return InitExprs.rend(); }
const_reverse_iterator rend() const { return InitExprs.rend(); }

friend class ASTStmtReader;
friend class ASTStmtWriter;
4176};

4178/// Represents a C99 designated initializer expression.
4179///
4180/// A designated initializer expression (C99 6.7.8) contains one or
4181/// more designators (which can be field designators, array
4182/// designators, or GNU array-range designators) followed by an
4183/// expression that initializes the field or element(s) that the
4184/// designators refer to. For example, given:
4185///
4186/// @code
4187/// struct point {
4188///   double x;
4189///   double y;
4190/// };
4191/// struct point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 };
4192/// @endcode
4193///
4194/// The InitListExpr contains three DesignatedInitExprs, the first of
4195/// which covers @c [2].y=1.0. This DesignatedInitExpr will have two
4196/// designators, one array designator for @c [2] followed by one field
4197/// designator for @c .y. The initialization expression will be 1.0.
4198class DesignatedInitExpr final
  : public Expr,
    private llvm::TrailingObjects<DesignatedInitExpr, Stmt *> {
4201public:
/// Forward declaration of the Designator class.
class Designator;

4205private:
/// The location of the '=' or ':' prior to the actual initializer
/// expression.
SourceLocation EqualOrColonLoc;

/// Whether this designated initializer used the GNU deprecated
/// syntax rather than the C99 '=' syntax.
unsigned GNUSyntax : 1;

/// The number of designators in this initializer expression.
unsigned NumDesignators : 15;

/// The number of subexpressions of this initializer expression,
/// which contains both the initializer and any additional
/// expressions used by array and array-range designators.
unsigned NumSubExprs : 16;

/// The designators in this designated initialization
/// expression.
Designator *Designators;

DesignatedInitExpr(const ASTContext &C, QualType Ty,
                   llvm::ArrayRef<Designator> Designators,
                   SourceLocation EqualOrColonLoc, bool GNUSyntax,
                   ArrayRef<Expr *> IndexExprs, Expr *Init);

explicit DesignatedInitExpr(unsigned NumSubExprs)
  : Expr(DesignatedInitExprClass, EmptyShell()),
    NumDesignators(0), NumSubExprs(NumSubExprs), Designators(nullptr) { }

4235public:
/// A field designator, e.g., ".x".
struct FieldDesignator {
  /// Refers to the field that is being initialized. The low bit
  /// of this field determines whether this is actually a pointer
  /// to an IdentifierInfo (if 1) or a FieldDecl (if 0). When
  /// initially constructed, a field designator will store an
  /// IdentifierInfo*. After semantic analysis has resolved that
  /// name, the field designator will instead store a FieldDecl*.
  uintptr_t NameOrField;

  /// The location of the '.' in the designated initializer.
  unsigned DotLoc;

  /// The location of the field name in the designated initializer.
  unsigned FieldLoc;
};

/// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
struct ArrayOrRangeDesignator {
  /// Location of the first index expression within the designated
  /// initializer expression's list of subexpressions.
  unsigned Index;
  /// The location of the '[' starting the array range designator.
  unsigned LBracketLoc;
  /// The location of the ellipsis separating the start and end
  /// indices. Only valid for GNU array-range designators.
  unsigned EllipsisLoc;
  /// The location of the ']' terminating the array range designator.
  unsigned RBracketLoc;
};

/// Represents a single C99 designator.
///
/// @todo This class is infuriatingly similar to clang::Designator,
/// but minor differences (storing indices vs. storing pointers)
/// keep us from reusing it. Try harder, later, to rectify these
/// differences.
class Designator {
  /// The kind of designator this describes.
  enum {
    FieldDesignator,
    ArrayDesignator,
    ArrayRangeDesignator
  } Kind;

  union {
    /// A field designator, e.g., ".x".
    struct FieldDesignator Field;
    /// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
    struct ArrayOrRangeDesignator ArrayOrRange;
  };
  friend class DesignatedInitExpr;

public:
  Designator() {}

  /// Initializes a field designator.
  Designator(const IdentifierInfo *FieldName, SourceLocation DotLoc,
             SourceLocation FieldLoc)
    : Kind(FieldDesignator) {
    Field.NameOrField = reinterpret_cast<uintptr_t>(FieldName) | 0x01;
    Field.DotLoc = DotLoc.getRawEncoding();
    Field.FieldLoc = FieldLoc.getRawEncoding();
  }

  /// Initializes an array designator.
  Designator(unsigned Index, SourceLocation LBracketLoc,
             SourceLocation RBracketLoc)
    : Kind(ArrayDesignator) {
    ArrayOrRange.Index = Index;
    ArrayOrRange.LBracketLoc = LBracketLoc.getRawEncoding();
    ArrayOrRange.EllipsisLoc = SourceLocation().getRawEncoding();
    ArrayOrRange.RBracketLoc = RBracketLoc.getRawEncoding();
  }

  /// Initializes a GNU array-range designator.
  Designator(unsigned Index, SourceLocation LBracketLoc,
             SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
    : Kind(ArrayRangeDesignator) {
    ArrayOrRange.Index = Index;
    ArrayOrRange.LBracketLoc = LBracketLoc.getRawEncoding();
    ArrayOrRange.EllipsisLoc = EllipsisLoc.getRawEncoding();
    ArrayOrRange.RBracketLoc = RBracketLoc.getRawEncoding();
  }

  bool isFieldDesignator() const { return Kind == FieldDesignator; }
  bool isArrayDesignator() const { return Kind == ArrayDesignator; }
  bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }

  IdentifierInfo *getFieldName() const;

  FieldDecl *getField() const {
    assert(Kind == FieldDesignator && "Only valid on a field designator")(static_cast <bool> (Kind == FieldDesignator &&
 "Only valid on a field designator") ? void (0) : __assert_fail
 ("Kind == FieldDesignator && \"Only valid on a field designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4328, __extension__ __PRETTY_FUNCTION__));
    if (Field.NameOrField & 0x01)
      return nullptr;
    else
      return reinterpret_cast<FieldDecl *>(Field.NameOrField);
  }

  void setField(FieldDecl *FD) {
    assert(Kind == FieldDesignator && "Only valid on a field designator")(static_cast <bool> (Kind == FieldDesignator &&
 "Only valid on a field designator") ? void (0) : __assert_fail
 ("Kind == FieldDesignator && \"Only valid on a field designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4336, __extension__ __PRETTY_FUNCTION__));
    Field.NameOrField = reinterpret_cast<uintptr_t>(FD);
  }

  SourceLocation getDotLoc() const {
    assert(Kind == FieldDesignator && "Only valid on a field designator")(static_cast <bool> (Kind == FieldDesignator &&
 "Only valid on a field designator") ? void (0) : __assert_fail
 ("Kind == FieldDesignator && \"Only valid on a field designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4341, __extension__ __PRETTY_FUNCTION__));
    return SourceLocation::getFromRawEncoding(Field.DotLoc);
  }

  SourceLocation getFieldLoc() const {
    assert(Kind == FieldDesignator && "Only valid on a field designator")(static_cast <bool> (Kind == FieldDesignator &&
 "Only valid on a field designator") ? void (0) : __assert_fail
 ("Kind == FieldDesignator && \"Only valid on a field designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4346, __extension__ __PRETTY_FUNCTION__));
    return SourceLocation::getFromRawEncoding(Field.FieldLoc);
  }

  SourceLocation getLBracketLoc() const {
    assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&(static_cast <bool> ((Kind == ArrayDesignator || Kind ==
 ArrayRangeDesignator) && "Only valid on an array or array-range designator"
) ? void (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4352, __extension__ __PRETTY_FUNCTION__))
           "Only valid on an array or array-range designator")(static_cast <bool> ((Kind == ArrayDesignator || Kind ==
 ArrayRangeDesignator) && "Only valid on an array or array-range designator"
) ? void (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4352, __extension__ __PRETTY_FUNCTION__));
    return SourceLocation::getFromRawEncoding(ArrayOrRange.LBracketLoc);
  }

  SourceLocation getRBracketLoc() const {
    assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&(static_cast <bool> ((Kind == ArrayDesignator || Kind ==
 ArrayRangeDesignator) && "Only valid on an array or array-range designator"
) ? void (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4358, __extension__ __PRETTY_FUNCTION__))
           "Only valid on an array or array-range designator")(static_cast <bool> ((Kind == ArrayDesignator || Kind ==
 ArrayRangeDesignator) && "Only valid on an array or array-range designator"
) ? void (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4358, __extension__ __PRETTY_FUNCTION__));
    return SourceLocation::getFromRawEncoding(ArrayOrRange.RBracketLoc);
  }

  SourceLocation getEllipsisLoc() const {
    assert(Kind == ArrayRangeDesignator &&(static_cast <bool> (Kind == ArrayRangeDesignator &&
 "Only valid on an array-range designator") ? void (0) : __assert_fail
 ("Kind == ArrayRangeDesignator && \"Only valid on an array-range designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4364, __extension__ __PRETTY_FUNCTION__))
           "Only valid on an array-range designator")(static_cast <bool> (Kind == ArrayRangeDesignator &&
 "Only valid on an array-range designator") ? void (0) : __assert_fail
 ("Kind == ArrayRangeDesignator && \"Only valid on an array-range designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4364, __extension__ __PRETTY_FUNCTION__));
    return SourceLocation::getFromRawEncoding(ArrayOrRange.EllipsisLoc);
  }

  unsigned getFirstExprIndex() const {
    assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&(static_cast <bool> ((Kind == ArrayDesignator || Kind ==
 ArrayRangeDesignator) && "Only valid on an array or array-range designator"
) ? void (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4370, __extension__ __PRETTY_FUNCTION__))
           "Only valid on an array or array-range designator")(static_cast <bool> ((Kind == ArrayDesignator || Kind ==
 ArrayRangeDesignator) && "Only valid on an array or array-range designator"
) ? void (0) : __assert_fail ("(Kind == ArrayDesignator || Kind == ArrayRangeDesignator) && \"Only valid on an array or array-range designator\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4370, __extension__ __PRETTY_FUNCTION__));
    return ArrayOrRange.Index;
  }

  SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
    if (Kind == FieldDesignator)
      return getDotLoc().isInvalid()? getFieldLoc() : getDotLoc();
    else
      return getLBracketLoc();
  }
  SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
    return Kind == FieldDesignator ? getFieldLoc() : getRBracketLoc();
  }
  SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
    return SourceRange(getLocStart(), getLocEnd());
  }
};

static DesignatedInitExpr *Create(const ASTContext &C,
                                  llvm::ArrayRef<Designator> Designators,
                                  ArrayRef<Expr*> IndexExprs,
                                  SourceLocation EqualOrColonLoc,
                                  bool GNUSyntax, Expr *Init);

static DesignatedInitExpr *CreateEmpty(const ASTContext &C,
                                       unsigned NumIndexExprs);

/// Returns the number of designators in this initializer.
unsigned size() const { return NumDesignators; }

// Iterator access to the designators.
llvm::MutableArrayRef<Designator> designators() {
  return {Designators, NumDesignators};
}

llvm::ArrayRef<Designator> designators() const {
  return {Designators, NumDesignators};
}

Designator *getDesignator(unsigned Idx) { return &designators()[Idx]; }
const Designator *getDesignator(unsigned Idx) const {
  return &designators()[Idx];
}

void setDesignators(const ASTContext &C, const Designator *Desigs,
                    unsigned NumDesigs);

Expr *getArrayIndex(const Designator &D) const;
Expr *getArrayRangeStart(const Designator &D) const;
Expr *getArrayRangeEnd(const Designator &D) const;

/// Retrieve the location of the '=' that precedes the
/// initializer value itself, if present.
SourceLocation getEqualOrColonLoc() const { return EqualOrColonLoc; }
void setEqualOrColonLoc(SourceLocation L) { EqualOrColonLoc = L; }

/// Determines whether this designated initializer used the
/// deprecated GNU syntax for designated initializers.
bool usesGNUSyntax() const { return GNUSyntax; }
void setGNUSyntax(bool GNU) { GNUSyntax = GNU; }

/// Retrieve the initializer value.
Expr *getInit() const {
  return cast<Expr>(*const_cast<DesignatedInitExpr*>(this)->child_begin());
}

void setInit(Expr *init) {
  *child_begin() = init;
}

/// Retrieve the total number of subexpressions in this
/// designated initializer expression, including the actual
/// initialized value and any expressions that occur within array
/// and array-range designators.
unsigned getNumSubExprs() const { return NumSubExprs; }

Expr *getSubExpr(unsigned Idx) const {
  assert(Idx < NumSubExprs && "Subscript out of range")(static_cast <bool> (Idx < NumSubExprs && "Subscript out of range"
) ? void (0) : __assert_fail ("Idx < NumSubExprs && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4447, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(getTrailingObjects<Stmt *>()[Idx]);
}

void setSubExpr(unsigned Idx, Expr *E) {
  assert(Idx < NumSubExprs && "Subscript out of range")(static_cast <bool> (Idx < NumSubExprs && "Subscript out of range"
) ? void (0) : __assert_fail ("Idx < NumSubExprs && \"Subscript out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4452, __extension__ __PRETTY_FUNCTION__));
  getTrailingObjects<Stmt *>()[Idx] = E;
}

/// Replaces the designator at index @p Idx with the series
/// of designators in [First, Last).
void ExpandDesignator(const ASTContext &C, unsigned Idx,
                      const Designator *First, const Designator *Last);

SourceRange getDesignatorsSourceRange() const;

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DesignatedInitExprClass;
}

// Iterators
child_range children() {
  Stmt **begin = getTrailingObjects<Stmt *>();
  return child_range(begin, begin + NumSubExprs);
}
const_child_range children() const {
  Stmt * const *begin = getTrailingObjects<Stmt *>();
  return const_child_range(begin, begin + NumSubExprs);
}

friend TrailingObjects;
4481};

4483/// Represents a place-holder for an object not to be initialized by
4484/// anything.
4485///
4486/// This only makes sense when it appears as part of an updater of a
4487/// DesignatedInitUpdateExpr (see below). The base expression of a DIUE
4488/// initializes a big object, and the NoInitExpr's mark the spots within the
4489/// big object not to be overwritten by the updater.
4490///
4491/// \see DesignatedInitUpdateExpr
4492class NoInitExpr : public Expr {
4493public:
explicit NoInitExpr(QualType ty)
  : Expr(NoInitExprClass, ty, VK_RValue, OK_Ordinary,
         false, false, ty->isInstantiationDependentType(), false) { }

explicit NoInitExpr(EmptyShell Empty)
  : Expr(NoInitExprClass, Empty) { }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == NoInitExprClass;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
4515};

4517// In cases like:
4518//   struct Q { int a, b, c; };
4519//   Q *getQ();
4520//   void foo() {
4521//     struct A { Q q; } a = { *getQ(), .q.b = 3 };
4522//   }
4523//
4524// We will have an InitListExpr for a, with type A, and then a
4525// DesignatedInitUpdateExpr for "a.q" with type Q. The "base" for this DIUE
4526// is the call expression *getQ(); the "updater" for the DIUE is ".q.b = 3"
4527//
4528class DesignatedInitUpdateExpr : public Expr {
// BaseAndUpdaterExprs[0] is the base expression;
// BaseAndUpdaterExprs[1] is an InitListExpr overwriting part of the base.
Stmt *BaseAndUpdaterExprs[2];

4533public:
DesignatedInitUpdateExpr(const ASTContext &C, SourceLocation lBraceLoc,
                         Expr *baseExprs, SourceLocation rBraceLoc);

explicit DesignatedInitUpdateExpr(EmptyShell Empty)
  : Expr(DesignatedInitUpdateExprClass, Empty) { }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DesignatedInitUpdateExprClass;
}

Expr *getBase() const { return cast<Expr>(BaseAndUpdaterExprs[0]); }
void setBase(Expr *Base) { BaseAndUpdaterExprs[0] = Base; }

InitListExpr *getUpdater() const {
  return cast<InitListExpr>(BaseAndUpdaterExprs[1]);
}
void setUpdater(Expr *Updater) { BaseAndUpdaterExprs[1] = Updater; }

// Iterators
// children = the base and the updater
child_range children() {
  return child_range(&BaseAndUpdaterExprs[0], &BaseAndUpdaterExprs[0] + 2);
}
const_child_range children() const {
  return const_child_range(&BaseAndUpdaterExprs[0],
                           &BaseAndUpdaterExprs[0] + 2);
}
4564};

4566/// Represents a loop initializing the elements of an array.
4567///
4568/// The need to initialize the elements of an array occurs in a number of
4569/// contexts:
4570///
4571///  * in the implicit copy/move constructor for a class with an array member
4572///  * when a lambda-expression captures an array by value
4573///  * when a decomposition declaration decomposes an array
4574///
4575/// There are two subexpressions: a common expression (the source array)
4576/// that is evaluated once up-front, and a per-element initializer that
4577/// runs once for each array element.
4578///
4579/// Within the per-element initializer, the common expression may be referenced
4580/// via an OpaqueValueExpr, and the current index may be obtained via an
4581/// ArrayInitIndexExpr.
4582class ArrayInitLoopExpr : public Expr {
Stmt *SubExprs[2];

explicit ArrayInitLoopExpr(EmptyShell Empty)
    : Expr(ArrayInitLoopExprClass, Empty), SubExprs{} {}

4588public:
explicit ArrayInitLoopExpr(QualType T, Expr *CommonInit, Expr *ElementInit)
    : Expr(ArrayInitLoopExprClass, T, VK_RValue, OK_Ordinary, false,
           CommonInit->isValueDependent() || ElementInit->isValueDependent(),
22
←
Assuming the condition is false→
23
←
Called C++ object pointer is null
           T->isInstantiationDependentType(),
           CommonInit->containsUnexpandedParameterPack() ||
               ElementInit->containsUnexpandedParameterPack()),
      SubExprs{CommonInit, ElementInit} {}

/// Get the common subexpression shared by all initializations (the source
/// array).
OpaqueValueExpr *getCommonExpr() const {
  return cast<OpaqueValueExpr>(SubExprs[0]);
}

/// Get the initializer to use for each array element.
Expr *getSubExpr() const { return cast<Expr>(SubExprs[1]); }

llvm::APInt getArraySize() const {
  return cast<ConstantArrayType>(getType()->castAsArrayTypeUnsafe())
      ->getSize();
}

static bool classof(const Stmt *S) {
  return S->getStmtClass() == ArrayInitLoopExprClass;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getCommonExpr()->getLocStart();
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return getCommonExpr()->getLocEnd();
}

child_range children() {
  return child_range(SubExprs, SubExprs + 2);
}
const_child_range children() const {
  return const_child_range(SubExprs, SubExprs + 2);
}

friend class ASTReader;
friend class ASTStmtReader;
friend class ASTStmtWriter;
4632};

4634/// Represents the index of the current element of an array being
4635/// initialized by an ArrayInitLoopExpr. This can only appear within the
4636/// subexpression of an ArrayInitLoopExpr.
4637class ArrayInitIndexExpr : public Expr {
explicit ArrayInitIndexExpr(EmptyShell Empty)
    : Expr(ArrayInitIndexExprClass, Empty) {}

4641public:
explicit ArrayInitIndexExpr(QualType T)
    : Expr(ArrayInitIndexExprClass, T, VK_RValue, OK_Ordinary,
           false, false, false, false) {}

static bool classof(const Stmt *S) {
  return S->getStmtClass() == ArrayInitIndexExprClass;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

friend class ASTReader;
friend class ASTStmtReader;
4662};

4664/// Represents an implicitly-generated value initialization of
4665/// an object of a given type.
4666///
4667/// Implicit value initializations occur within semantic initializer
4668/// list expressions (InitListExpr) as placeholders for subobject
4669/// initializations not explicitly specified by the user.
4670///
4671/// \see InitListExpr
4672class ImplicitValueInitExpr : public Expr {
4673public:
explicit ImplicitValueInitExpr(QualType ty)
  : Expr(ImplicitValueInitExprClass, ty, VK_RValue, OK_Ordinary,
         false, false, ty->isInstantiationDependentType(), false) { }

/// Construct an empty implicit value initialization.
explicit ImplicitValueInitExpr(EmptyShell Empty)
  : Expr(ImplicitValueInitExprClass, Empty) { }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ImplicitValueInitExprClass;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
4696};

4698class ParenListExpr : public Expr {
Stmt **Exprs;
unsigned NumExprs;
SourceLocation LParenLoc, RParenLoc;

4703public:
ParenListExpr(const ASTContext& C, SourceLocation lparenloc,
              ArrayRef<Expr*> exprs, SourceLocation rparenloc);

/// Build an empty paren list.
explicit ParenListExpr(EmptyShell Empty) : Expr(ParenListExprClass, Empty) { }

unsigned getNumExprs() const { return NumExprs; }

const Expr* getExpr(unsigned Init) const {
  assert(Init < getNumExprs() && "Initializer access out of range!")(static_cast <bool> (Init < getNumExprs() &&
 "Initializer access out of range!") ? void (0) : __assert_fail
 ("Init < getNumExprs() && \"Initializer access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4713, __extension__ __PRETTY_FUNCTION__));
  return cast_or_null<Expr>(Exprs[Init]);
}

Expr* getExpr(unsigned Init) {
  assert(Init < getNumExprs() && "Initializer access out of range!")(static_cast <bool> (Init < getNumExprs() &&
 "Initializer access out of range!") ? void (0) : __assert_fail
 ("Init < getNumExprs() && \"Initializer access out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4718, __extension__ __PRETTY_FUNCTION__));
  return cast_or_null<Expr>(Exprs[Init]);
}

Expr **getExprs() { return reinterpret_cast<Expr **>(Exprs); }

ArrayRef<Expr *> exprs() {
  return llvm::makeArrayRef(getExprs(), getNumExprs());
}

SourceLocation getLParenLoc() const { return LParenLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return LParenLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ParenListExprClass;
}

// Iterators
child_range children() {
  return child_range(&Exprs[0], &Exprs[0]+NumExprs);
}
const_child_range children() const {
  return const_child_range(&Exprs[0], &Exprs[0] + NumExprs);
}

friend class ASTStmtReader;
friend class ASTStmtWriter;
4748};

4750/// Represents a C11 generic selection.
4751///
4752/// A generic selection (C11 6.5.1.1) contains an unevaluated controlling
4753/// expression, followed by one or more generic associations.  Each generic
4754/// association specifies a type name and an expression, or "default" and an
4755/// expression (in which case it is known as a default generic association).
4756/// The type and value of the generic selection are identical to those of its
4757/// result expression, which is defined as the expression in the generic
4758/// association with a type name that is compatible with the type of the
4759/// controlling expression, or the expression in the default generic association
4760/// if no types are compatible.  For example:
4761///
4762/// @code
4763/// _Generic(X, double: 1, float: 2, default: 3)
4764/// @endcode
4765///
4766/// The above expression evaluates to 1 if 1.0 is substituted for X, 2 if 1.0f
4767/// or 3 if "hello".
4768///
4769/// As an extension, generic selections are allowed in C++, where the following
4770/// additional semantics apply:
4771///
4772/// Any generic selection whose controlling expression is type-dependent or
4773/// which names a dependent type in its association list is result-dependent,
4774/// which means that the choice of result expression is dependent.
4775/// Result-dependent generic associations are both type- and value-dependent.
4776class GenericSelectionExpr : public Expr {
enum { CONTROLLING, END_EXPR };
TypeSourceInfo **AssocTypes;
Stmt **SubExprs;
unsigned NumAssocs, ResultIndex;
SourceLocation GenericLoc, DefaultLoc, RParenLoc;

4783public:
GenericSelectionExpr(const ASTContext &Context,
                     SourceLocation GenericLoc, Expr *ControllingExpr,
                     ArrayRef<TypeSourceInfo*> AssocTypes,
                     ArrayRef<Expr*> AssocExprs,
                     SourceLocation DefaultLoc, SourceLocation RParenLoc,
                     bool ContainsUnexpandedParameterPack,
                     unsigned ResultIndex);

/// This constructor is used in the result-dependent case.
GenericSelectionExpr(const ASTContext &Context,
                     SourceLocation GenericLoc, Expr *ControllingExpr,
                     ArrayRef<TypeSourceInfo*> AssocTypes,
                     ArrayRef<Expr*> AssocExprs,
                     SourceLocation DefaultLoc, SourceLocation RParenLoc,
                     bool ContainsUnexpandedParameterPack);

explicit GenericSelectionExpr(EmptyShell Empty)
  : Expr(GenericSelectionExprClass, Empty) { }

unsigned getNumAssocs() const { return NumAssocs; }

SourceLocation getGenericLoc() const { return GenericLoc; }
SourceLocation getDefaultLoc() const { return DefaultLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }

const Expr *getAssocExpr(unsigned i) const {
  return cast<Expr>(SubExprs[END_EXPR+i]);
}
Expr *getAssocExpr(unsigned i) { return cast<Expr>(SubExprs[END_EXPR+i]); }
ArrayRef<Expr *> getAssocExprs() const {
  return NumAssocs
             ? llvm::makeArrayRef(
                   &reinterpret_cast<Expr **>(SubExprs)[END_EXPR], NumAssocs)
             : None;
}
const TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) const {
  return AssocTypes[i];
}
TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) { return AssocTypes[i]; }
ArrayRef<TypeSourceInfo *> getAssocTypeSourceInfos() const {
  return NumAssocs ? llvm::makeArrayRef(&AssocTypes[0], NumAssocs) : None;
}

QualType getAssocType(unsigned i) const {
  if (const TypeSourceInfo *TS = getAssocTypeSourceInfo(i))
    return TS->getType();
  else
    return QualType();
}

const Expr *getControllingExpr() const {
  return cast<Expr>(SubExprs[CONTROLLING]);
}
Expr *getControllingExpr() { return cast<Expr>(SubExprs[CONTROLLING]); }

/// Whether this generic selection is result-dependent.
bool isResultDependent() const { return ResultIndex == -1U; }

/// The zero-based index of the result expression's generic association in
/// the generic selection's association list.  Defined only if the
/// generic selection is not result-dependent.
unsigned getResultIndex() const {
  assert(!isResultDependent() && "Generic selection is result-dependent")(static_cast <bool> (!isResultDependent() && "Generic selection is result-dependent"
) ? void (0) : __assert_fail ("!isResultDependent() && \"Generic selection is result-dependent\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 4846, __extension__ __PRETTY_FUNCTION__));
  return ResultIndex;
}

/// The generic selection's result expression.  Defined only if the
/// generic selection is not result-dependent.
const Expr *getResultExpr() const { return getAssocExpr(getResultIndex()); }
Expr *getResultExpr() { return getAssocExpr(getResultIndex()); }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return GenericLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == GenericSelectionExprClass;
}

child_range children() {
  return child_range(SubExprs, SubExprs+END_EXPR+NumAssocs);
}
const_child_range children() const {
  return const_child_range(SubExprs, SubExprs + END_EXPR + NumAssocs);
}
friend class ASTStmtReader;
4869};

4871//===----------------------------------------------------------------------===//
4872// Clang Extensions
4873//===----------------------------------------------------------------------===//

4875/// ExtVectorElementExpr - This represents access to specific elements of a
4876/// vector, and may occur on the left hand side or right hand side.  For example
4877/// the following is legal:  "V.xy = V.zw" if V is a 4 element extended vector.
4878///
4879/// Note that the base may have either vector or pointer to vector type, just
4880/// like a struct field reference.
4881///
4882class ExtVectorElementExpr : public Expr {
Stmt *Base;
IdentifierInfo *Accessor;
SourceLocation AccessorLoc;
4886public:
ExtVectorElementExpr(QualType ty, ExprValueKind VK, Expr *base,
                     IdentifierInfo &accessor, SourceLocation loc)
  : Expr(ExtVectorElementExprClass, ty, VK,
         (VK == VK_RValue ? OK_Ordinary : OK_VectorComponent),
         base->isTypeDependent(), base->isValueDependent(),
         base->isInstantiationDependent(),
         base->containsUnexpandedParameterPack()),
    Base(base), Accessor(&accessor), AccessorLoc(loc) {}

/// Build an empty vector element expression.
explicit ExtVectorElementExpr(EmptyShell Empty)
  : Expr(ExtVectorElementExprClass, Empty) { }

const Expr *getBase() const { return cast<Expr>(Base); }
Expr *getBase() { return cast<Expr>(Base); }
void setBase(Expr *E) { Base = E; }

IdentifierInfo &getAccessor() const { return *Accessor; }
void setAccessor(IdentifierInfo *II) { Accessor = II; }

SourceLocation getAccessorLoc() const { return AccessorLoc; }
void setAccessorLoc(SourceLocation L) { AccessorLoc = L; }

/// getNumElements - Get the number of components being selected.
unsigned getNumElements() const;

/// containsDuplicateElements - Return true if any element access is
/// repeated.
bool containsDuplicateElements() const;

/// getEncodedElementAccess - Encode the elements accessed into an llvm
/// aggregate Constant of ConstantInt(s).
void getEncodedElementAccess(SmallVectorImpl<uint32_t> &Elts) const;

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->getLocStart();
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return AccessorLoc; }

/// isArrow - Return true if the base expression is a pointer to vector,
/// return false if the base expression is a vector.
bool isArrow() const;

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ExtVectorElementExprClass;
}

// Iterators
child_range children() { return child_range(&Base, &Base+1); }
const_child_range children() const {
  return const_child_range(&Base, &Base + 1);
}
4939};

4941/// BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
4942/// ^{ statement-body }   or   ^(int arg1, float arg2){ statement-body }
4943class BlockExpr : public Expr {
4944protected:
BlockDecl *TheBlock;
4946public:
BlockExpr(BlockDecl *BD, QualType ty)
  : Expr(BlockExprClass, ty, VK_RValue, OK_Ordinary,
         ty->isDependentType(), ty->isDependentType(),
         ty->isInstantiationDependentType() || BD->isDependentContext(),
         false),
    TheBlock(BD) {}

/// Build an empty block expression.
explicit BlockExpr(EmptyShell Empty) : Expr(BlockExprClass, Empty) { }

const BlockDecl *getBlockDecl() const { return TheBlock; }
BlockDecl *getBlockDecl() { return TheBlock; }
void setBlockDecl(BlockDecl *BD) { TheBlock = BD; }

// Convenience functions for probing the underlying BlockDecl.
SourceLocation getCaretLocation() const;
const Stmt *getBody() const;
Stmt *getBody();

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return getCaretLocation(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return getBody()->getLocEnd(); }

/// getFunctionType - Return the underlying function type for this block.
const FunctionProtoType *getFunctionType() const;

static bool classof(const Stmt *T) {
  return T->getStmtClass() == BlockExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
4983};

4985/// AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2]
4986/// This AST node provides support for reinterpreting a type to another
4987/// type of the same size.
4988class AsTypeExpr : public Expr {
4989private:
Stmt *SrcExpr;
SourceLocation BuiltinLoc, RParenLoc;

friend class ASTReader;
friend class ASTStmtReader;
explicit AsTypeExpr(EmptyShell Empty) : Expr(AsTypeExprClass, Empty) {}

4997public:
AsTypeExpr(Expr* SrcExpr, QualType DstType,
           ExprValueKind VK, ExprObjectKind OK,
           SourceLocation BuiltinLoc, SourceLocation RParenLoc)
  : Expr(AsTypeExprClass, DstType, VK, OK,
         DstType->isDependentType(),
         DstType->isDependentType() || SrcExpr->isValueDependent(),
         (DstType->isInstantiationDependentType() ||
          SrcExpr->isInstantiationDependent()),
         (DstType->containsUnexpandedParameterPack() ||
          SrcExpr->containsUnexpandedParameterPack())),
SrcExpr(SrcExpr), BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {}

/// getSrcExpr - Return the Expr to be converted.
Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }

/// getBuiltinLoc - Return the location of the __builtin_astype token.
SourceLocation getBuiltinLoc() const { return BuiltinLoc; }

/// getRParenLoc - Return the location of final right parenthesis.
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == AsTypeExprClass;
}

// Iterators
child_range children() { return child_range(&SrcExpr, &SrcExpr+1); }
const_child_range children() const {
  return const_child_range(&SrcExpr, &SrcExpr + 1);
}
5031};

5033/// PseudoObjectExpr - An expression which accesses a pseudo-object
5034/// l-value.  A pseudo-object is an abstract object, accesses to which
5035/// are translated to calls.  The pseudo-object expression has a
5036/// syntactic form, which shows how the expression was actually
5037/// written in the source code, and a semantic form, which is a series
5038/// of expressions to be executed in order which detail how the
5039/// operation is actually evaluated.  Optionally, one of the semantic
5040/// forms may also provide a result value for the expression.
5041///
5042/// If any of the semantic-form expressions is an OpaqueValueExpr,
5043/// that OVE is required to have a source expression, and it is bound
5044/// to the result of that source expression.  Such OVEs may appear
5045/// only in subsequent semantic-form expressions and as
5046/// sub-expressions of the syntactic form.
5047///
5048/// PseudoObjectExpr should be used only when an operation can be
5049/// usefully described in terms of fairly simple rewrite rules on
5050/// objects and functions that are meant to be used by end-developers.
5051/// For example, under the Itanium ABI, dynamic casts are implemented
5052/// as a call to a runtime function called __dynamic_cast; using this
5053/// class to describe that would be inappropriate because that call is
5054/// not really part of the user-visible semantics, and instead the
5055/// cast is properly reflected in the AST and IR-generation has been
5056/// taught to generate the call as necessary.  In contrast, an
5057/// Objective-C property access is semantically defined to be
5058/// equivalent to a particular message send, and this is very much
5059/// part of the user model.  The name of this class encourages this
5060/// modelling design.
5061class PseudoObjectExpr final
  : public Expr,
    private llvm::TrailingObjects<PseudoObjectExpr, Expr *> {
// PseudoObjectExprBits.NumSubExprs - The number of sub-expressions.
// Always at least two, because the first sub-expression is the
// syntactic form.

// PseudoObjectExprBits.ResultIndex - The index of the
// sub-expression holding the result.  0 means the result is void,
// which is unambiguous because it's the index of the syntactic
// form.  Note that this is therefore 1 higher than the value passed
// in to Create, which is an index within the semantic forms.
// Note also that ASTStmtWriter assumes this encoding.

Expr **getSubExprsBuffer() { return getTrailingObjects<Expr *>(); }
const Expr * const *getSubExprsBuffer() const {
  return getTrailingObjects<Expr *>();
}

PseudoObjectExpr(QualType type, ExprValueKind VK,
                 Expr *syntactic, ArrayRef<Expr*> semantic,
                 unsigned resultIndex);

PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs);

unsigned getNumSubExprs() const {
  return PseudoObjectExprBits.NumSubExprs;
}

5090public:
/// NoResult - A value for the result index indicating that there is
/// no semantic result.
enum : unsigned { NoResult = ~0U };

static PseudoObjectExpr *Create(const ASTContext &Context, Expr *syntactic,
                                ArrayRef<Expr*> semantic,
                                unsigned resultIndex);

static PseudoObjectExpr *Create(const ASTContext &Context, EmptyShell shell,
                                unsigned numSemanticExprs);

/// Return the syntactic form of this expression, i.e. the
/// expression it actually looks like.  Likely to be expressed in
/// terms of OpaqueValueExprs bound in the semantic form.
Expr *getSyntacticForm() { return getSubExprsBuffer()[0]; }
const Expr *getSyntacticForm() const { return getSubExprsBuffer()[0]; }

/// Return the index of the result-bearing expression into the semantics
/// expressions, or PseudoObjectExpr::NoResult if there is none.
unsigned getResultExprIndex() const {
  if (PseudoObjectExprBits.ResultIndex == 0) return NoResult;
  return PseudoObjectExprBits.ResultIndex - 1;
}

/// Return the result-bearing expression, or null if there is none.
Expr *getResultExpr() {
  if (PseudoObjectExprBits.ResultIndex == 0)
    return nullptr;
  return getSubExprsBuffer()[PseudoObjectExprBits.ResultIndex];
}
const Expr *getResultExpr() const {
  return const_cast<PseudoObjectExpr*>(this)->getResultExpr();
}

unsigned getNumSemanticExprs() const { return getNumSubExprs() - 1; }

typedef Expr * const *semantics_iterator;
typedef const Expr * const *const_semantics_iterator;
semantics_iterator semantics_begin() {
  return getSubExprsBuffer() + 1;
}
const_semantics_iterator semantics_begin() const {
  return getSubExprsBuffer() + 1;
}
semantics_iterator semantics_end() {
  return getSubExprsBuffer() + getNumSubExprs();
}
const_semantics_iterator semantics_end() const {
  return getSubExprsBuffer() + getNumSubExprs();
}

llvm::iterator_range<semantics_iterator> semantics() {
  return llvm::make_range(semantics_begin(), semantics_end());
}
llvm::iterator_range<const_semantics_iterator> semantics() const {
  return llvm::make_range(semantics_begin(), semantics_end());
}

Expr *getSemanticExpr(unsigned index) {
  assert(index + 1 < getNumSubExprs())(static_cast <bool> (index + 1 < getNumSubExprs()) ?
 void (0) : __assert_fail ("index + 1 < getNumSubExprs()",
 "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 5150, __extension__ __PRETTY_FUNCTION__));
  return getSubExprsBuffer()[index + 1];
}
const Expr *getSemanticExpr(unsigned index) const {
  return const_cast<PseudoObjectExpr*>(this)->getSemanticExpr(index);
}

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSyntacticForm()->getExprLoc();
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getSyntacticForm()->getLocStart();
}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return getSyntacticForm()->getLocEnd();
}

child_range children() {
  const_child_range CCR =
      const_cast<const PseudoObjectExpr *>(this)->children();
  return child_range(cast_away_const(CCR.begin()),
                     cast_away_const(CCR.end()));
}
const_child_range children() const {
  Stmt *const *cs = const_cast<Stmt *const *>(
      reinterpret_cast<const Stmt *const *>(getSubExprsBuffer()));
  return const_child_range(cs, cs + getNumSubExprs());
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == PseudoObjectExprClass;
}

friend TrailingObjects;
friend class ASTStmtReader;
5186};

5188/// AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*,
5189/// __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the
5190/// similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>,
5191/// and corresponding __opencl_atomic_* for OpenCL 2.0.
5192/// All of these instructions take one primary pointer, at least one memory
5193/// order. The instructions for which getScopeModel returns non-null value
5194/// take one synch scope.
5195class AtomicExpr : public Expr {
5196public:
enum AtomicOp {
5198#define BUILTIN(ID, TYPE, ATTRS)
5199#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) AO ## ID,
5200#include "clang/Basic/Builtins.def"
  // Avoid trailing comma
  BI_First = 0
};

5205private:
/// Location of sub-expressions.
/// The location of Scope sub-expression is NumSubExprs - 1, which is
/// not fixed, therefore is not defined in enum.
enum { PTR, ORDER, VAL1, ORDER_FAIL, VAL2, WEAK, END_EXPR };
Stmt *SubExprs[END_EXPR + 1];
unsigned NumSubExprs;
SourceLocation BuiltinLoc, RParenLoc;
AtomicOp Op;

friend class ASTStmtReader;
5216public:
AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args, QualType t,
           AtomicOp op, SourceLocation RP);

/// Determine the number of arguments the specified atomic builtin
/// should have.
static unsigned getNumSubExprs(AtomicOp Op);

/// Build an empty AtomicExpr.
explicit AtomicExpr(EmptyShell Empty) : Expr(AtomicExprClass, Empty) { }

Expr *getPtr() const {
  return cast<Expr>(SubExprs[PTR]);
}
Expr *getOrder() const {
  return cast<Expr>(SubExprs[ORDER]);
}
Expr *getScope() const {
  assert(getScopeModel() && "No scope")(static_cast <bool> (getScopeModel() && "No scope"
) ? void (0) : __assert_fail ("getScopeModel() && \"No scope\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 5234, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[NumSubExprs - 1]);
}
Expr *getVal1() const {
  if (Op == AO__c11_atomic_init || Op == AO__opencl_atomic_init)
    return cast<Expr>(SubExprs[ORDER]);
  assert(NumSubExprs > VAL1)(static_cast <bool> (NumSubExprs > VAL1) ? void (0) :
 __assert_fail ("NumSubExprs > VAL1", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 5240, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[VAL1]);
}
Expr *getOrderFail() const {
  assert(NumSubExprs > ORDER_FAIL)(static_cast <bool> (NumSubExprs > ORDER_FAIL) ? void
 (0) : __assert_fail ("NumSubExprs > ORDER_FAIL", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 5244, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[ORDER_FAIL]);
}
Expr *getVal2() const {
  if (Op == AO__atomic_exchange)
    return cast<Expr>(SubExprs[ORDER_FAIL]);
  assert(NumSubExprs > VAL2)(static_cast <bool> (NumSubExprs > VAL2) ? void (0) :
 __assert_fail ("NumSubExprs > VAL2", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 5250, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[VAL2]);
}
Expr *getWeak() const {
  assert(NumSubExprs > WEAK)(static_cast <bool> (NumSubExprs > WEAK) ? void (0) :
 __assert_fail ("NumSubExprs > WEAK", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 5254, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(SubExprs[WEAK]);
}
QualType getValueType() const;

AtomicOp getOp() const { return Op; }
unsigned getNumSubExprs() const { return NumSubExprs; }

Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }
const Expr * const *getSubExprs() const {
  return reinterpret_cast<Expr * const *>(SubExprs);
}

bool isVolatile() const {
  return getPtr()->getType()->getPointeeType().isVolatileQualified();
}

bool isCmpXChg() const {
  return getOp() == AO__c11_atomic_compare_exchange_strong ||
         getOp() == AO__c11_atomic_compare_exchange_weak ||
         getOp() == AO__opencl_atomic_compare_exchange_strong ||
         getOp() == AO__opencl_atomic_compare_exchange_weak ||
         getOp() == AO__atomic_compare_exchange ||
         getOp() == AO__atomic_compare_exchange_n;
}

bool isOpenCL() const {
  return getOp() >= AO__opencl_atomic_init &&
         getOp() <= AO__opencl_atomic_fetch_max;
}

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == AtomicExprClass;
}

// Iterators
child_range children() {
  return child_range(SubExprs, SubExprs+NumSubExprs);
}
const_child_range children() const {
  return const_child_range(SubExprs, SubExprs + NumSubExprs);
}

/// Get atomic scope model for the atomic op code.
/// \return empty atomic scope model if the atomic op code does not have
///   scope operand.
static std::unique_ptr<AtomicScopeModel> getScopeModel(AtomicOp Op) {
  auto Kind =
      (Op >= AO__opencl_atomic_load && Op <= AO__opencl_atomic_fetch_max)
          ? AtomicScopeModelKind::OpenCL
          : AtomicScopeModelKind::None;
  return AtomicScopeModel::create(Kind);
}

/// Get atomic scope model.
/// \return empty atomic scope model if this atomic expression does not have
///   scope operand.
std::unique_ptr<AtomicScopeModel> getScopeModel() const {
  return getScopeModel(getOp());
}
5320};

5322/// TypoExpr - Internal placeholder for expressions where typo correction
5323/// still needs to be performed and/or an error diagnostic emitted.
5324class TypoExpr : public Expr {
5325public:
TypoExpr(QualType T)
    : Expr(TypoExprClass, T, VK_LValue, OK_Ordinary,
           /*isTypeDependent*/ true,
           /*isValueDependent*/ true,
           /*isInstantiationDependent*/ true,
           /*containsUnexpandedParameterPack*/ false) {
  assert(T->isDependentType() && "TypoExpr given a non-dependent type")(static_cast <bool> (T->isDependentType() &&
 "TypoExpr given a non-dependent type") ? void (0) : __assert_fail
 ("T->isDependentType() && \"TypoExpr given a non-dependent type\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/Expr.h"
, 5332, __extension__ __PRETTY_FUNCTION__));
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == TypoExprClass;
}

5349};
5350} // end namespace clang

5352#endif // LLVM_CLANG_AST_EXPR_H