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

Bug Summary

File:	tools/clang/include/clang/AST/ExprCXX.h
Warning:	line 2107, column 14 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())
1
Taking false branch→
  return nullptr;

auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
      Importer.Import(E->getOperatorDelete()));
if (!OperatorDeleteDecl && E->getOperatorDelete())
2
←
Taking false branch→
  return nullptr;

Expr *ToArg = Importer.Import(E->getArgument());
3
←
Calling 'ASTImporter::Import'→
15
←
Returning from 'ASTImporter::Import'→
16
←
'ToArg' initialized here→
if (!ToArg && E->getArgument())
17
←
Assuming 'ToArg' is null→
18
←
Assuming the condition is false→
19
←
Taking false branch→
  return nullptr;

return new (Importer.getToContext()) CXXDeleteExpr(
21
←
Calling constructor for 'CXXDeleteExpr'→
      T, E->isGlobalDelete(),
      E->isArrayForm(),
      E->isArrayFormAsWritten(),
      E->doesUsualArrayDeleteWantSize(),
      OperatorDeleteDecl,
      ToArg,
20
←
Passing null pointer value via 7th parameter 'arg'→
      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())
  return nullptr;

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

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

return new (Importer.getToContext())
    ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr);
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/ExprCXX.h

1//===- ExprCXX.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/// \file
11/// Defines the clang::Expr interface and subclasses for C++ expressions.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_CLANG_AST_EXPRCXX_H
16#define LLVM_CLANG_AST_EXPRCXX_H

18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclBase.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclarationName.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/NestedNameSpecifier.h"
24#include "clang/AST/OperationKinds.h"
25#include "clang/AST/Stmt.h"
26#include "clang/AST/TemplateBase.h"
27#include "clang/AST/Type.h"
28#include "clang/AST/UnresolvedSet.h"
29#include "clang/Basic/ExceptionSpecificationType.h"
30#include "clang/Basic/ExpressionTraits.h"
31#include "clang/Basic/LLVM.h"
32#include "clang/Basic/Lambda.h"
33#include "clang/Basic/LangOptions.h"
34#include "clang/Basic/OperatorKinds.h"
35#include "clang/Basic/SourceLocation.h"
36#include "clang/Basic/Specifiers.h"
37#include "clang/Basic/TypeTraits.h"
38#include "llvm/ADT/ArrayRef.h"
39#include "llvm/ADT/None.h"
40#include "llvm/ADT/Optional.h"
41#include "llvm/ADT/PointerUnion.h"
42#include "llvm/ADT/StringRef.h"
43#include "llvm/ADT/iterator_range.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/Compiler.h"
46#include "llvm/Support/TrailingObjects.h"
47#include <cassert>
48#include <cstddef>
49#include <cstdint>
50#include <memory>

52namespace clang {

54class ASTContext;
55class DeclAccessPair;
56class IdentifierInfo;
57class LambdaCapture;
58class NonTypeTemplateParmDecl;
59class TemplateParameterList;

61//===--------------------------------------------------------------------===//
62// C++ Expressions.
63//===--------------------------------------------------------------------===//

65/// A call to an overloaded operator written using operator
66/// syntax.
67///
68/// Represents a call to an overloaded operator written using operator
69/// syntax, e.g., "x + y" or "*p". While semantically equivalent to a
70/// normal call, this AST node provides better information about the
71/// syntactic representation of the call.
72///
73/// In a C++ template, this expression node kind will be used whenever
74/// any of the arguments are type-dependent. In this case, the
75/// function itself will be a (possibly empty) set of functions and
76/// function templates that were found by name lookup at template
77/// definition time.
78class CXXOperatorCallExpr : public CallExpr {
/// The overloaded operator.
OverloadedOperatorKind Operator;

SourceRange Range;

// Only meaningful for floating point types.
FPOptions FPFeatures;

SourceRange getSourceRangeImpl() const LLVM_READONLY__attribute__((__pure__));

89public:
friend class ASTStmtReader;
friend class ASTStmtWriter;

CXXOperatorCallExpr(ASTContext& C, OverloadedOperatorKind Op, Expr *fn,
                    ArrayRef<Expr*> args, QualType t, ExprValueKind VK,
                    SourceLocation operatorloc, FPOptions FPFeatures)
    : CallExpr(C, CXXOperatorCallExprClass, fn, args, t, VK, operatorloc),
      Operator(Op), FPFeatures(FPFeatures) {
  Range = getSourceRangeImpl();
}

explicit CXXOperatorCallExpr(ASTContext& C, EmptyShell Empty)
    : CallExpr(C, CXXOperatorCallExprClass, Empty) {}

/// Returns the kind of overloaded operator that this
/// expression refers to.
OverloadedOperatorKind getOperator() const { return Operator; }

static bool isAssignmentOp(OverloadedOperatorKind Opc) {
  return Opc == OO_Equal || Opc == OO_StarEqual ||
         Opc == OO_SlashEqual || Opc == OO_PercentEqual ||
         Opc == OO_PlusEqual || Opc == OO_MinusEqual ||
         Opc == OO_LessLessEqual || Opc == OO_GreaterGreaterEqual ||
         Opc == OO_AmpEqual || Opc == OO_CaretEqual ||
         Opc == OO_PipeEqual;
}
bool isAssignmentOp() const { return isAssignmentOp(getOperator()); }

/// Is this written as an infix binary operator?
bool isInfixBinaryOp() const;

/// Returns the location of the operator symbol in the expression.
///
/// When \c getOperator()==OO_Call, this is the location of the right
/// parentheses; when \c getOperator()==OO_Subscript, this is the location
/// of the right bracket.
SourceLocation getOperatorLoc() const { return getRParenLoc(); }

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return (Operator < OO_Plus || Operator >= OO_Arrow ||
          Operator == OO_PlusPlus || Operator == OO_MinusMinus)
             ? getLocStart()
             : getOperatorLoc();
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
SourceRange getSourceRange() const { return Range; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXOperatorCallExprClass;
}

// Set the FP contractability status of this operator. Only meaningful for
// operations on floating point types.
void setFPFeatures(FPOptions F) { FPFeatures = F; }

FPOptions getFPFeatures() const { return FPFeatures; }

// Get the FP contractability status of this operator. Only meaningful for
// operations on floating point types.
bool isFPContractableWithinStatement() const {
  return FPFeatures.allowFPContractWithinStatement();
}
154};

156/// Represents a call to a member function that
157/// may be written either with member call syntax (e.g., "obj.func()"
158/// or "objptr->func()") or with normal function-call syntax
159/// ("func()") within a member function that ends up calling a member
160/// function. The callee in either case is a MemberExpr that contains
161/// both the object argument and the member function, while the
162/// arguments are the arguments within the parentheses (not including
163/// the object argument).
164class CXXMemberCallExpr : public CallExpr {
165public:
CXXMemberCallExpr(ASTContext &C, Expr *fn, ArrayRef<Expr*> args,
                  QualType t, ExprValueKind VK, SourceLocation RP)
    : CallExpr(C, CXXMemberCallExprClass, fn, args, t, VK, RP) {}

CXXMemberCallExpr(ASTContext &C, EmptyShell Empty)
    : CallExpr(C, CXXMemberCallExprClass, Empty) {}

/// Retrieves the implicit object argument for the member call.
///
/// For example, in "x.f(5)", this returns the sub-expression "x".
Expr *getImplicitObjectArgument() const;

/// Retrieves the declaration of the called method.
CXXMethodDecl *getMethodDecl() const;

/// Retrieves the CXXRecordDecl for the underlying type of
/// the implicit object argument.
///
/// Note that this is may not be the same declaration as that of the class
/// context of the CXXMethodDecl which this function is calling.
/// FIXME: Returns 0 for member pointer call exprs.
CXXRecordDecl *getRecordDecl() const;

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  SourceLocation CLoc = getCallee()->getExprLoc();
  if (CLoc.isValid())
    return CLoc;

  return getLocStart();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXMemberCallExprClass;
}
200};

202/// Represents a call to a CUDA kernel function.
203class CUDAKernelCallExpr : public CallExpr {
204private:
enum { CONFIG, END_PREARG };

207public:
CUDAKernelCallExpr(ASTContext &C, Expr *fn, CallExpr *Config,
                   ArrayRef<Expr*> args, QualType t, ExprValueKind VK,
                   SourceLocation RP)
    : CallExpr(C, CUDAKernelCallExprClass, fn, Config, args, t, VK, RP) {}

CUDAKernelCallExpr(ASTContext &C, EmptyShell Empty)
    : CallExpr(C, CUDAKernelCallExprClass, END_PREARG, Empty) {}

const CallExpr *getConfig() const {
  return cast_or_null<CallExpr>(getPreArg(CONFIG));
}
CallExpr *getConfig() { return cast_or_null<CallExpr>(getPreArg(CONFIG)); }

/// Sets the kernel configuration expression.
///
/// Note that this method cannot be called if config has already been set to a
/// non-null value.
void setConfig(CallExpr *E) {
  assert(!getConfig() &&(static_cast <bool> (!getConfig() && "Cannot call setConfig if config is not null"
) ? void (0) : __assert_fail ("!getConfig() && \"Cannot call setConfig if config is not null\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 227, __extension__ __PRETTY_FUNCTION__))
         "Cannot call setConfig if config is not null")(static_cast <bool> (!getConfig() && "Cannot call setConfig if config is not null"
) ? void (0) : __assert_fail ("!getConfig() && \"Cannot call setConfig if config is not null\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 227, __extension__ __PRETTY_FUNCTION__));
  setPreArg(CONFIG, E);
  setInstantiationDependent(isInstantiationDependent() ||
                            E->isInstantiationDependent());
  setContainsUnexpandedParameterPack(containsUnexpandedParameterPack() ||
                                     E->containsUnexpandedParameterPack());
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CUDAKernelCallExprClass;
}
238};

240/// Abstract class common to all of the C++ "named"/"keyword" casts.
241///
242/// This abstract class is inherited by all of the classes
243/// representing "named" casts: CXXStaticCastExpr for \c static_cast,
244/// CXXDynamicCastExpr for \c dynamic_cast, CXXReinterpretCastExpr for
245/// reinterpret_cast, and CXXConstCastExpr for \c const_cast.
246class CXXNamedCastExpr : public ExplicitCastExpr {
247private:
// the location of the casting op
SourceLocation Loc;

// the location of the right parenthesis
SourceLocation RParenLoc;

// range for '<' '>'
SourceRange AngleBrackets;

257protected:
friend class ASTStmtReader;

CXXNamedCastExpr(StmtClass SC, QualType ty, ExprValueKind VK,
                 CastKind kind, Expr *op, unsigned PathSize,
                 TypeSourceInfo *writtenTy, SourceLocation l,
                 SourceLocation RParenLoc,
                 SourceRange AngleBrackets)
    : ExplicitCastExpr(SC, ty, VK, kind, op, PathSize, writtenTy), Loc(l),
      RParenLoc(RParenLoc), AngleBrackets(AngleBrackets) {}

explicit CXXNamedCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize)
    : ExplicitCastExpr(SC, Shell, PathSize) {}

271public:
const char *getCastName() const;

/// Retrieve the location of the cast operator keyword, e.g.,
/// \c static_cast.
SourceLocation getOperatorLoc() const { return Loc; }

/// Retrieve the location of the closing parenthesis.
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }
SourceRange getAngleBrackets() const LLVM_READONLY__attribute__((__pure__)) { return AngleBrackets; }

static bool classof(const Stmt *T) {
  switch (T->getStmtClass()) {
  case CXXStaticCastExprClass:
  case CXXDynamicCastExprClass:
  case CXXReinterpretCastExprClass:
  case CXXConstCastExprClass:
    return true;
  default:
    return false;
  }
}
296};

298/// A C++ \c static_cast expression (C++ [expr.static.cast]).
299///
300/// This expression node represents a C++ static cast, e.g.,
301/// \c static_cast<int>(1.0).
302class CXXStaticCastExpr final
  : public CXXNamedCastExpr,
    private llvm::TrailingObjects<CXXStaticCastExpr, CXXBaseSpecifier *> {
CXXStaticCastExpr(QualType ty, ExprValueKind vk, CastKind kind, Expr *op,
                  unsigned pathSize, TypeSourceInfo *writtenTy,
                  SourceLocation l, SourceLocation RParenLoc,
                  SourceRange AngleBrackets)
    : CXXNamedCastExpr(CXXStaticCastExprClass, ty, vk, kind, op, pathSize,
                       writtenTy, l, RParenLoc, AngleBrackets) {}

explicit CXXStaticCastExpr(EmptyShell Empty, unsigned PathSize)
    : CXXNamedCastExpr(CXXStaticCastExprClass, Empty, PathSize) {}

315public:
friend class CastExpr;
friend TrailingObjects;

static CXXStaticCastExpr *Create(const ASTContext &Context, QualType T,
                                 ExprValueKind VK, CastKind K, Expr *Op,
                                 const CXXCastPath *Path,
                                 TypeSourceInfo *Written, SourceLocation L,
                                 SourceLocation RParenLoc,
                                 SourceRange AngleBrackets);
static CXXStaticCastExpr *CreateEmpty(const ASTContext &Context,
                                      unsigned PathSize);

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXStaticCastExprClass;
}
331};

333/// A C++ @c dynamic_cast expression (C++ [expr.dynamic.cast]).
334///
335/// This expression node represents a dynamic cast, e.g.,
336/// \c dynamic_cast<Derived*>(BasePtr). Such a cast may perform a run-time
337/// check to determine how to perform the type conversion.
338class CXXDynamicCastExpr final
  : public CXXNamedCastExpr,
    private llvm::TrailingObjects<CXXDynamicCastExpr, CXXBaseSpecifier *> {
CXXDynamicCastExpr(QualType ty, ExprValueKind VK, CastKind kind,
                   Expr *op, unsigned pathSize, TypeSourceInfo *writtenTy,
                   SourceLocation l, SourceLocation RParenLoc,
                   SourceRange AngleBrackets)
    : CXXNamedCastExpr(CXXDynamicCastExprClass, ty, VK, kind, op, pathSize,
                       writtenTy, l, RParenLoc, AngleBrackets) {}

explicit CXXDynamicCastExpr(EmptyShell Empty, unsigned pathSize)
    : CXXNamedCastExpr(CXXDynamicCastExprClass, Empty, pathSize) {}

351public:
friend class CastExpr;
friend TrailingObjects;

static CXXDynamicCastExpr *Create(const ASTContext &Context, QualType T,
                                  ExprValueKind VK, CastKind Kind, Expr *Op,
                                  const CXXCastPath *Path,
                                  TypeSourceInfo *Written, SourceLocation L,
                                  SourceLocation RParenLoc,
                                  SourceRange AngleBrackets);

static CXXDynamicCastExpr *CreateEmpty(const ASTContext &Context,
                                       unsigned pathSize);

bool isAlwaysNull() const;

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXDynamicCastExprClass;
}
370};

372/// A C++ @c reinterpret_cast expression (C++ [expr.reinterpret.cast]).
373///
374/// This expression node represents a reinterpret cast, e.g.,
375/// @c reinterpret_cast<int>(VoidPtr).
376///
377/// A reinterpret_cast provides a differently-typed view of a value but
378/// (in Clang, as in most C++ implementations) performs no actual work at
379/// run time.
380class CXXReinterpretCastExpr final
  : public CXXNamedCastExpr,
    private llvm::TrailingObjects<CXXReinterpretCastExpr,
                                  CXXBaseSpecifier *> {
CXXReinterpretCastExpr(QualType ty, ExprValueKind vk, CastKind kind,
                       Expr *op, unsigned pathSize,
                       TypeSourceInfo *writtenTy, SourceLocation l,
                       SourceLocation RParenLoc,
                       SourceRange AngleBrackets)
    : CXXNamedCastExpr(CXXReinterpretCastExprClass, ty, vk, kind, op,
                       pathSize, writtenTy, l, RParenLoc, AngleBrackets) {}

CXXReinterpretCastExpr(EmptyShell Empty, unsigned pathSize)
    : CXXNamedCastExpr(CXXReinterpretCastExprClass, Empty, pathSize) {}

395public:
friend class CastExpr;
friend TrailingObjects;

static CXXReinterpretCastExpr *Create(const ASTContext &Context, QualType T,
                                      ExprValueKind VK, CastKind Kind,
                                      Expr *Op, const CXXCastPath *Path,
                               TypeSourceInfo *WrittenTy, SourceLocation L,
                                      SourceLocation RParenLoc,
                                      SourceRange AngleBrackets);
static CXXReinterpretCastExpr *CreateEmpty(const ASTContext &Context,
                                           unsigned pathSize);

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXReinterpretCastExprClass;
}
411};

413/// A C++ \c const_cast expression (C++ [expr.const.cast]).
414///
415/// This expression node represents a const cast, e.g.,
416/// \c const_cast<char*>(PtrToConstChar).
417///
418/// A const_cast can remove type qualifiers but does not change the underlying
419/// value.
420class CXXConstCastExpr final
  : public CXXNamedCastExpr,
    private llvm::TrailingObjects<CXXConstCastExpr, CXXBaseSpecifier *> {
CXXConstCastExpr(QualType ty, ExprValueKind VK, Expr *op,
                 TypeSourceInfo *writtenTy, SourceLocation l,
                 SourceLocation RParenLoc, SourceRange AngleBrackets)
    : CXXNamedCastExpr(CXXConstCastExprClass, ty, VK, CK_NoOp, op,
                       0, writtenTy, l, RParenLoc, AngleBrackets) {}

explicit CXXConstCastExpr(EmptyShell Empty)
    : CXXNamedCastExpr(CXXConstCastExprClass, Empty, 0) {}

432public:
friend class CastExpr;
friend TrailingObjects;

static CXXConstCastExpr *Create(const ASTContext &Context, QualType T,
                                ExprValueKind VK, Expr *Op,
                                TypeSourceInfo *WrittenTy, SourceLocation L,
                                SourceLocation RParenLoc,
                                SourceRange AngleBrackets);
static CXXConstCastExpr *CreateEmpty(const ASTContext &Context);

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXConstCastExprClass;
}
446};

448/// A call to a literal operator (C++11 [over.literal])
449/// written as a user-defined literal (C++11 [lit.ext]).
450///
451/// Represents a user-defined literal, e.g. "foo"_bar or 1.23_xyz. While this
452/// is semantically equivalent to a normal call, this AST node provides better
453/// information about the syntactic representation of the literal.
454///
455/// Since literal operators are never found by ADL and can only be declared at
456/// namespace scope, a user-defined literal is never dependent.
457class UserDefinedLiteral : public CallExpr {
/// The location of a ud-suffix within the literal.
SourceLocation UDSuffixLoc;

461public:
friend class ASTStmtReader;
friend class ASTStmtWriter;

UserDefinedLiteral(const ASTContext &C, Expr *Fn, ArrayRef<Expr*> Args,
                   QualType T, ExprValueKind VK, SourceLocation LitEndLoc,
                   SourceLocation SuffixLoc)
    : CallExpr(C, UserDefinedLiteralClass, Fn, Args, T, VK, LitEndLoc),
      UDSuffixLoc(SuffixLoc) {}

explicit UserDefinedLiteral(const ASTContext &C, EmptyShell Empty)
    : CallExpr(C, UserDefinedLiteralClass, Empty) {}

/// The kind of literal operator which is invoked.
enum LiteralOperatorKind {
  /// Raw form: operator "" X (const char *)
  LOK_Raw,

  /// Raw form: operator "" X<cs...> ()
  LOK_Template,

  /// operator "" X (unsigned long long)
  LOK_Integer,

  /// operator "" X (long double)
  LOK_Floating,

  /// operator "" X (const CharT *, size_t)
  LOK_String,

  /// operator "" X (CharT)
  LOK_Character
};

/// Returns the kind of literal operator invocation
/// which this expression represents.
LiteralOperatorKind getLiteralOperatorKind() const;

/// If this is not a raw user-defined literal, get the
/// underlying cooked literal (representing the literal with the suffix
/// removed).
Expr *getCookedLiteral();
const Expr *getCookedLiteral() const {
  return const_cast<UserDefinedLiteral*>(this)->getCookedLiteral();
}

SourceLocation getLocStart() const {
  if (getLiteralOperatorKind() == LOK_Template)
    return getRParenLoc();
  return getArg(0)->getLocStart();
}

SourceLocation getLocEnd() const { return getRParenLoc(); }

/// Returns the location of a ud-suffix in the expression.
///
/// For a string literal, there may be multiple identical suffixes. This
/// returns the first.
SourceLocation getUDSuffixLoc() const { return UDSuffixLoc; }

/// Returns the ud-suffix specified for this literal.
const IdentifierInfo *getUDSuffix() const;

static bool classof(const Stmt *S) {
  return S->getStmtClass() == UserDefinedLiteralClass;
}
527};

529/// A boolean literal, per ([C++ lex.bool] Boolean literals).
530class CXXBoolLiteralExpr : public Expr {
bool Value;
SourceLocation Loc;

534public:
CXXBoolLiteralExpr(bool val, QualType Ty, SourceLocation l)
    : Expr(CXXBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
           false, false),
      Value(val), Loc(l) {}

explicit CXXBoolLiteralExpr(EmptyShell Empty)
    : Expr(CXXBoolLiteralExprClass, Empty) {}

bool getValue() const { return Value; }
void setValue(bool V) { Value = V; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

SourceLocation getLocation() const { return Loc; }
void setLocation(SourceLocation L) { Loc = L; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXBoolLiteralExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
560};

562/// The null pointer literal (C++11 [lex.nullptr])
563///
564/// Introduced in C++11, the only literal of type \c nullptr_t is \c nullptr.
565class CXXNullPtrLiteralExpr : public Expr {
SourceLocation Loc;

568public:
CXXNullPtrLiteralExpr(QualType Ty, SourceLocation l)
    : Expr(CXXNullPtrLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false,
           false, false, false),
      Loc(l) {}

explicit CXXNullPtrLiteralExpr(EmptyShell Empty)
    : Expr(CXXNullPtrLiteralExprClass, Empty) {}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

SourceLocation getLocation() const { return Loc; }
void setLocation(SourceLocation L) { Loc = L; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXNullPtrLiteralExprClass;
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}
590};

592/// Implicit construction of a std::initializer_list<T> object from an
593/// array temporary within list-initialization (C++11 [dcl.init.list]p5).
594class CXXStdInitializerListExpr : public Expr {
Stmt *SubExpr = nullptr;

CXXStdInitializerListExpr(EmptyShell Empty)
    : Expr(CXXStdInitializerListExprClass, Empty) {}

600public:
friend class ASTReader;
friend class ASTStmtReader;

CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr)
    : Expr(CXXStdInitializerListExprClass, Ty, VK_RValue, OK_Ordinary,
           Ty->isDependentType(), SubExpr->isValueDependent(),
           SubExpr->isInstantiationDependent(),
           SubExpr->containsUnexpandedParameterPack()),
      SubExpr(SubExpr) {}

Expr *getSubExpr() { return static_cast<Expr*>(SubExpr); }
const Expr *getSubExpr() const { return static_cast<const Expr*>(SubExpr); }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getLocStart();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getLocEnd();
}

/// Retrieve the source range of the expression.
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getSourceRange();
}

static bool classof(const Stmt *S) {
  return S->getStmtClass() == CXXStdInitializerListExprClass;
}

child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
632};

634/// A C++ \c typeid expression (C++ [expr.typeid]), which gets
635/// the \c type_info that corresponds to the supplied type, or the (possibly
636/// dynamic) type of the supplied expression.
637///
638/// This represents code like \c typeid(int) or \c typeid(*objPtr)
639class CXXTypeidExpr : public Expr {
640private:
llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
SourceRange Range;

644public:
CXXTypeidExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)
    : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary,
           // typeid is never type-dependent (C++ [temp.dep.expr]p4)
           false,
           // typeid is value-dependent if the type or expression are
           // dependent
           Operand->getType()->isDependentType(),
           Operand->getType()->isInstantiationDependentType(),
           Operand->getType()->containsUnexpandedParameterPack()),
      Operand(Operand), Range(R) {}

CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R)
    : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary,
           // typeid is never type-dependent (C++ [temp.dep.expr]p4)
           false,
           // typeid is value-dependent if the type or expression are
           // dependent
           Operand->isTypeDependent() || Operand->isValueDependent(),
           Operand->isInstantiationDependent(),
           Operand->containsUnexpandedParameterPack()),
      Operand(Operand), Range(R) {}

CXXTypeidExpr(EmptyShell Empty, bool isExpr)
    : Expr(CXXTypeidExprClass, Empty) {
  if (isExpr)
    Operand = (Expr*)nullptr;
  else
    Operand = (TypeSourceInfo*)nullptr;
}

/// Determine whether this typeid has a type operand which is potentially
/// evaluated, per C++11 [expr.typeid]p3.
bool isPotentiallyEvaluated() const;

bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }

/// Retrieves the type operand of this typeid() expression after
/// various required adjustments (removing reference types, cv-qualifiers).
QualType getTypeOperand(ASTContext &Context) const;

/// Retrieve source information for the type operand.
TypeSourceInfo *getTypeOperandSourceInfo() const {
  assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)")(static_cast <bool> (isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)"
) ? void (0) : __assert_fail ("isTypeOperand() && \"Cannot call getTypeOperand for typeid(expr)\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 687, __extension__ __PRETTY_FUNCTION__));
  return Operand.get<TypeSourceInfo *>();
}

void setTypeOperandSourceInfo(TypeSourceInfo *TSI) {
  assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)")(static_cast <bool> (isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)"
) ? void (0) : __assert_fail ("isTypeOperand() && \"Cannot call getTypeOperand for typeid(expr)\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 692, __extension__ __PRETTY_FUNCTION__));
  Operand = TSI;
}

Expr *getExprOperand() const {
  assert(!isTypeOperand() && "Cannot call getExprOperand for typeid(type)")(static_cast <bool> (!isTypeOperand() && "Cannot call getExprOperand for typeid(type)"
) ? void (0) : __assert_fail ("!isTypeOperand() && \"Cannot call getExprOperand for typeid(type)\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 697, __extension__ __PRETTY_FUNCTION__));
  return static_cast<Expr*>(Operand.get<Stmt *>());
}

void setExprOperand(Expr *E) {
  assert(!isTypeOperand() && "Cannot call getExprOperand for typeid(type)")(static_cast <bool> (!isTypeOperand() && "Cannot call getExprOperand for typeid(type)"
) ? void (0) : __assert_fail ("!isTypeOperand() && \"Cannot call getExprOperand for typeid(type)\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 702, __extension__ __PRETTY_FUNCTION__));
  Operand = E;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
void setSourceRange(SourceRange R) { Range = R; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXTypeidExprClass;
}

// Iterators
child_range children() {
  if (isTypeOperand())
    return child_range(child_iterator(), child_iterator());
  auto **begin = reinterpret_cast<Stmt **>(&Operand);
  return child_range(begin, begin + 1);
}
722};

724/// A member reference to an MSPropertyDecl. 
725///
726/// This expression always has pseudo-object type, and therefore it is
727/// typically not encountered in a fully-typechecked expression except
728/// within the syntactic form of a PseudoObjectExpr.
729class MSPropertyRefExpr : public Expr {
Expr *BaseExpr;
MSPropertyDecl *TheDecl;
SourceLocation MemberLoc;
bool IsArrow;
NestedNameSpecifierLoc QualifierLoc;

736public:
friend class ASTStmtReader;

MSPropertyRefExpr(Expr *baseExpr, MSPropertyDecl *decl, bool isArrow,
                  QualType ty, ExprValueKind VK,
                  NestedNameSpecifierLoc qualifierLoc,
                  SourceLocation nameLoc)
    : Expr(MSPropertyRefExprClass, ty, VK, OK_Ordinary,
           /*type-dependent*/ false, baseExpr->isValueDependent(),
           baseExpr->isInstantiationDependent(),
           baseExpr->containsUnexpandedParameterPack()),
      BaseExpr(baseExpr), TheDecl(decl),
      MemberLoc(nameLoc), IsArrow(isArrow),
      QualifierLoc(qualifierLoc) {}

MSPropertyRefExpr(EmptyShell Empty) : Expr(MSPropertyRefExprClass, Empty) {}

SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getLocStart(), getLocEnd());
}

bool isImplicitAccess() const {
  return getBaseExpr() && getBaseExpr()->isImplicitCXXThis();
}

SourceLocation getLocStart() const {
  if (!isImplicitAccess())
    return BaseExpr->getLocStart();
  else if (QualifierLoc)
    return QualifierLoc.getBeginLoc();
  else
      return MemberLoc;
}

SourceLocation getLocEnd() const { return getMemberLoc(); }

child_range children() {
  return child_range((Stmt**)&BaseExpr, (Stmt**)&BaseExpr + 1);
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == MSPropertyRefExprClass;
}

Expr *getBaseExpr() const { return BaseExpr; }
MSPropertyDecl *getPropertyDecl() const { return TheDecl; }
bool isArrow() const { return IsArrow; }
SourceLocation getMemberLoc() const { return MemberLoc; }
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
785};

787/// MS property subscript expression.
788/// MSVC supports 'property' attribute and allows to apply it to the
789/// declaration of an empty array in a class or structure definition.
790/// For example:
791/// \code
792/// __declspec(property(get=GetX, put=PutX)) int x[];
793/// \endcode
794/// The above statement indicates that x[] can be used with one or more array
795/// indices. In this case, i=p->x[a][b] will be turned into i=p->GetX(a, b), and
796/// p->x[a][b] = i will be turned into p->PutX(a, b, i).
797/// This is a syntactic pseudo-object expression.
798class MSPropertySubscriptExpr : public Expr {
friend class ASTStmtReader;

enum { BASE_EXPR, IDX_EXPR, NUM_SUBEXPRS = 2 };

Stmt *SubExprs[NUM_SUBEXPRS];
SourceLocation RBracketLoc;

void setBase(Expr *Base) { SubExprs[BASE_EXPR] = Base; }
void setIdx(Expr *Idx) { SubExprs[IDX_EXPR] = Idx; }

809public:
MSPropertySubscriptExpr(Expr *Base, Expr *Idx, QualType Ty, ExprValueKind VK,
                        ExprObjectKind OK, SourceLocation RBracketLoc)
    : Expr(MSPropertySubscriptExprClass, Ty, VK, OK, Idx->isTypeDependent(),
           Idx->isValueDependent(), Idx->isInstantiationDependent(),
           Idx->containsUnexpandedParameterPack()),
      RBracketLoc(RBracketLoc) {
  SubExprs[BASE_EXPR] = Base;
  SubExprs[IDX_EXPR] = Idx;
}

/// Create an empty array subscript expression.
explicit MSPropertySubscriptExpr(EmptyShell Shell)
    : Expr(MSPropertySubscriptExprClass, Shell) {}

Expr *getBase() { return cast<Expr>(SubExprs[BASE_EXPR]); }
const Expr *getBase() const { return cast<Expr>(SubExprs[BASE_EXPR]); }

Expr *getIdx() { return cast<Expr>(SubExprs[IDX_EXPR]); }
const Expr *getIdx() const { return cast<Expr>(SubExprs[IDX_EXPR]); }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->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() == MSPropertySubscriptExprClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS);
}
851};

853/// A Microsoft C++ @c __uuidof expression, which gets
854/// the _GUID that corresponds to the supplied type or expression.
855///
856/// This represents code like @c __uuidof(COMTYPE) or @c __uuidof(*comPtr)
857class CXXUuidofExpr : public Expr {
858private:
llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
StringRef UuidStr;
SourceRange Range;

863public:
CXXUuidofExpr(QualType Ty, TypeSourceInfo *Operand, StringRef UuidStr,
              SourceRange R)
    : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary, false,
           Operand->getType()->isDependentType(),
           Operand->getType()->isInstantiationDependentType(),
           Operand->getType()->containsUnexpandedParameterPack()),
      Operand(Operand), UuidStr(UuidStr), Range(R) {}

CXXUuidofExpr(QualType Ty, Expr *Operand, StringRef UuidStr, SourceRange R)
    : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary, false,
           Operand->isTypeDependent(), Operand->isInstantiationDependent(),
           Operand->containsUnexpandedParameterPack()),
      Operand(Operand), UuidStr(UuidStr), Range(R) {}

CXXUuidofExpr(EmptyShell Empty, bool isExpr)
  : Expr(CXXUuidofExprClass, Empty) {
  if (isExpr)
    Operand = (Expr*)nullptr;
  else
    Operand = (TypeSourceInfo*)nullptr;
}

bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }

/// Retrieves the type operand of this __uuidof() expression after
/// various required adjustments (removing reference types, cv-qualifiers).
QualType getTypeOperand(ASTContext &Context) const;

/// Retrieve source information for the type operand.
TypeSourceInfo *getTypeOperandSourceInfo() const {
  assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)")(static_cast <bool> (isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)"
) ? void (0) : __assert_fail ("isTypeOperand() && \"Cannot call getTypeOperand for __uuidof(expr)\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 894, __extension__ __PRETTY_FUNCTION__));
  return Operand.get<TypeSourceInfo *>();
}

void setTypeOperandSourceInfo(TypeSourceInfo *TSI) {
  assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)")(static_cast <bool> (isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)"
) ? void (0) : __assert_fail ("isTypeOperand() && \"Cannot call getTypeOperand for __uuidof(expr)\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 899, __extension__ __PRETTY_FUNCTION__));
  Operand = TSI;
}

Expr *getExprOperand() const {
  assert(!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)")(static_cast <bool> (!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)"
) ? void (0) : __assert_fail ("!isTypeOperand() && \"Cannot call getExprOperand for __uuidof(type)\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 904, __extension__ __PRETTY_FUNCTION__));
  return static_cast<Expr*>(Operand.get<Stmt *>());
}

void setExprOperand(Expr *E) {
  assert(!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)")(static_cast <bool> (!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)"
) ? void (0) : __assert_fail ("!isTypeOperand() && \"Cannot call getExprOperand for __uuidof(type)\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 909, __extension__ __PRETTY_FUNCTION__));
  Operand = E;
}

void setUuidStr(StringRef US) { UuidStr = US; }
StringRef getUuidStr() const { return UuidStr; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
void setSourceRange(SourceRange R) { Range = R; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXUuidofExprClass;
}

// Iterators
child_range children() {
  if (isTypeOperand())
    return child_range(child_iterator(), child_iterator());
  auto **begin = reinterpret_cast<Stmt **>(&Operand);
  return child_range(begin, begin + 1);
}
932};

934/// Represents the \c this expression in C++.
935///
936/// This is a pointer to the object on which the current member function is
937/// executing (C++ [expr.prim]p3). Example:
938///
939/// \code
940/// class Foo {
941/// public:
942///   void bar();
943///   void test() { this->bar(); }
944/// };
945/// \endcode
946class CXXThisExpr : public Expr {
SourceLocation Loc;
bool Implicit : 1;

950public:
CXXThisExpr(SourceLocation L, QualType Type, bool isImplicit)
    : Expr(CXXThisExprClass, Type, VK_RValue, OK_Ordinary,
           // 'this' is type-dependent if the class type of the enclosing
           // member function is dependent (C++ [temp.dep.expr]p2)
           Type->isDependentType(), Type->isDependentType(),
           Type->isInstantiationDependentType(),
           /*ContainsUnexpandedParameterPack=*/false),
      Loc(L), Implicit(isImplicit) {}

CXXThisExpr(EmptyShell Empty) : Expr(CXXThisExprClass, Empty) {}

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; }

bool isImplicit() const { return Implicit; }
void setImplicit(bool I) { Implicit = I; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXThisExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
979};

981/// A C++ throw-expression (C++ [except.throw]).
982///
983/// This handles 'throw' (for re-throwing the current exception) and
984/// 'throw' assignment-expression.  When assignment-expression isn't
985/// present, Op will be null.
986class CXXThrowExpr : public Expr {
friend class ASTStmtReader;

Stmt *Op;
SourceLocation ThrowLoc;

/// Whether the thrown variable (if any) is in scope.
unsigned IsThrownVariableInScope : 1;

995public:
// \p Ty is the void type which is used as the result type of the
// expression.  The \p l is the location of the throw keyword.  \p expr
// can by null, if the optional expression to throw isn't present.
CXXThrowExpr(Expr *expr, QualType Ty, SourceLocation l,
             bool IsThrownVariableInScope)
    : Expr(CXXThrowExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
           expr && expr->isInstantiationDependent(),
           expr && expr->containsUnexpandedParameterPack()),
      Op(expr), ThrowLoc(l),
      IsThrownVariableInScope(IsThrownVariableInScope) {}
CXXThrowExpr(EmptyShell Empty) : Expr(CXXThrowExprClass, Empty) {}

const Expr *getSubExpr() const { return cast_or_null<Expr>(Op); }
Expr *getSubExpr() { return cast_or_null<Expr>(Op); }

SourceLocation getThrowLoc() const { return ThrowLoc; }

/// Determines whether the variable thrown by this expression (if any!)
/// is within the innermost try block.
///
/// This information is required to determine whether the NRVO can apply to
/// this variable.
bool isThrownVariableInScope() const { return IsThrownVariableInScope; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return ThrowLoc; }

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  if (!getSubExpr())
    return ThrowLoc;
  return getSubExpr()->getLocEnd();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXThrowExprClass;
}

// Iterators
child_range children() {
  return child_range(&Op, Op ? &Op+1 : &Op);
}
1036};

1038/// A default argument (C++ [dcl.fct.default]).
1039///
1040/// This wraps up a function call argument that was created from the
1041/// corresponding parameter's default argument, when the call did not
1042/// explicitly supply arguments for all of the parameters.
1043class CXXDefaultArgExpr final : public Expr {
/// The parameter whose default is being used.
ParmVarDecl *Param;

/// The location where the default argument expression was used.
SourceLocation Loc;

CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *param)
    : Expr(SC,
           param->hasUnparsedDefaultArg()
             ? param->getType().getNonReferenceType()
             : param->getDefaultArg()->getType(),
           param->getDefaultArg()->getValueKind(),
           param->getDefaultArg()->getObjectKind(), false, false, false,
           false),
      Param(param), Loc(Loc) {}

1060public:
friend class ASTStmtReader;
friend class ASTStmtWriter;

CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}

// \p Param is the parameter whose default argument is used by this
// expression.
static CXXDefaultArgExpr *Create(const ASTContext &C, SourceLocation Loc,
                                 ParmVarDecl *Param) {
  return new (C) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param);
}

// Retrieve the parameter that the argument was created from.
const ParmVarDecl *getParam() const { return Param; }
ParmVarDecl *getParam() { return Param; }

// Retrieve the actual argument to the function call.
const Expr *getExpr() const {
  return getParam()->getDefaultArg();
}
Expr *getExpr() {
  return getParam()->getDefaultArg();
}

/// Retrieve the location where this default argument was actually
/// used.
SourceLocation getUsedLocation() const { return Loc; }

/// Default argument expressions have no representation in the
/// source, so they have an empty source range.
SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXDefaultArgExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
1104};

1106/// A use of a default initializer in a constructor or in aggregate
1107/// initialization.
1108///
1109/// This wraps a use of a C++ default initializer (technically,
1110/// a brace-or-equal-initializer for a non-static data member) when it
1111/// is implicitly used in a mem-initializer-list in a constructor
1112/// (C++11 [class.base.init]p8) or in aggregate initialization
1113/// (C++1y [dcl.init.aggr]p7).
1114class CXXDefaultInitExpr : public Expr {
/// The field whose default is being used.
FieldDecl *Field;

/// The location where the default initializer expression was used.
SourceLocation Loc;

CXXDefaultInitExpr(const ASTContext &C, SourceLocation Loc, FieldDecl *Field,
                   QualType T);

CXXDefaultInitExpr(EmptyShell Empty) : Expr(CXXDefaultInitExprClass, Empty) {}

1126public:
friend class ASTReader;
friend class ASTStmtReader;

/// \p Field is the non-static data member whose default initializer is used
/// by this expression.
static CXXDefaultInitExpr *Create(const ASTContext &C, SourceLocation Loc,
                                  FieldDecl *Field) {
  return new (C) CXXDefaultInitExpr(C, Loc, Field, Field->getType());
}

/// Get the field whose initializer will be used.
FieldDecl *getField() { return Field; }
const FieldDecl *getField() const { return Field; }

/// Get the initialization expression that will be used.
const Expr *getExpr() const {
  assert(Field->getInClassInitializer() && "initializer hasn't been parsed")(static_cast <bool> (Field->getInClassInitializer() &&
 "initializer hasn't been parsed") ? void (0) : __assert_fail
 ("Field->getInClassInitializer() && \"initializer hasn't been parsed\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 1143, __extension__ __PRETTY_FUNCTION__));
  return Field->getInClassInitializer();
}
Expr *getExpr() {
  assert(Field->getInClassInitializer() && "initializer hasn't been parsed")(static_cast <bool> (Field->getInClassInitializer() &&
 "initializer hasn't been parsed") ? void (0) : __assert_fail
 ("Field->getInClassInitializer() && \"initializer hasn't been parsed\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 1147, __extension__ __PRETTY_FUNCTION__));
  return Field->getInClassInitializer();
}

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() == CXXDefaultInitExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
1162};

1164/// Represents a C++ temporary.
1165class CXXTemporary {
/// The destructor that needs to be called.
const CXXDestructorDecl *Destructor;

explicit CXXTemporary(const CXXDestructorDecl *destructor)
    : Destructor(destructor) {}

1172public:
static CXXTemporary *Create(const ASTContext &C,
                            const CXXDestructorDecl *Destructor);

const CXXDestructorDecl *getDestructor() const { return Destructor; }

void setDestructor(const CXXDestructorDecl *Dtor) {
  Destructor = Dtor;
}
1181};

1183/// Represents binding an expression to a temporary.
1184///
1185/// This ensures the destructor is called for the temporary. It should only be
1186/// needed for non-POD, non-trivially destructable class types. For example:
1187///
1188/// \code
1189///   struct S {
1190///     S() { }  // User defined constructor makes S non-POD.
1191///     ~S() { } // User defined destructor makes it non-trivial.
1192///   };
1193///   void test() {
1194///     const S &s_ref = S(); // Requires a CXXBindTemporaryExpr.
1195///   }
1196/// \endcode
1197class CXXBindTemporaryExpr : public Expr {
CXXTemporary *Temp = nullptr;
Stmt *SubExpr = nullptr;

CXXBindTemporaryExpr(CXXTemporary *temp, Expr* SubExpr)
    : Expr(CXXBindTemporaryExprClass, SubExpr->getType(),
           VK_RValue, OK_Ordinary, SubExpr->isTypeDependent(),
           SubExpr->isValueDependent(),
           SubExpr->isInstantiationDependent(),
           SubExpr->containsUnexpandedParameterPack()),
      Temp(temp), SubExpr(SubExpr) {}

1209public:
CXXBindTemporaryExpr(EmptyShell Empty)
    : Expr(CXXBindTemporaryExprClass, Empty) {}

static CXXBindTemporaryExpr *Create(const ASTContext &C, CXXTemporary *Temp,
                                    Expr* SubExpr);

CXXTemporary *getTemporary() { return Temp; }
const CXXTemporary *getTemporary() const { return Temp; }
void setTemporary(CXXTemporary *T) { Temp = T; }

const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
Expr *getSubExpr() { return cast<Expr>(SubExpr); }
void setSubExpr(Expr *E) { SubExpr = E; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getLocStart();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return SubExpr->getLocEnd();}

// Implement isa/cast/dyncast/etc.
static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXBindTemporaryExprClass;
}

// Iterators
child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
1237};

1239/// Represents a call to a C++ constructor.
1240class CXXConstructExpr : public Expr {
1241public:
enum ConstructionKind {
  CK_Complete,
  CK_NonVirtualBase,
  CK_VirtualBase,
  CK_Delegating
};

1249private:
CXXConstructorDecl *Constructor = nullptr;
SourceLocation Loc;
SourceRange ParenOrBraceRange;
unsigned NumArgs : 16;
unsigned Elidable : 1;
unsigned HadMultipleCandidates : 1;
unsigned ListInitialization : 1;
unsigned StdInitListInitialization : 1;
unsigned ZeroInitialization : 1;
unsigned ConstructKind : 2;
Stmt **Args = nullptr;

void setConstructor(CXXConstructorDecl *C) { Constructor = C; }

1264protected:
CXXConstructExpr(const ASTContext &C, StmtClass SC, QualType T,
                 SourceLocation Loc,
                 CXXConstructorDecl *Ctor,
                 bool Elidable,
                 ArrayRef<Expr *> Args,
                 bool HadMultipleCandidates,
                 bool ListInitialization,
                 bool StdInitListInitialization,
                 bool ZeroInitialization,
                 ConstructionKind ConstructKind,
                 SourceRange ParenOrBraceRange);

/// Construct an empty C++ construction expression.
CXXConstructExpr(StmtClass SC, EmptyShell Empty)
    : Expr(SC, Empty), NumArgs(0), Elidable(false),
      HadMultipleCandidates(false), ListInitialization(false),
      ZeroInitialization(false), ConstructKind(0) {}

1283public:
friend class ASTStmtReader;

/// Construct an empty C++ construction expression.
explicit CXXConstructExpr(EmptyShell Empty)
    : CXXConstructExpr(CXXConstructExprClass, Empty) {}

static CXXConstructExpr *Create(const ASTContext &C, QualType T,
                                SourceLocation Loc,
                                CXXConstructorDecl *Ctor,
                                bool Elidable,
                                ArrayRef<Expr *> Args,
                                bool HadMultipleCandidates,
                                bool ListInitialization,
                                bool StdInitListInitialization,
                                bool ZeroInitialization,
                                ConstructionKind ConstructKind,
                                SourceRange ParenOrBraceRange);

/// Get the constructor that this expression will (ultimately) call.
CXXConstructorDecl *getConstructor() const { return Constructor; }

SourceLocation getLocation() const { return Loc; }
void setLocation(SourceLocation Loc) { this->Loc = Loc; }

/// Whether this construction is elidable.
bool isElidable() const { return Elidable; }
void setElidable(bool E) { Elidable = E; }

/// Whether the referred constructor was resolved from
/// an overloaded set having size greater than 1.
bool hadMultipleCandidates() const { return HadMultipleCandidates; }
void setHadMultipleCandidates(bool V) { HadMultipleCandidates = V; }

/// Whether this constructor call was written as list-initialization.
bool isListInitialization() const { return ListInitialization; }
void setListInitialization(bool V) { ListInitialization = V; }

/// Whether this constructor call was written as list-initialization,
/// but was interpreted as forming a std::initializer_list<T> from the list
/// and passing that as a single constructor argument.
/// See C++11 [over.match.list]p1 bullet 1.
bool isStdInitListInitialization() const { return StdInitListInitialization; }
void setStdInitListInitialization(bool V) { StdInitListInitialization = V; }

/// Whether this construction first requires
/// zero-initialization before the initializer is called.
bool requiresZeroInitialization() const { return ZeroInitialization; }
void setRequiresZeroInitialization(bool ZeroInit) {
  ZeroInitialization = ZeroInit;
}

/// Determine whether this constructor is actually constructing
/// a base class (rather than a complete object).
ConstructionKind getConstructionKind() const {
  return (ConstructionKind)ConstructKind;
}
void setConstructionKind(ConstructionKind CK) {
  ConstructKind = CK;
}

using arg_iterator = ExprIterator;
using const_arg_iterator = ConstExprIterator;
using arg_range = llvm::iterator_range<arg_iterator>;
using arg_const_range = llvm::iterator_range<const_arg_iterator>;

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 Args; }
arg_iterator arg_end() { return Args + NumArgs; }
const_arg_iterator arg_begin() const { return Args; }
const_arg_iterator arg_end() const { return Args + NumArgs; }

Expr **getArgs() { return reinterpret_cast<Expr **>(Args); }
const Expr *const *getArgs() const {
  return const_cast<CXXConstructExpr *>(this)->getArgs();
}
unsigned getNumArgs() const { return NumArgs; }

/// 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/ExprCXX.h"
, 1367, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(Args[Arg]);
}
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/ExprCXX.h"
, 1371, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(Args[Arg]);
}

/// 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/ExprCXX.h"
, 1377, __extension__ __PRETTY_FUNCTION__));
  Args[Arg] = ArgExpr;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__));
SourceRange getParenOrBraceRange() const { return ParenOrBraceRange; }
void setParenOrBraceRange(SourceRange Range) { ParenOrBraceRange = Range; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXConstructExprClass ||
    T->getStmtClass() == CXXTemporaryObjectExprClass;
}

// Iterators
child_range children() {
  return child_range(&Args[0], &Args[0]+NumArgs);
}
1395};

1397/// Represents a call to an inherited base class constructor from an
1398/// inheriting constructor. This call implicitly forwards the arguments from
1399/// the enclosing context (an inheriting constructor) to the specified inherited
1400/// base class constructor.
1401class CXXInheritedCtorInitExpr : public Expr {
1402private:
CXXConstructorDecl *Constructor = nullptr;

/// The location of the using declaration.
SourceLocation Loc;

/// Whether this is the construction of a virtual base.
unsigned ConstructsVirtualBase : 1;

/// Whether the constructor is inherited from a virtual base class of the
/// class that we construct.
unsigned InheritedFromVirtualBase : 1;

1415public:
friend class ASTStmtReader;

/// Construct a C++ inheriting construction expression.
CXXInheritedCtorInitExpr(SourceLocation Loc, QualType T,
                         CXXConstructorDecl *Ctor, bool ConstructsVirtualBase,
                         bool InheritedFromVirtualBase)
    : Expr(CXXInheritedCtorInitExprClass, T, VK_RValue, OK_Ordinary, false,
           false, false, false),
      Constructor(Ctor), Loc(Loc),
      ConstructsVirtualBase(ConstructsVirtualBase),
      InheritedFromVirtualBase(InheritedFromVirtualBase) {
  assert(!T->isDependentType())(static_cast <bool> (!T->isDependentType()) ? void (
0) : __assert_fail ("!T->isDependentType()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 1427, __extension__ __PRETTY_FUNCTION__));
}

/// Construct an empty C++ inheriting construction expression.
explicit CXXInheritedCtorInitExpr(EmptyShell Empty)
    : Expr(CXXInheritedCtorInitExprClass, Empty),
      ConstructsVirtualBase(false), InheritedFromVirtualBase(false) {}

/// Get the constructor that this expression will call.
CXXConstructorDecl *getConstructor() const { return Constructor; }

/// Determine whether this constructor is actually constructing
/// a base class (rather than a complete object).
bool constructsVBase() const { return ConstructsVirtualBase; }
CXXConstructExpr::ConstructionKind getConstructionKind() const {
  return ConstructsVirtualBase ? CXXConstructExpr::CK_VirtualBase
                               : CXXConstructExpr::CK_NonVirtualBase;
}

/// Determine whether the inherited constructor is inherited from a
/// virtual base of the object we construct. If so, we are not responsible
/// for calling the inherited constructor (the complete object constructor
/// does that), and so we don't need to pass any arguments.
bool inheritedFromVBase() const { return InheritedFromVirtualBase; }

SourceLocation getLocation() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
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() == CXXInheritedCtorInitExprClass;
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}
1463};

1465/// Represents an explicit C++ type conversion that uses "functional"
1466/// notation (C++ [expr.type.conv]).
1467///
1468/// Example:
1469/// \code
1470///   x = int(0.5);
1471/// \endcode
1472class CXXFunctionalCastExpr final
  : public ExplicitCastExpr,
    private llvm::TrailingObjects<CXXFunctionalCastExpr, CXXBaseSpecifier *> {
SourceLocation LParenLoc;
SourceLocation RParenLoc;

CXXFunctionalCastExpr(QualType ty, ExprValueKind VK,
                      TypeSourceInfo *writtenTy,
                      CastKind kind, Expr *castExpr, unsigned pathSize,
                      SourceLocation lParenLoc, SourceLocation rParenLoc)
    : ExplicitCastExpr(CXXFunctionalCastExprClass, ty, VK, kind,
                       castExpr, pathSize, writtenTy),
      LParenLoc(lParenLoc), RParenLoc(rParenLoc) {}

explicit CXXFunctionalCastExpr(EmptyShell Shell, unsigned PathSize)
    : ExplicitCastExpr(CXXFunctionalCastExprClass, Shell, PathSize) {}

1489public:
friend class CastExpr;
friend TrailingObjects;

static CXXFunctionalCastExpr *Create(const ASTContext &Context, QualType T,
                                     ExprValueKind VK,
                                     TypeSourceInfo *Written,
                                     CastKind Kind, Expr *Op,
                                     const CXXCastPath *Path,
                                     SourceLocation LPLoc,
                                     SourceLocation RPLoc);
static CXXFunctionalCastExpr *CreateEmpty(const ASTContext &Context,
                                          unsigned PathSize);

SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

/// Determine whether this expression models list-initialization.
bool isListInitialization() const { return LParenLoc.isInvalid(); }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXFunctionalCastExprClass;
}
1517};

1519/// Represents a C++ functional cast expression that builds a
1520/// temporary object.
1521///
1522/// This expression type represents a C++ "functional" cast
1523/// (C++[expr.type.conv]) with N != 1 arguments that invokes a
1524/// constructor to build a temporary object. With N == 1 arguments the
1525/// functional cast expression will be represented by CXXFunctionalCastExpr.
1526/// Example:
1527/// \code
1528/// struct X { X(int, float); }
1529///
1530/// X create_X() {
1531///   return X(1, 3.14f); // creates a CXXTemporaryObjectExpr
1532/// };
1533/// \endcode
1534class CXXTemporaryObjectExpr : public CXXConstructExpr {
TypeSourceInfo *Type = nullptr;

1537public:
friend class ASTStmtReader;

CXXTemporaryObjectExpr(const ASTContext &C,
                       CXXConstructorDecl *Cons,
                       QualType Type,
                       TypeSourceInfo *TSI,
                       ArrayRef<Expr *> Args,
                       SourceRange ParenOrBraceRange,
                       bool HadMultipleCandidates,
                       bool ListInitialization,
                       bool StdInitListInitialization,
                       bool ZeroInitialization);
explicit CXXTemporaryObjectExpr(EmptyShell Empty)
    : CXXConstructExpr(CXXTemporaryObjectExprClass, Empty) {}

TypeSourceInfo *getTypeSourceInfo() const { return Type; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXTemporaryObjectExprClass;
}
1561};

1563/// A C++ lambda expression, which produces a function object
1564/// (of unspecified type) that can be invoked later.
1565///
1566/// Example:
1567/// \code
1568/// void low_pass_filter(std::vector<double> &values, double cutoff) {
1569///   values.erase(std::remove_if(values.begin(), values.end(),
1570///                               [=](double value) { return value > cutoff; });
1571/// }
1572/// \endcode
1573///
1574/// C++11 lambda expressions can capture local variables, either by copying
1575/// the values of those local variables at the time the function
1576/// object is constructed (not when it is called!) or by holding a
1577/// reference to the local variable. These captures can occur either
1578/// implicitly or can be written explicitly between the square
1579/// brackets ([...]) that start the lambda expression.
1580///
1581/// C++1y introduces a new form of "capture" called an init-capture that
1582/// includes an initializing expression (rather than capturing a variable),
1583/// and which can never occur implicitly.
1584class LambdaExpr final : public Expr,
                       private llvm::TrailingObjects<LambdaExpr, Stmt *> {
/// The source range that covers the lambda introducer ([...]).
SourceRange IntroducerRange;

/// The source location of this lambda's capture-default ('=' or '&').
SourceLocation CaptureDefaultLoc;

/// The number of captures.
unsigned NumCaptures : 16;

/// The default capture kind, which is a value of type
/// LambdaCaptureDefault.
unsigned CaptureDefault : 2;

/// Whether this lambda had an explicit parameter list vs. an
/// implicit (and empty) parameter list.
unsigned ExplicitParams : 1;

/// Whether this lambda had the result type explicitly specified.
unsigned ExplicitResultType : 1;

/// The location of the closing brace ('}') that completes
/// the lambda.
/// 
/// The location of the brace is also available by looking up the
/// function call operator in the lambda class. However, it is
/// stored here to improve the performance of getSourceRange(), and
/// to avoid having to deserialize the function call operator from a
/// module file just to determine the source range.
SourceLocation ClosingBrace;

/// Construct a lambda expression.
LambdaExpr(QualType T, SourceRange IntroducerRange,
           LambdaCaptureDefault CaptureDefault,
           SourceLocation CaptureDefaultLoc, ArrayRef<LambdaCapture> Captures,
           bool ExplicitParams, bool ExplicitResultType,
           ArrayRef<Expr *> CaptureInits, SourceLocation ClosingBrace,
           bool ContainsUnexpandedParameterPack);

/// Construct an empty lambda expression.
LambdaExpr(EmptyShell Empty, unsigned NumCaptures)
    : Expr(LambdaExprClass, Empty), NumCaptures(NumCaptures),
      CaptureDefault(LCD_None), ExplicitParams(false),
      ExplicitResultType(false) {
  getStoredStmts()[NumCaptures] = nullptr;
}

Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }

Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }

1636public:
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// Construct a new lambda expression.
static LambdaExpr *
Create(const ASTContext &C, CXXRecordDecl *Class, SourceRange IntroducerRange,
       LambdaCaptureDefault CaptureDefault, SourceLocation CaptureDefaultLoc,
       ArrayRef<LambdaCapture> Captures, bool ExplicitParams,
       bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
       SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack);

/// Construct a new lambda expression that will be deserialized from
/// an external source.
static LambdaExpr *CreateDeserialized(const ASTContext &C,
                                      unsigned NumCaptures);

/// Determine the default capture kind for this lambda.
LambdaCaptureDefault getCaptureDefault() const {
  return static_cast<LambdaCaptureDefault>(CaptureDefault);
}

/// Retrieve the location of this lambda's capture-default, if any.
SourceLocation getCaptureDefaultLoc() const {
  return CaptureDefaultLoc;
}

/// Determine whether one of this lambda's captures is an init-capture.
bool isInitCapture(const LambdaCapture *Capture) const;

/// An iterator that walks over the captures of the lambda,
/// both implicit and explicit.
using capture_iterator = const LambdaCapture *;

/// An iterator over a range of lambda captures.
using capture_range = llvm::iterator_range<capture_iterator>;

/// Retrieve this lambda's captures.
capture_range captures() const;

/// Retrieve an iterator pointing to the first lambda capture.
capture_iterator capture_begin() const;

/// Retrieve an iterator pointing past the end of the
/// sequence of lambda captures.
capture_iterator capture_end() const;

/// Determine the number of captures in this lambda.
unsigned capture_size() const { return NumCaptures; }

/// Retrieve this lambda's explicit captures.
capture_range explicit_captures() const;

/// Retrieve an iterator pointing to the first explicit
/// lambda capture.
capture_iterator explicit_capture_begin() const;

/// Retrieve an iterator pointing past the end of the sequence of
/// explicit lambda captures.
capture_iterator explicit_capture_end() const;

/// Retrieve this lambda's implicit captures.
capture_range implicit_captures() const;

/// Retrieve an iterator pointing to the first implicit
/// lambda capture.
capture_iterator implicit_capture_begin() const;

/// Retrieve an iterator pointing past the end of the sequence of
/// implicit lambda captures.
capture_iterator implicit_capture_end() const;

/// Iterator that walks over the capture initialization
/// arguments.
using capture_init_iterator = Expr **;

/// Const iterator that walks over the capture initialization
/// arguments.
using const_capture_init_iterator = Expr *const *;

/// Retrieve the initialization expressions for this lambda's captures.
llvm::iterator_range<capture_init_iterator> capture_inits() {
  return llvm::make_range(capture_init_begin(), capture_init_end());
}

/// Retrieve the initialization expressions for this lambda's captures.
llvm::iterator_range<const_capture_init_iterator> capture_inits() const {
  return llvm::make_range(capture_init_begin(), capture_init_end());
}

/// Retrieve the first initialization argument for this
/// lambda expression (which initializes the first capture field).
capture_init_iterator capture_init_begin() {
  return reinterpret_cast<Expr **>(getStoredStmts());
}

/// Retrieve the first initialization argument for this
/// lambda expression (which initializes the first capture field).
const_capture_init_iterator capture_init_begin() const {
  return reinterpret_cast<Expr *const *>(getStoredStmts());
}

/// Retrieve the iterator pointing one past the last
/// initialization argument for this lambda expression.
capture_init_iterator capture_init_end() {
  return capture_init_begin() + NumCaptures;
}

/// Retrieve the iterator pointing one past the last
/// initialization argument for this lambda expression.
const_capture_init_iterator capture_init_end() const {
  return capture_init_begin() + NumCaptures;
}

/// Retrieve the source range covering the lambda introducer,
/// which contains the explicit capture list surrounded by square
/// brackets ([...]).
SourceRange getIntroducerRange() const { return IntroducerRange; }

/// Retrieve the class that corresponds to the lambda.
/// 
/// This is the "closure type" (C++1y [expr.prim.lambda]), and stores the
/// captures in its fields and provides the various operations permitted
/// on a lambda (copying, calling).
CXXRecordDecl *getLambdaClass() const;

/// Retrieve the function call operator associated with this
/// lambda expression. 
CXXMethodDecl *getCallOperator() const;

/// If this is a generic lambda expression, retrieve the template 
/// parameter list associated with it, or else return null. 
TemplateParameterList *getTemplateParameterList() const;

/// Whether this is a generic lambda.
bool isGenericLambda() const { return getTemplateParameterList(); }

/// Retrieve the body of the lambda.
CompoundStmt *getBody() const;

/// Determine whether the lambda is mutable, meaning that any
/// captures values can be modified.
bool isMutable() const;

/// Determine whether this lambda has an explicit parameter
/// list vs. an implicit (empty) parameter list.
bool hasExplicitParameters() const { return ExplicitParams; }

/// Whether this lambda had its result type explicitly specified.
bool hasExplicitResultType() const { return ExplicitResultType; }
  
static bool classof(const Stmt *T) {
  return T->getStmtClass() == LambdaExprClass;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return IntroducerRange.getBegin();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return ClosingBrace; }

child_range children() {
  // Includes initialization exprs plus body stmt
  return child_range(getStoredStmts(), getStoredStmts() + NumCaptures + 1);
}
1802};

1804/// An expression "T()" which creates a value-initialized rvalue of type
1805/// T, which is a non-class type.  See (C++98 [5.2.3p2]).
1806class CXXScalarValueInitExpr : public Expr {
friend class ASTStmtReader;

SourceLocation RParenLoc;
TypeSourceInfo *TypeInfo;

1812public:
/// Create an explicitly-written scalar-value initialization
/// expression.
CXXScalarValueInitExpr(QualType Type, TypeSourceInfo *TypeInfo,
                       SourceLocation rParenLoc)
    : Expr(CXXScalarValueInitExprClass, Type, VK_RValue, OK_Ordinary,
           false, false, Type->isInstantiationDependentType(),
           Type->containsUnexpandedParameterPack()),
      RParenLoc(rParenLoc), TypeInfo(TypeInfo) {}

explicit CXXScalarValueInitExpr(EmptyShell Shell)
    : Expr(CXXScalarValueInitExprClass, Shell) {}

TypeSourceInfo *getTypeSourceInfo() const {
  return TypeInfo;
}

SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXScalarValueInitExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
1842};

1844/// Represents a new-expression for memory allocation and constructor
1845/// calls, e.g: "new CXXNewExpr(foo)".
1846class CXXNewExpr : public Expr {
friend class ASTStmtReader;
friend class ASTStmtWriter;

/// Contains an optional array size expression, an optional initialization
/// expression, and any number of optional placement arguments, in that order.
Stmt **SubExprs = nullptr;

/// Points to the allocation function used.
FunctionDecl *OperatorNew;

/// Points to the deallocation function used in case of error. May be
/// null.
FunctionDecl *OperatorDelete;

/// The allocated type-source information, as written in the source.
TypeSourceInfo *AllocatedTypeInfo;

/// If the allocated type was expressed as a parenthesized type-id,
/// the source range covering the parenthesized type-id.
SourceRange TypeIdParens;

/// Range of the entire new expression.
SourceRange Range;

/// Source-range of a paren-delimited initializer.
SourceRange DirectInitRange;

/// Was the usage ::new, i.e. is the global new to be used?
unsigned GlobalNew : 1;

/// Do we allocate an array? If so, the first SubExpr is the size expression.
unsigned Array : 1;

/// Should the alignment be passed to the allocation function?
unsigned PassAlignment : 1;

/// If this is an array allocation, does the usual deallocation
/// function for the allocated type want to know the allocated size?
unsigned UsualArrayDeleteWantsSize : 1;

/// The number of placement new arguments.
unsigned NumPlacementArgs : 26;

/// What kind of initializer do we have? Could be none, parens, or braces.
/// In storage, we distinguish between "none, and no initializer expr", and
/// "none, but an implicit initializer expr".
unsigned StoredInitializationStyle : 2;

1895public:
enum InitializationStyle {
  /// New-expression has no initializer as written.
  NoInit,

  /// New-expression has a C++98 paren-delimited initializer.
  CallInit,

  /// New-expression has a C++11 list-initializer.
  ListInit
};

CXXNewExpr(const ASTContext &C, bool globalNew, FunctionDecl *operatorNew,
           FunctionDecl *operatorDelete, bool PassAlignment,
           bool usualArrayDeleteWantsSize, ArrayRef<Expr*> placementArgs,
           SourceRange typeIdParens, Expr *arraySize,
           InitializationStyle initializationStyle, Expr *initializer,
           QualType ty, TypeSourceInfo *AllocatedTypeInfo,
           SourceRange Range, SourceRange directInitRange);
explicit CXXNewExpr(EmptyShell Shell)
    : Expr(CXXNewExprClass, Shell) {}

void AllocateArgsArray(const ASTContext &C, bool isArray,
                       unsigned numPlaceArgs, bool hasInitializer);

QualType getAllocatedType() const {
  assert(getType()->isPointerType())(static_cast <bool> (getType()->isPointerType()) ? void
 (0) : __assert_fail ("getType()->isPointerType()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 1921, __extension__ __PRETTY_FUNCTION__));
  return getType()->getAs<PointerType>()->getPointeeType();
}

TypeSourceInfo *getAllocatedTypeSourceInfo() const {
  return AllocatedTypeInfo;
}

/// True if the allocation result needs to be null-checked.
///
/// C++11 [expr.new]p13:
///   If the allocation function returns null, initialization shall
///   not be done, the deallocation function shall not be called,
///   and the value of the new-expression shall be null.
///
/// C++ DR1748:
///   If the allocation function is a reserved placement allocation
///   function that returns null, the behavior is undefined.
///
/// An allocation function is not allowed to return null unless it
/// has a non-throwing exception-specification.  The '03 rule is
/// identical except that the definition of a non-throwing
/// exception specification is just "is it throw()?".
bool shouldNullCheckAllocation(const ASTContext &Ctx) const;

FunctionDecl *getOperatorNew() const { return OperatorNew; }
void setOperatorNew(FunctionDecl *D) { OperatorNew = D; }
FunctionDecl *getOperatorDelete() const { return OperatorDelete; }
void setOperatorDelete(FunctionDecl *D) { OperatorDelete = D; }

bool isArray() const { return Array; }

Expr *getArraySize() {
  return Array ? cast<Expr>(SubExprs[0]) : nullptr;
}
const Expr *getArraySize() const {
  return Array ? cast<Expr>(SubExprs[0]) : nullptr;
}

unsigned getNumPlacementArgs() const { return NumPlacementArgs; }

Expr **getPlacementArgs() {
  return reinterpret_cast<Expr **>(SubExprs + Array + hasInitializer());
}

Expr *getPlacementArg(unsigned i) {
  assert(i < NumPlacementArgs && "Index out of range")(static_cast <bool> (i < NumPlacementArgs &&
 "Index out of range") ? void (0) : __assert_fail ("i < NumPlacementArgs && \"Index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 1967, __extension__ __PRETTY_FUNCTION__));
  return getPlacementArgs()[i];
}
const Expr *getPlacementArg(unsigned i) const {
  assert(i < NumPlacementArgs && "Index out of range")(static_cast <bool> (i < NumPlacementArgs &&
 "Index out of range") ? void (0) : __assert_fail ("i < NumPlacementArgs && \"Index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 1971, __extension__ __PRETTY_FUNCTION__));
  return const_cast<CXXNewExpr*>(this)->getPlacementArg(i);
}

bool isParenTypeId() const { return TypeIdParens.isValid(); }
SourceRange getTypeIdParens() const { return TypeIdParens; }

bool isGlobalNew() const { return GlobalNew; }

/// Whether this new-expression has any initializer at all.
bool hasInitializer() const { return StoredInitializationStyle > 0; }

/// The kind of initializer this new-expression has.
InitializationStyle getInitializationStyle() const {
  if (StoredInitializationStyle == 0)
    return NoInit;
  return static_cast<InitializationStyle>(StoredInitializationStyle-1);
}

/// The initializer of this new-expression.
Expr *getInitializer() {
  return hasInitializer() ? cast<Expr>(SubExprs[Array]) : nullptr;
}
const Expr *getInitializer() const {
  return hasInitializer() ? cast<Expr>(SubExprs[Array]) : nullptr;
}

/// Returns the CXXConstructExpr from this new-expression, or null.
const CXXConstructExpr *getConstructExpr() const {
  return dyn_cast_or_null<CXXConstructExpr>(getInitializer());
}

/// Indicates whether the required alignment should be implicitly passed to
/// the allocation function.
bool passAlignment() const {
  return PassAlignment;
}

/// Answers whether the usual array deallocation function for the
/// allocated type expects the size of the allocation as a
/// parameter.
bool doesUsualArrayDeleteWantSize() const {
  return UsualArrayDeleteWantsSize;
}

using arg_iterator = ExprIterator;
using const_arg_iterator = ConstExprIterator;

llvm::iterator_range<arg_iterator> placement_arguments() {
  return llvm::make_range(placement_arg_begin(), placement_arg_end());
}

llvm::iterator_range<const_arg_iterator> placement_arguments() const {
  return llvm::make_range(placement_arg_begin(), placement_arg_end());
}

arg_iterator placement_arg_begin() {
  return SubExprs + Array + hasInitializer();
}
arg_iterator placement_arg_end() {
  return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
}
const_arg_iterator placement_arg_begin() const {
  return SubExprs + Array + hasInitializer();
}
const_arg_iterator placement_arg_end() const {
  return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
}

using raw_arg_iterator = Stmt **;

raw_arg_iterator raw_arg_begin() { return SubExprs; }
raw_arg_iterator raw_arg_end() {
  return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
}
const_arg_iterator raw_arg_begin() const { return SubExprs; }
const_arg_iterator raw_arg_end() const {
  return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
}

SourceLocation getStartLoc() const { return Range.getBegin(); }
SourceLocation getEndLoc() const { return Range.getEnd(); }

SourceRange getDirectInitRange() const { return DirectInitRange; }

SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  return Range;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return getStartLoc(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return getEndLoc(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXNewExprClass;
}

// Iterators
child_range children() {
  return child_range(raw_arg_begin(), raw_arg_end());
}
2071};

2073/// Represents a \c delete expression for memory deallocation and
2074/// destructor calls, e.g. "delete[] pArray".
2075class CXXDeleteExpr : public Expr {
/// Points to the operator delete overload that is used. Could be a member.
FunctionDecl *OperatorDelete = nullptr;

/// The pointer expression to be deleted.
Stmt *Argument = nullptr;

/// Location of the expression.
SourceLocation Loc;

/// Is this a forced global delete, i.e. "::delete"?
bool GlobalDelete : 1;

/// Is this the array form of delete, i.e. "delete[]"?
bool ArrayForm : 1;

/// ArrayFormAsWritten can be different from ArrayForm if 'delete' is applied
/// to pointer-to-array type (ArrayFormAsWritten will be false while ArrayForm
/// will be true).
bool ArrayFormAsWritten : 1;

/// Does the usual deallocation function for the element type require
/// a size_t argument?
bool UsualArrayDeleteWantsSize : 1;

2100public:
friend class ASTStmtReader;

CXXDeleteExpr(QualType ty, bool globalDelete, bool arrayForm,
              bool arrayFormAsWritten, bool usualArrayDeleteWantsSize,
              FunctionDecl *operatorDelete, Expr *arg, SourceLocation loc)
    : Expr(CXXDeleteExprClass, ty, VK_RValue, OK_Ordinary, false, false,
           arg->isInstantiationDependent(),
22
←
Called C++ object pointer is null
           arg->containsUnexpandedParameterPack()),
      OperatorDelete(operatorDelete), Argument(arg), Loc(loc),
      GlobalDelete(globalDelete),
      ArrayForm(arrayForm), ArrayFormAsWritten(arrayFormAsWritten),
      UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) {}
explicit CXXDeleteExpr(EmptyShell Shell) : Expr(CXXDeleteExprClass, Shell) {}

bool isGlobalDelete() const { return GlobalDelete; }
bool isArrayForm() const { return ArrayForm; }
bool isArrayFormAsWritten() const { return ArrayFormAsWritten; }

/// Answers whether the usual array deallocation function for the
/// allocated type expects the size of the allocation as a
/// parameter.  This can be true even if the actual deallocation
/// function that we're using doesn't want a size.
bool doesUsualArrayDeleteWantSize() const {
  return UsualArrayDeleteWantsSize;
}

FunctionDecl *getOperatorDelete() const { return OperatorDelete; }

Expr *getArgument() { return cast<Expr>(Argument); }
const Expr *getArgument() const { return cast<Expr>(Argument); }

/// Retrieve the type being destroyed. 
///
/// If the type being destroyed is a dependent type which may or may not
/// be a pointer, return an invalid type.
QualType getDestroyedType() const;

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {return Argument->getLocEnd();}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXDeleteExprClass;
}

// Iterators
child_range children() { return child_range(&Argument, &Argument+1); }
2147};

2149/// Stores the type being destroyed by a pseudo-destructor expression.
2150class PseudoDestructorTypeStorage {
/// Either the type source information or the name of the type, if
/// it couldn't be resolved due to type-dependence.
llvm::PointerUnion<TypeSourceInfo *, IdentifierInfo *> Type;

/// The starting source location of the pseudo-destructor type.
SourceLocation Location;

2158public:
PseudoDestructorTypeStorage() = default;

PseudoDestructorTypeStorage(IdentifierInfo *II, SourceLocation Loc)
    : Type(II), Location(Loc) {}

PseudoDestructorTypeStorage(TypeSourceInfo *Info);

TypeSourceInfo *getTypeSourceInfo() const {
  return Type.dyn_cast<TypeSourceInfo *>();
}

IdentifierInfo *getIdentifier() const {
  return Type.dyn_cast<IdentifierInfo *>();
}

SourceLocation getLocation() const { return Location; }
2175};

2177/// Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
2178///
2179/// A pseudo-destructor is an expression that looks like a member access to a
2180/// destructor of a scalar type, except that scalar types don't have
2181/// destructors. For example:
2182///
2183/// \code
2184/// typedef int T;
2185/// void f(int *p) {
2186///   p->T::~T();
2187/// }
2188/// \endcode
2189///
2190/// Pseudo-destructors typically occur when instantiating templates such as:
2191///
2192/// \code
2193/// template<typename T>
2194/// void destroy(T* ptr) {
2195///   ptr->T::~T();
2196/// }
2197/// \endcode
2198///
2199/// for scalar types. A pseudo-destructor expression has no run-time semantics
2200/// beyond evaluating the base expression.
2201class CXXPseudoDestructorExpr : public Expr {
friend class ASTStmtReader;

/// The base expression (that is being destroyed).
Stmt *Base = nullptr;

/// Whether the operator was an arrow ('->'); otherwise, it was a
/// period ('.').
bool IsArrow : 1;

/// The location of the '.' or '->' operator.
SourceLocation OperatorLoc;

/// The nested-name-specifier that follows the operator, if present.
NestedNameSpecifierLoc QualifierLoc;

/// The type that precedes the '::' in a qualified pseudo-destructor
/// expression.
TypeSourceInfo *ScopeType = nullptr;

/// The location of the '::' in a qualified pseudo-destructor
/// expression.
SourceLocation ColonColonLoc;

/// The location of the '~'.
SourceLocation TildeLoc;

/// The type being destroyed, or its name if we were unable to
/// resolve the name.
PseudoDestructorTypeStorage DestroyedType;

2232public:
CXXPseudoDestructorExpr(const ASTContext &Context,
                        Expr *Base, bool isArrow, SourceLocation OperatorLoc,
                        NestedNameSpecifierLoc QualifierLoc,
                        TypeSourceInfo *ScopeType,
                        SourceLocation ColonColonLoc,
                        SourceLocation TildeLoc,
                        PseudoDestructorTypeStorage DestroyedType);

explicit CXXPseudoDestructorExpr(EmptyShell Shell)
    : Expr(CXXPseudoDestructorExprClass, Shell), IsArrow(false) {}

Expr *getBase() const { return cast<Expr>(Base); }

/// 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 QualifierLoc.hasQualifier(); }

/// Retrieves the nested-name-specifier that qualifies the type name,
/// with source-location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// If the member name was qualified, retrieves the
/// nested-name-specifier that precedes the member name. Otherwise, returns
/// null.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

/// Determine whether this pseudo-destructor expression was written
/// using an '->' (otherwise, it used a '.').
bool isArrow() const { return IsArrow; }

/// Retrieve the location of the '.' or '->' operator.
SourceLocation getOperatorLoc() const { return OperatorLoc; }

/// Retrieve the scope type in a qualified pseudo-destructor
/// expression.
///
/// Pseudo-destructor expressions can have extra qualification within them
/// that is not part of the nested-name-specifier, e.g., \c p->T::~T().
/// Here, if the object type of the expression is (or may be) a scalar type,
/// \p T may also be a scalar type and, therefore, cannot be part of a
/// nested-name-specifier. It is stored as the "scope type" of the pseudo-
/// destructor expression.
TypeSourceInfo *getScopeTypeInfo() const { return ScopeType; }

/// Retrieve the location of the '::' in a qualified pseudo-destructor
/// expression.
SourceLocation getColonColonLoc() const { return ColonColonLoc; }

/// Retrieve the location of the '~'.
SourceLocation getTildeLoc() const { return TildeLoc; }

/// Retrieve the source location information for the type
/// being destroyed.
///
/// This type-source information is available for non-dependent
/// pseudo-destructor expressions and some dependent pseudo-destructor
/// expressions. Returns null if we only have the identifier for a
/// dependent pseudo-destructor expression.
TypeSourceInfo *getDestroyedTypeInfo() const {
  return DestroyedType.getTypeSourceInfo();
}

/// In a dependent pseudo-destructor expression for which we do not
/// have full type information on the destroyed type, provides the name
/// of the destroyed type.
IdentifierInfo *getDestroyedTypeIdentifier() const {
  return DestroyedType.getIdentifier();
}

/// Retrieve the type being destroyed.
QualType getDestroyedType() const;

/// Retrieve the starting location of the type being destroyed.
SourceLocation getDestroyedTypeLoc() const {
  return DestroyedType.getLocation();
}

/// Set the name of destroyed type for a dependent pseudo-destructor
/// expression.
void setDestroyedType(IdentifierInfo *II, SourceLocation Loc) {
  DestroyedType = PseudoDestructorTypeStorage(II, Loc);
}

/// Set the destroyed type.
void setDestroyedType(TypeSourceInfo *Info) {
  DestroyedType = PseudoDestructorTypeStorage(Info);
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {return Base->getLocStart();}
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXPseudoDestructorExprClass;
}

// Iterators
child_range children() { return child_range(&Base, &Base + 1); }
2333};

2335/// A type trait used in the implementation of various C++11 and
2336/// Library TR1 trait templates.
2337///
2338/// \code
2339///   __is_pod(int) == true
2340///   __is_enum(std::string) == false
2341///   __is_trivially_constructible(vector<int>, int*, int*)
2342/// \endcode
2343class TypeTraitExpr final
  : public Expr,
    private llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> {
/// The location of the type trait keyword.
SourceLocation Loc;

///  The location of the closing parenthesis.
SourceLocation RParenLoc;

// Note: The TypeSourceInfos for the arguments are allocated after the
// TypeTraitExpr.

TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
              ArrayRef<TypeSourceInfo *> Args,
              SourceLocation RParenLoc,
              bool Value);

TypeTraitExpr(EmptyShell Empty) : Expr(TypeTraitExprClass, Empty) {}

size_t numTrailingObjects(OverloadToken<TypeSourceInfo *>) const {
  return getNumArgs();
}

2366public:
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// Create a new type trait expression.
static TypeTraitExpr *Create(const ASTContext &C, QualType T,
                             SourceLocation Loc, TypeTrait Kind,
                             ArrayRef<TypeSourceInfo *> Args,
                             SourceLocation RParenLoc,
                             bool Value);

static TypeTraitExpr *CreateDeserialized(const ASTContext &C,
                                         unsigned NumArgs);

/// Determine which type trait this expression uses.
TypeTrait getTrait() const {
  return static_cast<TypeTrait>(TypeTraitExprBits.Kind);
}

bool getValue() const { 
  assert(!isValueDependent())(static_cast <bool> (!isValueDependent()) ? void (0) : __assert_fail
 ("!isValueDependent()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 2387, __extension__ __PRETTY_FUNCTION__)); 
  return TypeTraitExprBits.Value; 
}

/// Determine the number of arguments to this type trait.
unsigned getNumArgs() const { return TypeTraitExprBits.NumArgs; }

/// Retrieve the Ith argument.
TypeSourceInfo *getArg(unsigned I) const {
  assert(I < getNumArgs() && "Argument out-of-range")(static_cast <bool> (I < getNumArgs() && "Argument out-of-range"
) ? void (0) : __assert_fail ("I < getNumArgs() && \"Argument out-of-range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 2396, __extension__ __PRETTY_FUNCTION__));
  return getArgs()[I];
}

/// Retrieve the argument types.
ArrayRef<TypeSourceInfo *> getArgs() const {
  return llvm::makeArrayRef(getTrailingObjects<TypeSourceInfo *>(),
                            getNumArgs());
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == TypeTraitExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
2417};

2419/// An Embarcadero array type trait, as used in the implementation of
2420/// __array_rank and __array_extent.
2421///
2422/// Example:
2423/// \code
2424///   __array_rank(int[10][20]) == 2
2425///   __array_extent(int, 1)    == 20
2426/// \endcode
2427class ArrayTypeTraitExpr : public Expr {
/// The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
unsigned ATT : 2;

/// The value of the type trait. Unspecified if dependent.
uint64_t Value = 0;

/// The array dimension being queried, or -1 if not used.
Expr *Dimension;

/// The location of the type trait keyword.
SourceLocation Loc;

/// The location of the closing paren.
SourceLocation RParen;

/// The type being queried.
TypeSourceInfo *QueriedType = nullptr;

virtual void anchor();

2448public:
friend class ASTStmtReader;

ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att,
                   TypeSourceInfo *queried, uint64_t value,
                   Expr *dimension, SourceLocation rparen, QualType ty)
    : Expr(ArrayTypeTraitExprClass, ty, VK_RValue, OK_Ordinary,
           false, queried->getType()->isDependentType(),
           (queried->getType()->isInstantiationDependentType() ||
            (dimension && dimension->isInstantiationDependent())),
           queried->getType()->containsUnexpandedParameterPack()),
      ATT(att), Value(value), Dimension(dimension),
      Loc(loc), RParen(rparen), QueriedType(queried) {}

explicit ArrayTypeTraitExpr(EmptyShell Empty)
    : Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {}

virtual ~ArrayTypeTraitExpr() = default;

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParen; }

ArrayTypeTrait getTrait() const { return static_cast<ArrayTypeTrait>(ATT); }

QualType getQueriedType() const { return QueriedType->getType(); }

TypeSourceInfo *getQueriedTypeSourceInfo() const { return QueriedType; }

uint64_t getValue() const { assert(!isTypeDependent())(static_cast <bool> (!isTypeDependent()) ? void (0) : __assert_fail
 ("!isTypeDependent()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 2476, __extension__ __PRETTY_FUNCTION__)); return Value; }

Expr *getDimensionExpression() const { return Dimension; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ArrayTypeTraitExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
2488};

2490/// An expression trait intrinsic.
2491///
2492/// Example:
2493/// \code
2494///   __is_lvalue_expr(std::cout) == true
2495///   __is_lvalue_expr(1) == false
2496/// \endcode
2497class ExpressionTraitExpr : public Expr {
/// The trait. A ExpressionTrait enum in MSVC compatible unsigned.
unsigned ET : 31;

/// The value of the type trait. Unspecified if dependent.
unsigned Value : 1;

/// The location of the type trait keyword.
SourceLocation Loc;

/// The location of the closing paren.
SourceLocation RParen;

/// The expression being queried.
Expr* QueriedExpression = nullptr;

2513public:
friend class ASTStmtReader;

ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et,
                   Expr *queried, bool value,
                   SourceLocation rparen, QualType resultType)
    : Expr(ExpressionTraitExprClass, resultType, VK_RValue, OK_Ordinary,
           false, // Not type-dependent
           // Value-dependent if the argument is type-dependent.
           queried->isTypeDependent(),
           queried->isInstantiationDependent(),
           queried->containsUnexpandedParameterPack()),
      ET(et), Value(value), Loc(loc), RParen(rparen),
      QueriedExpression(queried) {}

explicit ExpressionTraitExpr(EmptyShell Empty)
    : Expr(ExpressionTraitExprClass, Empty), ET(0), Value(false) {}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return RParen; }

ExpressionTrait getTrait() const { return static_cast<ExpressionTrait>(ET); }

Expr *getQueriedExpression() const { return QueriedExpression; }

bool getValue() const { return Value; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ExpressionTraitExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
2548};

2550/// A reference to an overloaded function set, either an
2551/// \c UnresolvedLookupExpr or an \c UnresolvedMemberExpr.
2552class OverloadExpr : public Expr {
/// The common name of these declarations.
DeclarationNameInfo NameInfo;

/// The nested-name-specifier that qualifies the name, if any.
NestedNameSpecifierLoc QualifierLoc;

/// The results.  These are undesugared, which is to say, they may
/// include UsingShadowDecls.  Access is relative to the naming
/// class.
// FIXME: Allocate this data after the OverloadExpr subclass.
DeclAccessPair *Results = nullptr;

unsigned NumResults = 0;

2567protected:
/// Whether the name includes info for explicit template
/// keyword and arguments.
bool HasTemplateKWAndArgsInfo = false;

OverloadExpr(StmtClass K, const ASTContext &C,
             NestedNameSpecifierLoc QualifierLoc,
             SourceLocation TemplateKWLoc,
             const DeclarationNameInfo &NameInfo,
             const TemplateArgumentListInfo *TemplateArgs,
             UnresolvedSetIterator Begin, UnresolvedSetIterator End,
             bool KnownDependent,
             bool KnownInstantiationDependent,
             bool KnownContainsUnexpandedParameterPack);

OverloadExpr(StmtClass K, EmptyShell Empty) : Expr(K, Empty) {}

/// Return the optional template keyword and arguments info.
ASTTemplateKWAndArgsInfo *
getTrailingASTTemplateKWAndArgsInfo(); // defined far below.

/// Return the optional template keyword and arguments info.
const ASTTemplateKWAndArgsInfo *getTrailingASTTemplateKWAndArgsInfo() const {
  return const_cast<OverloadExpr *>(this)
      ->getTrailingASTTemplateKWAndArgsInfo();
}

/// Return the optional template arguments.
TemplateArgumentLoc *getTrailingTemplateArgumentLoc(); // defined far below

void initializeResults(const ASTContext &C,
                       UnresolvedSetIterator Begin,
                       UnresolvedSetIterator End);

2601public:
friend class ASTStmtReader;
friend class ASTStmtWriter;

struct FindResult {
  OverloadExpr *Expression;
  bool IsAddressOfOperand;
  bool HasFormOfMemberPointer;
};

/// Finds the overloaded expression in the given expression \p E of
/// OverloadTy.
///
/// \return the expression (which must be there) and true if it has
/// the particular form of a member pointer expression
static FindResult find(Expr *E) {
  assert(E->getType()->isSpecificBuiltinType(BuiltinType::Overload))(static_cast <bool> (E->getType()->isSpecificBuiltinType
(BuiltinType::Overload)) ? void (0) : __assert_fail ("E->getType()->isSpecificBuiltinType(BuiltinType::Overload)"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 2617, __extension__ __PRETTY_FUNCTION__));

  FindResult Result;

  E = E->IgnoreParens();
  if (isa<UnaryOperator>(E)) {
    assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf)(static_cast <bool> (cast<UnaryOperator>(E)->getOpcode
() == UO_AddrOf) ? void (0) : __assert_fail ("cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 2623, __extension__ __PRETTY_FUNCTION__));
    E = cast<UnaryOperator>(E)->getSubExpr();
    auto *Ovl = cast<OverloadExpr>(E->IgnoreParens());

    Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier());
    Result.IsAddressOfOperand = true;
    Result.Expression = Ovl;
  } else {
    Result.HasFormOfMemberPointer = false;
    Result.IsAddressOfOperand = false;
    Result.Expression = cast<OverloadExpr>(E);
  }

  return Result;
}

/// Gets the naming class of this lookup, if any.
CXXRecordDecl *getNamingClass() const;

using decls_iterator = UnresolvedSetImpl::iterator;

decls_iterator decls_begin() const { return UnresolvedSetIterator(Results); }
decls_iterator decls_end() const {
  return UnresolvedSetIterator(Results + NumResults);
}
llvm::iterator_range<decls_iterator> decls() const {
  return llvm::make_range(decls_begin(), decls_end());
}

/// Gets the number of declarations in the unresolved set.
unsigned getNumDecls() const { return NumResults; }

/// Gets the full name info.
const DeclarationNameInfo &getNameInfo() const { return NameInfo; }

/// Gets the name looked up.
DeclarationName getName() const { return NameInfo.getName(); }

/// Gets the location of the name.
SourceLocation getNameLoc() const { return NameInfo.getLoc(); }

/// Fetches the nested-name qualifier, if one was given.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

/// Fetches the nested-name qualifier with source-location
/// information, if one was given.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// Retrieve the location of the template keyword preceding
/// this name, if any.
SourceLocation getTemplateKeywordLoc() const {
  if (!HasTemplateKWAndArgsInfo) return SourceLocation();
  return getTrailingASTTemplateKWAndArgsInfo()->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 getTrailingASTTemplateKWAndArgsInfo()->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 getTrailingASTTemplateKWAndArgsInfo()->RAngleLoc;
}

/// Determines whether the name was preceded by the template keyword.
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }

/// Determines whether this expression had explicit template arguments.
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }

TemplateArgumentLoc const *getTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return nullptr;
  return const_cast<OverloadExpr *>(this)->getTrailingTemplateArgumentLoc();
}

unsigned getNumTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return 0;

  return getTrailingASTTemplateKWAndArgsInfo()->NumTemplateArgs;
}

ArrayRef<TemplateArgumentLoc> template_arguments() const {
  return {getTemplateArgs(), getNumTemplateArgs()};
}

/// Copies the template arguments into the given structure.
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
  if (hasExplicitTemplateArgs())
    getTrailingASTTemplateKWAndArgsInfo()->copyInto(getTemplateArgs(), List);
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnresolvedLookupExprClass ||
         T->getStmtClass() == UnresolvedMemberExprClass;
}
2727};

2729/// A reference to a name which we were able to look up during
2730/// parsing but could not resolve to a specific declaration.
2731///
2732/// This arises in several ways:
2733///   * we might be waiting for argument-dependent lookup;
2734///   * the name might resolve to an overloaded function;
2735/// and eventually:
2736///   * the lookup might have included a function template.
2737///
2738/// These never include UnresolvedUsingValueDecls, which are always class
2739/// members and therefore appear only in UnresolvedMemberLookupExprs.
2740class UnresolvedLookupExpr final
  : public OverloadExpr,
    private llvm::TrailingObjects<
        UnresolvedLookupExpr, ASTTemplateKWAndArgsInfo, TemplateArgumentLoc> {
friend class ASTStmtReader;
friend class OverloadExpr;
friend TrailingObjects;

/// True if these lookup results should be extended by
/// argument-dependent lookup if this is the operand of a function
/// call.
bool RequiresADL = false;

/// True if these lookup results are overloaded.  This is pretty
/// trivially rederivable if we urgently need to kill this field.
bool Overloaded = false;

/// The naming class (C++ [class.access.base]p5) of the lookup, if
/// any.  This can generally be recalculated from the context chain,
/// but that can be fairly expensive for unqualified lookups.  If we
/// want to improve memory use here, this could go in a union
/// against the qualified-lookup bits.
CXXRecordDecl *NamingClass = nullptr;

UnresolvedLookupExpr(const ASTContext &C,
                     CXXRecordDecl *NamingClass,
                     NestedNameSpecifierLoc QualifierLoc,
                     SourceLocation TemplateKWLoc,
                     const DeclarationNameInfo &NameInfo,
                     bool RequiresADL, bool Overloaded,
                     const TemplateArgumentListInfo *TemplateArgs,
                     UnresolvedSetIterator Begin, UnresolvedSetIterator End)
    : OverloadExpr(UnresolvedLookupExprClass, C, QualifierLoc, TemplateKWLoc,
                   NameInfo, TemplateArgs, Begin, End, false, false, false),
      RequiresADL(RequiresADL),
      Overloaded(Overloaded), NamingClass(NamingClass) {}

UnresolvedLookupExpr(EmptyShell Empty)
    : OverloadExpr(UnresolvedLookupExprClass, Empty) {}

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return HasTemplateKWAndArgsInfo ? 1 : 0;
}

2784public:
static UnresolvedLookupExpr *Create(const ASTContext &C,
                                    CXXRecordDecl *NamingClass,
                                    NestedNameSpecifierLoc QualifierLoc,
                                    const DeclarationNameInfo &NameInfo,
                                    bool ADL, bool Overloaded,
                                    UnresolvedSetIterator Begin,
                                    UnresolvedSetIterator End) {
  return new(C) UnresolvedLookupExpr(C, NamingClass, QualifierLoc,
                                     SourceLocation(), NameInfo,
                                     ADL, Overloaded, nullptr, Begin, End);
}

static UnresolvedLookupExpr *Create(const ASTContext &C,
                                    CXXRecordDecl *NamingClass,
                                    NestedNameSpecifierLoc QualifierLoc,
                                    SourceLocation TemplateKWLoc,
                                    const DeclarationNameInfo &NameInfo,
                                    bool ADL,
                                    const TemplateArgumentListInfo *Args,
                                    UnresolvedSetIterator Begin,
                                    UnresolvedSetIterator End);

static UnresolvedLookupExpr *CreateEmpty(const ASTContext &C,
                                         bool HasTemplateKWAndArgsInfo,
                                         unsigned NumTemplateArgs);

/// True if this declaration should be extended by
/// argument-dependent lookup.
bool requiresADL() const { return RequiresADL; }

/// True if this lookup is overloaded.
bool isOverloaded() const { return Overloaded; }

/// Gets the 'naming class' (in the sense of C++0x
/// [class.access.base]p5) of the lookup.  This is the scope
/// that was looked in to find these results.
CXXRecordDecl *getNamingClass() const { return NamingClass; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  if (NestedNameSpecifierLoc l = getQualifierLoc())
    return l.getBeginLoc();
  return getNameInfo().getLocStart();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  if (hasExplicitTemplateArgs())
    return getRAngleLoc();
  return getNameInfo().getLocEnd();
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnresolvedLookupExprClass;
}
2842};

2844/// A qualified reference to a name whose declaration cannot
2845/// yet be resolved.
2846///
2847/// DependentScopeDeclRefExpr is similar to DeclRefExpr in that
2848/// it expresses a reference to a declaration such as
2849/// X<T>::value. The difference, however, is that an
2850/// DependentScopeDeclRefExpr node is used only within C++ templates when
2851/// the qualification (e.g., X<T>::) refers to a dependent type. In
2852/// this case, X<T>::value cannot resolve to a declaration because the
2853/// declaration will differ from one instantiation of X<T> to the
2854/// next. Therefore, DependentScopeDeclRefExpr keeps track of the
2855/// qualifier (X<T>::) and the name of the entity being referenced
2856/// ("value"). Such expressions will instantiate to a DeclRefExpr once the
2857/// declaration can be found.
2858class DependentScopeDeclRefExpr final
  : public Expr,
    private llvm::TrailingObjects<DependentScopeDeclRefExpr,
                                  ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc> {
/// The nested-name-specifier that qualifies this unresolved
/// declaration name.
NestedNameSpecifierLoc QualifierLoc;

/// The name of the entity we will be referencing.
DeclarationNameInfo NameInfo;

/// Whether the name includes info for explicit template
/// keyword and arguments.
bool HasTemplateKWAndArgsInfo;

DependentScopeDeclRefExpr(QualType T,
                          NestedNameSpecifierLoc QualifierLoc,
                          SourceLocation TemplateKWLoc,
                          const DeclarationNameInfo &NameInfo,
                          const TemplateArgumentListInfo *Args);

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return HasTemplateKWAndArgsInfo ? 1 : 0;
}

2884public:
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

static DependentScopeDeclRefExpr *Create(const ASTContext &C,
                                         NestedNameSpecifierLoc QualifierLoc,
                                         SourceLocation TemplateKWLoc,
                                         const DeclarationNameInfo &NameInfo,
                            const TemplateArgumentListInfo *TemplateArgs);

static DependentScopeDeclRefExpr *CreateEmpty(const ASTContext &C,
                                              bool HasTemplateKWAndArgsInfo,
                                              unsigned NumTemplateArgs);

/// Retrieve the name that this expression refers to.
const DeclarationNameInfo &getNameInfo() const { return NameInfo; }

/// Retrieve the name that this expression refers to.
DeclarationName getDeclName() const { return NameInfo.getName(); }

/// Retrieve the location of the name within the expression.
///
/// For example, in "X<T>::value" this is the location of "value".
SourceLocation getLocation() const { return NameInfo.getLoc(); }

/// Retrieve the nested-name-specifier that qualifies the
/// name, with source location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// Retrieve the nested-name-specifier that qualifies this
/// declaration.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

/// 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 was preceded by the template keyword.
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }

/// Determines whether this lookup had explicit template arguments.
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);
}

TemplateArgumentLoc const *getTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return nullptr;

  return getTrailingObjects<TemplateArgumentLoc>();
}

unsigned getNumTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return 0;

  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
}

ArrayRef<TemplateArgumentLoc> template_arguments() const {
  return {getTemplateArgs(), getNumTemplateArgs()};
}

/// Note: getLocStart() is the start of the whole DependentScopeDeclRefExpr,
/// and differs from getLocation().getStart().
SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return QualifierLoc.getBeginLoc();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  if (hasExplicitTemplateArgs())
    return getRAngleLoc();
  return getLocation();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DependentScopeDeclRefExprClass;
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}
2992};

2994/// Represents an expression -- generally a full-expression -- that
2995/// introduces cleanups to be run at the end of the sub-expression's
2996/// evaluation.  The most common source of expression-introduced
2997/// cleanups is temporary objects in C++, but several other kinds of
2998/// expressions can create cleanups, including basically every
2999/// call in ARC that returns an Objective-C pointer.
3000///
3001/// This expression also tracks whether the sub-expression contains a
3002/// potentially-evaluated block literal.  The lifetime of a block
3003/// literal is the extent of the enclosing scope.
3004class ExprWithCleanups final
  : public Expr,
    private llvm::TrailingObjects<ExprWithCleanups, BlockDecl *> {
3007public:
/// The type of objects that are kept in the cleanup.
/// It's useful to remember the set of blocks;  we could also
/// remember the set of temporaries, but there's currently
/// no need.
using CleanupObject = BlockDecl *;

3014private:
friend class ASTStmtReader;
friend TrailingObjects;

Stmt *SubExpr;

ExprWithCleanups(EmptyShell, unsigned NumObjects);
ExprWithCleanups(Expr *SubExpr, bool CleanupsHaveSideEffects,
                 ArrayRef<CleanupObject> Objects);

3024public:
static ExprWithCleanups *Create(const ASTContext &C, EmptyShell empty,
                                unsigned numObjects);

static ExprWithCleanups *Create(const ASTContext &C, Expr *subexpr,
                                bool CleanupsHaveSideEffects,
                                ArrayRef<CleanupObject> objects);

ArrayRef<CleanupObject> getObjects() const {
  return llvm::makeArrayRef(getTrailingObjects<CleanupObject>(),
                            getNumObjects());
}

unsigned getNumObjects() const { return ExprWithCleanupsBits.NumObjects; }

CleanupObject getObject(unsigned i) const {
  assert(i < getNumObjects() && "Index out of range")(static_cast <bool> (i < getNumObjects() && "Index out of range"
) ? void (0) : __assert_fail ("i < getNumObjects() && \"Index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3040, __extension__ __PRETTY_FUNCTION__));
  return getObjects()[i];
}

Expr *getSubExpr() { return cast<Expr>(SubExpr); }
const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }

bool cleanupsHaveSideEffects() const {
  return ExprWithCleanupsBits.CleanupsHaveSideEffects;
}

/// As with any mutator of the AST, be very careful
/// when modifying an existing AST to preserve its invariants.
void setSubExpr(Expr *E) { SubExpr = E; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getLocStart();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return SubExpr->getLocEnd();}

// Implement isa/cast/dyncast/etc.
static bool classof(const Stmt *T) {
  return T->getStmtClass() == ExprWithCleanupsClass;
}

// Iterators
child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
3068};

3070/// Describes an explicit type conversion that uses functional
3071/// notion but could not be resolved because one or more arguments are
3072/// type-dependent.
3073///
3074/// The explicit type conversions expressed by
3075/// CXXUnresolvedConstructExpr have the form <tt>T(a1, a2, ..., aN)</tt>,
3076/// where \c T is some type and \c a1, \c a2, ..., \c aN are values, and
3077/// either \c T is a dependent type or one or more of the <tt>a</tt>'s is
3078/// type-dependent. For example, this would occur in a template such
3079/// as:
3080///
3081/// \code
3082///   template<typename T, typename A1>
3083///   inline T make_a(const A1& a1) {
3084///     return T(a1);
3085///   }
3086/// \endcode
3087///
3088/// When the returned expression is instantiated, it may resolve to a
3089/// constructor call, conversion function call, or some kind of type
3090/// conversion.
3091class CXXUnresolvedConstructExpr final
  : public Expr,
    private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> {
friend class ASTStmtReader;
friend TrailingObjects;

/// The type being constructed.
TypeSourceInfo *Type = nullptr;

/// The location of the left parentheses ('(').
SourceLocation LParenLoc;

/// The location of the right parentheses (')').
SourceLocation RParenLoc;

/// The number of arguments used to construct the type.
unsigned NumArgs;

CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
                           SourceLocation LParenLoc,
                           ArrayRef<Expr*> Args,
                           SourceLocation RParenLoc);

CXXUnresolvedConstructExpr(EmptyShell Empty, unsigned NumArgs)
    : Expr(CXXUnresolvedConstructExprClass, Empty), NumArgs(NumArgs) {}

3117public:
static CXXUnresolvedConstructExpr *Create(const ASTContext &C,
                                          TypeSourceInfo *Type,
                                          SourceLocation LParenLoc,
                                          ArrayRef<Expr*> Args,
                                          SourceLocation RParenLoc);

static CXXUnresolvedConstructExpr *CreateEmpty(const ASTContext &C,
                                               unsigned NumArgs);

/// Retrieve the type that is being constructed, as specified
/// in the source code.
QualType getTypeAsWritten() const { return Type->getType(); }

/// Retrieve the type source information for the type being
/// constructed.
TypeSourceInfo *getTypeSourceInfo() const { return Type; }

/// Retrieve the location of the left parentheses ('(') that
/// precedes the argument list.
SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }

/// Retrieve the location of the right parentheses (')') that
/// follows the argument list.
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

/// Determine whether this expression models list-initialization.
/// If so, there will be exactly one subexpression, which will be
/// an InitListExpr.
bool isListInitialization() const { return LParenLoc.isInvalid(); }

/// Retrieve the number of arguments.
unsigned arg_size() const { return NumArgs; }

using arg_iterator = Expr **;

arg_iterator arg_begin() { return getTrailingObjects<Expr *>(); }
arg_iterator arg_end() { return arg_begin() + NumArgs; }

using const_arg_iterator = const Expr* const *;

const_arg_iterator arg_begin() const { return getTrailingObjects<Expr *>(); }
const_arg_iterator arg_end() const {
  return arg_begin() + NumArgs;
}

Expr *getArg(unsigned I) {
  assert(I < NumArgs && "Argument index out-of-range")(static_cast <bool> (I < NumArgs && "Argument index out-of-range"
) ? void (0) : __assert_fail ("I < NumArgs && \"Argument index out-of-range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3166, __extension__ __PRETTY_FUNCTION__));
  return *(arg_begin() + I);
}

const Expr *getArg(unsigned I) const {
  assert(I < NumArgs && "Argument index out-of-range")(static_cast <bool> (I < NumArgs && "Argument index out-of-range"
) ? void (0) : __assert_fail ("I < NumArgs && \"Argument index out-of-range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3171, __extension__ __PRETTY_FUNCTION__));
  return *(arg_begin() + I);
}

void setArg(unsigned I, Expr *E) {
  assert(I < NumArgs && "Argument index out-of-range")(static_cast <bool> (I < NumArgs && "Argument index out-of-range"
) ? void (0) : __assert_fail ("I < NumArgs && \"Argument index out-of-range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3176, __extension__ __PRETTY_FUNCTION__));
  *(arg_begin() + I) = E;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__));

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  if (!RParenLoc.isValid() && NumArgs > 0)
    return getArg(NumArgs - 1)->getLocEnd();
  return RParenLoc;
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXUnresolvedConstructExprClass;
}

// Iterators
child_range children() {
  auto **begin = reinterpret_cast<Stmt **>(arg_begin());
  return child_range(begin, begin + NumArgs);
}
3197};

3199/// Represents a C++ member access expression where the actual
3200/// member referenced could not be resolved because the base
3201/// expression or the member name was dependent.
3202///
3203/// Like UnresolvedMemberExprs, these can be either implicit or
3204/// explicit accesses.  It is only possible to get one of these with
3205/// an implicit access if a qualifier is provided.
3206class CXXDependentScopeMemberExpr final
  : public Expr,
    private llvm::TrailingObjects<CXXDependentScopeMemberExpr,
                                  ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc> {
/// The expression for the base pointer or class reference,
/// e.g., the \c x in x.f.  Can be null in implicit accesses.
Stmt *Base;

/// The type of the base expression.  Never null, even for
/// implicit accesses.
QualType BaseType;

/// Whether this member expression used the '->' operator or
/// the '.' operator.
bool IsArrow : 1;

/// Whether this member expression has info for explicit template
/// keyword and arguments.
bool HasTemplateKWAndArgsInfo : 1;

/// The location of the '->' or '.' operator.
SourceLocation OperatorLoc;

/// The nested-name-specifier that precedes the member name, if any.
NestedNameSpecifierLoc QualifierLoc;

/// In a qualified member access expression such as t->Base::f, this
/// member stores the resolves of name lookup in the context of the member
/// access expression, to be used at instantiation time.
///
/// FIXME: This member, along with the QualifierLoc, could
/// be stuck into a structure that is optionally allocated at the end of
/// the CXXDependentScopeMemberExpr, to save space in the common case.
NamedDecl *FirstQualifierFoundInScope;

/// The member to which this member expression refers, which
/// can be name, overloaded operator, or destructor.
///
/// FIXME: could also be a template-id
DeclarationNameInfo MemberNameInfo;

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return HasTemplateKWAndArgsInfo ? 1 : 0;
}

CXXDependentScopeMemberExpr(const ASTContext &C, Expr *Base,
                            QualType BaseType, bool IsArrow,
                            SourceLocation OperatorLoc,
                            NestedNameSpecifierLoc QualifierLoc,
                            SourceLocation TemplateKWLoc,
                            NamedDecl *FirstQualifierFoundInScope,
                            DeclarationNameInfo MemberNameInfo,
                            const TemplateArgumentListInfo *TemplateArgs);

3261public:
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

CXXDependentScopeMemberExpr(const ASTContext &C, Expr *Base,
                            QualType BaseType, bool IsArrow,
                            SourceLocation OperatorLoc,
                            NestedNameSpecifierLoc QualifierLoc,
                            NamedDecl *FirstQualifierFoundInScope,
                            DeclarationNameInfo MemberNameInfo);

static CXXDependentScopeMemberExpr *
Create(const ASTContext &C, Expr *Base, QualType BaseType, bool IsArrow,
       SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
       SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
       DeclarationNameInfo MemberNameInfo,
       const TemplateArgumentListInfo *TemplateArgs);

static CXXDependentScopeMemberExpr *
CreateEmpty(const ASTContext &C, bool HasTemplateKWAndArgsInfo,
            unsigned NumTemplateArgs);

/// True if this is an implicit access, i.e. one in which the
/// member being accessed was not written in the source.  The source
/// location of the operator is invalid in this case.
bool isImplicitAccess() const;

/// Retrieve the base object of this member expressions,
/// e.g., the \c x in \c x.m.
Expr *getBase() const {
  assert(!isImplicitAccess())(static_cast <bool> (!isImplicitAccess()) ? void (0) : __assert_fail
 ("!isImplicitAccess()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3292, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(Base);
}

QualType getBaseType() const { return BaseType; }

/// Determine whether this member expression used the '->'
/// operator; otherwise, it used the '.' operator.
bool isArrow() const { return IsArrow; }

/// Retrieve the location of the '->' or '.' operator.
SourceLocation getOperatorLoc() const { return OperatorLoc; }

/// Retrieve the nested-name-specifier that qualifies the member
/// name.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

/// Retrieve the nested-name-specifier that qualifies the member
/// name, with source location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// Retrieve the first part of the nested-name-specifier that was
/// found in the scope of the member access expression when the member access
/// was initially parsed.
///
/// This function only returns a useful result when member access expression
/// uses a qualified member name, e.g., "x.Base::f". Here, the declaration
/// returned by this function describes what was found by unqualified name
/// lookup for the identifier "Base" within the scope of the member access
/// expression itself. At template instantiation time, this information is
/// combined with the results of name lookup into the type of the object
/// expression itself (the class type of x).
NamedDecl *getFirstQualifierFoundInScope() const {
  return FirstQualifierFoundInScope;
}

/// Retrieve the name of the member that this expression
/// refers to.
const DeclarationNameInfo &getMemberNameInfo() const {
  return MemberNameInfo;
}

/// Retrieve the name of the member that this expression
/// refers to.
DeclarationName getMember() const { return MemberNameInfo.getName(); }

// Retrieve the location of the name of the member that this
// expression refers to.
SourceLocation getMemberLoc() const { return MemberNameInfo.getLoc(); }

/// 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 this member expression actually had a C++
/// template argument list explicitly specified, e.g., x.f<int>.
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()};
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  if (!isImplicitAccess())
    return Base->getLocStart();
  if (getQualifier())
    return getQualifierLoc().getBeginLoc();
  return MemberNameInfo.getBeginLoc();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  if (hasExplicitTemplateArgs())
    return getRAngleLoc();
  return MemberNameInfo.getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXDependentScopeMemberExprClass;
}

// Iterators
child_range children() {
  if (isImplicitAccess())
    return child_range(child_iterator(), child_iterator());
  return child_range(&Base, &Base + 1);
}
3426};

3428/// Represents a C++ member access expression for which lookup
3429/// produced a set of overloaded functions.
3430///
3431/// The member access may be explicit or implicit:
3432/// \code
3433///    struct A {
3434///      int a, b;
3435///      int explicitAccess() { return this->a + this->A::b; }
3436///      int implicitAccess() { return a + A::b; }
3437///    };
3438/// \endcode
3439///
3440/// In the final AST, an explicit access always becomes a MemberExpr.
3441/// An implicit access may become either a MemberExpr or a
3442/// DeclRefExpr, depending on whether the member is static.
3443class UnresolvedMemberExpr final
  : public OverloadExpr,
    private llvm::TrailingObjects<
        UnresolvedMemberExpr, ASTTemplateKWAndArgsInfo, TemplateArgumentLoc> {
friend class ASTStmtReader;
friend class OverloadExpr;
friend TrailingObjects;

/// Whether this member expression used the '->' operator or
/// the '.' operator.
bool IsArrow : 1;

/// Whether the lookup results contain an unresolved using
/// declaration.
bool HasUnresolvedUsing : 1;

/// The expression for the base pointer or class reference,
/// e.g., the \c x in x.f.
///
/// This can be null if this is an 'unbased' member expression.
Stmt *Base = nullptr;

/// The type of the base expression; never null.
QualType BaseType;

/// The location of the '->' or '.' operator.
SourceLocation OperatorLoc;

UnresolvedMemberExpr(const ASTContext &C, bool HasUnresolvedUsing,
                     Expr *Base, QualType BaseType, bool IsArrow,
                     SourceLocation OperatorLoc,
                     NestedNameSpecifierLoc QualifierLoc,
                     SourceLocation TemplateKWLoc,
                     const DeclarationNameInfo &MemberNameInfo,
                     const TemplateArgumentListInfo *TemplateArgs,
                     UnresolvedSetIterator Begin, UnresolvedSetIterator End);

UnresolvedMemberExpr(EmptyShell Empty)
    : OverloadExpr(UnresolvedMemberExprClass, Empty), IsArrow(false),
      HasUnresolvedUsing(false) {}

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return HasTemplateKWAndArgsInfo ? 1 : 0;
}

3488public:
static UnresolvedMemberExpr *
Create(const ASTContext &C, bool HasUnresolvedUsing,
       Expr *Base, QualType BaseType, bool IsArrow,
       SourceLocation OperatorLoc,
       NestedNameSpecifierLoc QualifierLoc,
       SourceLocation TemplateKWLoc,
       const DeclarationNameInfo &MemberNameInfo,
       const TemplateArgumentListInfo *TemplateArgs,
       UnresolvedSetIterator Begin, UnresolvedSetIterator End);

static UnresolvedMemberExpr *
CreateEmpty(const ASTContext &C, bool HasTemplateKWAndArgsInfo,
            unsigned NumTemplateArgs);

/// True if this is an implicit access, i.e., one in which the
/// member being accessed was not written in the source.
///
/// The source location of the operator is invalid in this case.
bool isImplicitAccess() const;

/// Retrieve the base object of this member expressions,
/// e.g., the \c x in \c x.m.
Expr *getBase() {
  assert(!isImplicitAccess())(static_cast <bool> (!isImplicitAccess()) ? void (0) : __assert_fail
 ("!isImplicitAccess()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3512, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(Base);
}
const Expr *getBase() const {
  assert(!isImplicitAccess())(static_cast <bool> (!isImplicitAccess()) ? void (0) : __assert_fail
 ("!isImplicitAccess()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3516, __extension__ __PRETTY_FUNCTION__));
  return cast<Expr>(Base);
}

QualType getBaseType() const { return BaseType; }

/// Determine whether the lookup results contain an unresolved using
/// declaration.
bool hasUnresolvedUsing() const { return HasUnresolvedUsing; }

/// Determine whether this member expression used the '->'
/// operator; otherwise, it used the '.' operator.
bool isArrow() const { return IsArrow; }

/// Retrieve the location of the '->' or '.' operator.
SourceLocation getOperatorLoc() const { return OperatorLoc; }

/// Retrieve the naming class of this lookup.
CXXRecordDecl *getNamingClass() const;

/// Retrieve the full name info for the member that this expression
/// refers to.
const DeclarationNameInfo &getMemberNameInfo() const { return getNameInfo(); }

/// Retrieve the name of the member that this expression
/// refers to.
DeclarationName getMemberName() const { return getName(); }

// Retrieve the location of the name of the member that this
// expression refers to.
SourceLocation getMemberLoc() const { return getNameLoc(); }

// Return the preferred location (the member name) for the arrow when
// diagnosing a problem with this expression.
SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) { return getMemberLoc(); }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  if (!isImplicitAccess())
    return Base->getLocStart();
  if (NestedNameSpecifierLoc l = getQualifierLoc())
    return l.getBeginLoc();
  return getMemberNameInfo().getLocStart();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  if (hasExplicitTemplateArgs())
    return getRAngleLoc();
  return getMemberNameInfo().getLocEnd();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnresolvedMemberExprClass;
}

// Iterators
child_range children() {
  if (isImplicitAccess())
    return child_range(child_iterator(), child_iterator());
  return child_range(&Base, &Base + 1);
}
3576};

3578inline ASTTemplateKWAndArgsInfo *
3579OverloadExpr::getTrailingASTTemplateKWAndArgsInfo() {
if (!HasTemplateKWAndArgsInfo)
  return nullptr;

if (isa<UnresolvedLookupExpr>(this))
  return cast<UnresolvedLookupExpr>(this)
      ->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
else
  return cast<UnresolvedMemberExpr>(this)
      ->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
3589}

3591inline TemplateArgumentLoc *OverloadExpr::getTrailingTemplateArgumentLoc() {
if (isa<UnresolvedLookupExpr>(this))
  return cast<UnresolvedLookupExpr>(this)
      ->getTrailingObjects<TemplateArgumentLoc>();
else
  return cast<UnresolvedMemberExpr>(this)
      ->getTrailingObjects<TemplateArgumentLoc>();
3598}

3600/// Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
3601///
3602/// The noexcept expression tests whether a given expression might throw. Its
3603/// result is a boolean constant.
3604class CXXNoexceptExpr : public Expr {
friend class ASTStmtReader;

bool Value : 1;
Stmt *Operand;
SourceRange Range;

3611public:
CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val,
                SourceLocation Keyword, SourceLocation RParen)
    : Expr(CXXNoexceptExprClass, Ty, VK_RValue, OK_Ordinary,
           /*TypeDependent*/false,
           /*ValueDependent*/Val == CT_Dependent,
           Val == CT_Dependent || Operand->isInstantiationDependent(),
           Operand->containsUnexpandedParameterPack()),
      Value(Val == CT_Cannot), Operand(Operand), Range(Keyword, RParen) {}

CXXNoexceptExpr(EmptyShell Empty) : Expr(CXXNoexceptExprClass, Empty) {}

Expr *getOperand() const { return static_cast<Expr*>(Operand); }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }

bool getValue() const { return Value; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXNoexceptExprClass;
}

// Iterators
child_range children() { return child_range(&Operand, &Operand + 1); }
3637};

3639/// Represents a C++11 pack expansion that produces a sequence of
3640/// expressions.
3641///
3642/// A pack expansion expression contains a pattern (which itself is an
3643/// expression) followed by an ellipsis. For example:
3644///
3645/// \code
3646/// template<typename F, typename ...Types>
3647/// void forward(F f, Types &&...args) {
3648///   f(static_cast<Types&&>(args)...);
3649/// }
3650/// \endcode
3651///
3652/// Here, the argument to the function object \c f is a pack expansion whose
3653/// pattern is \c static_cast<Types&&>(args). When the \c forward function
3654/// template is instantiated, the pack expansion will instantiate to zero or
3655/// or more function arguments to the function object \c f.
3656class PackExpansionExpr : public Expr {
friend class ASTStmtReader;
friend class ASTStmtWriter;

SourceLocation EllipsisLoc;

/// The number of expansions that will be produced by this pack
/// expansion expression, if known.
///
/// When zero, the number of expansions is not known. Otherwise, this value
/// is the number of expansions + 1.
unsigned NumExpansions;

Stmt *Pattern;

3671public:
PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc,
                  Optional<unsigned> NumExpansions)
    : Expr(PackExpansionExprClass, T, Pattern->getValueKind(),
           Pattern->getObjectKind(), /*TypeDependent=*/true,
           /*ValueDependent=*/true, /*InstantiationDependent=*/true,
           /*ContainsUnexpandedParameterPack=*/false),
      EllipsisLoc(EllipsisLoc),
      NumExpansions(NumExpansions ? *NumExpansions + 1 : 0),
      Pattern(Pattern) {}

PackExpansionExpr(EmptyShell Empty) : Expr(PackExpansionExprClass, Empty) {}

/// Retrieve the pattern of the pack expansion.
Expr *getPattern() { return reinterpret_cast<Expr *>(Pattern); }

/// Retrieve the pattern of the pack expansion.
const Expr *getPattern() const { return reinterpret_cast<Expr *>(Pattern); }

/// Retrieve the location of the ellipsis that describes this pack
/// expansion.
SourceLocation getEllipsisLoc() const { return EllipsisLoc; }

/// Determine the number of expansions that will be produced when
/// this pack expansion is instantiated, if already known.
Optional<unsigned> getNumExpansions() const {
  if (NumExpansions)
    return NumExpansions - 1;

  return None;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return Pattern->getLocStart();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return EllipsisLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == PackExpansionExprClass;
}

// Iterators
child_range children() {
  return child_range(&Pattern, &Pattern + 1);
}
3717};

3719/// Represents an expression that computes the length of a parameter
3720/// pack.
3721///
3722/// \code
3723/// template<typename ...Types>
3724/// struct count {
3725///   static const unsigned value = sizeof...(Types);
3726/// };
3727/// \endcode
3728class SizeOfPackExpr final
  : public Expr,
    private llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> {
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// The location of the \c sizeof keyword.
SourceLocation OperatorLoc;

/// The location of the name of the parameter pack.
SourceLocation PackLoc;

/// The location of the closing parenthesis.
SourceLocation RParenLoc;

/// The length of the parameter pack, if known.
///
/// When this expression is not value-dependent, this is the length of
/// the pack. When the expression was parsed rather than instantiated
/// (and thus is value-dependent), this is zero.
///
/// After partial substitution into a sizeof...(X) expression (for instance,
/// within an alias template or during function template argument deduction),
/// we store a trailing array of partially-substituted TemplateArguments,
/// and this is the length of that array.
unsigned Length;

/// The parameter pack.
NamedDecl *Pack = nullptr;

/// Create an expression that computes the length of
/// the given parameter pack.
SizeOfPackExpr(QualType SizeType, SourceLocation OperatorLoc, NamedDecl *Pack,
               SourceLocation PackLoc, SourceLocation RParenLoc,
               Optional<unsigned> Length, ArrayRef<TemplateArgument> PartialArgs)
    : Expr(SizeOfPackExprClass, SizeType, VK_RValue, OK_Ordinary,
           /*TypeDependent=*/false, /*ValueDependent=*/!Length,
           /*InstantiationDependent=*/!Length,
           /*ContainsUnexpandedParameterPack=*/false),
      OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),
      Length(Length ? *Length : PartialArgs.size()), Pack(Pack) {
  assert((!Length || PartialArgs.empty()) &&(static_cast <bool> ((!Length || PartialArgs.empty()) &&
 "have partial args for non-dependent sizeof... expression") ?
 void (0) : __assert_fail ("(!Length || PartialArgs.empty()) && \"have partial args for non-dependent sizeof... expression\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3771, __extension__ __PRETTY_FUNCTION__))
         "have partial args for non-dependent sizeof... expression")(static_cast <bool> ((!Length || PartialArgs.empty()) &&
 "have partial args for non-dependent sizeof... expression") ?
 void (0) : __assert_fail ("(!Length || PartialArgs.empty()) && \"have partial args for non-dependent sizeof... expression\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3771, __extension__ __PRETTY_FUNCTION__));
  auto *Args = getTrailingObjects<TemplateArgument>();
  std::uninitialized_copy(PartialArgs.begin(), PartialArgs.end(), Args);
}

/// Create an empty expression.
SizeOfPackExpr(EmptyShell Empty, unsigned NumPartialArgs)
    : Expr(SizeOfPackExprClass, Empty), Length(NumPartialArgs) {}

3780public:
static SizeOfPackExpr *Create(ASTContext &Context, SourceLocation OperatorLoc,
                              NamedDecl *Pack, SourceLocation PackLoc,
                              SourceLocation RParenLoc,
                              Optional<unsigned> Length = None,
                              ArrayRef<TemplateArgument> PartialArgs = None);
static SizeOfPackExpr *CreateDeserialized(ASTContext &Context,
                                          unsigned NumPartialArgs);

/// Determine the location of the 'sizeof' keyword.
SourceLocation getOperatorLoc() const { return OperatorLoc; }

/// Determine the location of the parameter pack.
SourceLocation getPackLoc() const { return PackLoc; }

/// Determine the location of the right parenthesis.
SourceLocation getRParenLoc() const { return RParenLoc; }

/// Retrieve the parameter pack.
NamedDecl *getPack() const { return Pack; }

/// Retrieve the length of the parameter pack.
///
/// This routine may only be invoked when the expression is not
/// value-dependent.
unsigned getPackLength() const {
  assert(!isValueDependent() &&(static_cast <bool> (!isValueDependent() && "Cannot get the length of a value-dependent pack size expression"
) ? void (0) : __assert_fail ("!isValueDependent() && \"Cannot get the length of a value-dependent pack size expression\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3807, __extension__ __PRETTY_FUNCTION__))
         "Cannot get the length of a value-dependent pack size expression")(static_cast <bool> (!isValueDependent() && "Cannot get the length of a value-dependent pack size expression"
) ? void (0) : __assert_fail ("!isValueDependent() && \"Cannot get the length of a value-dependent pack size expression\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3807, __extension__ __PRETTY_FUNCTION__));
  return Length;
}

/// Determine whether this represents a partially-substituted sizeof...
/// expression, such as is produced for:
///
///   template<typename ...Ts> using X = int[sizeof...(Ts)];
///   template<typename ...Us> void f(X<Us..., 1, 2, 3, Us...>);
bool isPartiallySubstituted() const {
  return isValueDependent() && Length;
}

/// Get
ArrayRef<TemplateArgument> getPartialArguments() const {
  assert(isPartiallySubstituted())(static_cast <bool> (isPartiallySubstituted()) ? void (
0) : __assert_fail ("isPartiallySubstituted()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 3822, __extension__ __PRETTY_FUNCTION__));
  const auto *Args = getTrailingObjects<TemplateArgument>();
  return llvm::makeArrayRef(Args, Args + Length);
}

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() == SizeOfPackExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
3838};

3840/// Represents a reference to a non-type template parameter
3841/// that has been substituted with a template argument.
3842class SubstNonTypeTemplateParmExpr : public Expr {
friend class ASTReader;
friend class ASTStmtReader;

/// The replaced parameter.
NonTypeTemplateParmDecl *Param;

/// The replacement expression.
Stmt *Replacement;

/// The location of the non-type template parameter reference.
SourceLocation NameLoc;

explicit SubstNonTypeTemplateParmExpr(EmptyShell Empty)
    : Expr(SubstNonTypeTemplateParmExprClass, Empty) {}

3858public:
SubstNonTypeTemplateParmExpr(QualType type,
                             ExprValueKind valueKind,
                             SourceLocation loc,
                             NonTypeTemplateParmDecl *param,
                             Expr *replacement)
    : Expr(SubstNonTypeTemplateParmExprClass, type, valueKind, OK_Ordinary,
           replacement->isTypeDependent(), replacement->isValueDependent(),
           replacement->isInstantiationDependent(),
           replacement->containsUnexpandedParameterPack()),
      Param(param), Replacement(replacement), NameLoc(loc) {}

SourceLocation getNameLoc() const { return NameLoc; }
SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return NameLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return NameLoc; }

Expr *getReplacement() const { return cast<Expr>(Replacement); }

NonTypeTemplateParmDecl *getParameter() const { return Param; }

static bool classof(const Stmt *s) {
  return s->getStmtClass() == SubstNonTypeTemplateParmExprClass;
}

// Iterators
child_range children() { return child_range(&Replacement, &Replacement+1); }
3884};

3886/// Represents a reference to a non-type template parameter pack that
3887/// has been substituted with a non-template argument pack.
3888///
3889/// When a pack expansion in the source code contains multiple parameter packs
3890/// and those parameter packs correspond to different levels of template
3891/// parameter lists, this node is used to represent a non-type template
3892/// parameter pack from an outer level, which has already had its argument pack
3893/// substituted but that still lives within a pack expansion that itself
3894/// could not be instantiated. When actually performing a substitution into
3895/// that pack expansion (e.g., when all template parameters have corresponding
3896/// arguments), this type will be replaced with the appropriate underlying
3897/// expression at the current pack substitution index.
3898class SubstNonTypeTemplateParmPackExpr : public Expr {
friend class ASTReader;
friend class ASTStmtReader;

/// The non-type template parameter pack itself.
NonTypeTemplateParmDecl *Param;

/// A pointer to the set of template arguments that this
/// parameter pack is instantiated with.
const TemplateArgument *Arguments;

/// The number of template arguments in \c Arguments.
unsigned NumArguments;

/// The location of the non-type template parameter pack reference.
SourceLocation NameLoc;

explicit SubstNonTypeTemplateParmPackExpr(EmptyShell Empty)
    : Expr(SubstNonTypeTemplateParmPackExprClass, Empty) {}

3918public:
SubstNonTypeTemplateParmPackExpr(QualType T,
                                 ExprValueKind ValueKind,
                                 NonTypeTemplateParmDecl *Param,
                                 SourceLocation NameLoc,
                                 const TemplateArgument &ArgPack);

/// Retrieve the non-type template parameter pack being substituted.
NonTypeTemplateParmDecl *getParameterPack() const { return Param; }

/// Retrieve the location of the parameter pack name.
SourceLocation getParameterPackLocation() const { return NameLoc; }

/// Retrieve the template argument pack containing the substituted
/// template arguments.
TemplateArgument getArgumentPack() const;

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return NameLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return NameLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == SubstNonTypeTemplateParmPackExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
3946};

3948/// Represents a reference to a function parameter pack that has been
3949/// substituted but not yet expanded.
3950///
3951/// When a pack expansion contains multiple parameter packs at different levels,
3952/// this node is used to represent a function parameter pack at an outer level
3953/// which we have already substituted to refer to expanded parameters, but where
3954/// the containing pack expansion cannot yet be expanded.
3955///
3956/// \code
3957/// template<typename...Ts> struct S {
3958///   template<typename...Us> auto f(Ts ...ts) -> decltype(g(Us(ts)...));
3959/// };
3960/// template struct S<int, int>;
3961/// \endcode
3962class FunctionParmPackExpr final
  : public Expr,
    private llvm::TrailingObjects<FunctionParmPackExpr, ParmVarDecl *> {
friend class ASTReader;
friend class ASTStmtReader;
friend TrailingObjects;

/// The function parameter pack which was referenced.
ParmVarDecl *ParamPack;

/// The location of the function parameter pack reference.
SourceLocation NameLoc;

/// The number of expansions of this pack.
unsigned NumParameters;

FunctionParmPackExpr(QualType T, ParmVarDecl *ParamPack,
                     SourceLocation NameLoc, unsigned NumParams,
                     ParmVarDecl *const *Params);

3982public:
static FunctionParmPackExpr *Create(const ASTContext &Context, QualType T,
                                    ParmVarDecl *ParamPack,
                                    SourceLocation NameLoc,
                                    ArrayRef<ParmVarDecl *> Params);
static FunctionParmPackExpr *CreateEmpty(const ASTContext &Context,
                                         unsigned NumParams);

/// Get the parameter pack which this expression refers to.
ParmVarDecl *getParameterPack() const { return ParamPack; }

/// Get the location of the parameter pack.
SourceLocation getParameterPackLocation() const { return NameLoc; }

/// Iterators over the parameters which the parameter pack expanded
/// into.
using iterator = ParmVarDecl * const *;
iterator begin() const { return getTrailingObjects<ParmVarDecl *>(); }
iterator end() const { return begin() + NumParameters; }

/// Get the number of parameters in this parameter pack.
unsigned getNumExpansions() const { return NumParameters; }

/// Get an expansion of the parameter pack by index.
ParmVarDecl *getExpansion(unsigned I) const { return begin()[I]; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return NameLoc; }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return NameLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == FunctionParmPackExprClass;
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}
4018};

4020/// Represents a prvalue temporary that is written into memory so that
4021/// a reference can bind to it.
4022///
4023/// Prvalue expressions are materialized when they need to have an address
4024/// in memory for a reference to bind to. This happens when binding a
4025/// reference to the result of a conversion, e.g.,
4026///
4027/// \code
4028/// const int &r = 1.0;
4029/// \endcode
4030///
4031/// Here, 1.0 is implicitly converted to an \c int. That resulting \c int is
4032/// then materialized via a \c MaterializeTemporaryExpr, and the reference
4033/// binds to the temporary. \c MaterializeTemporaryExprs are always glvalues
4034/// (either an lvalue or an xvalue, depending on the kind of reference binding
4035/// to it), maintaining the invariant that references always bind to glvalues.
4036///
4037/// Reference binding and copy-elision can both extend the lifetime of a
4038/// temporary. When either happens, the expression will also track the
4039/// declaration which is responsible for the lifetime extension.
4040class MaterializeTemporaryExpr : public Expr {
4041private:
friend class ASTStmtReader;
friend class ASTStmtWriter;

struct ExtraState {
  /// The temporary-generating expression whose value will be
  /// materialized.
  Stmt *Temporary;

  /// The declaration which lifetime-extended this reference, if any.
  /// Either a VarDecl, or (for a ctor-initializer) a FieldDecl.
  const ValueDecl *ExtendingDecl;

  unsigned ManglingNumber;
};
llvm::PointerUnion<Stmt *, ExtraState *> State;

void initializeExtraState(const ValueDecl *ExtendedBy,
                          unsigned ManglingNumber);

4061public:
MaterializeTemporaryExpr(QualType T, Expr *Temporary,
                         bool BoundToLvalueReference)
    : Expr(MaterializeTemporaryExprClass, T,
           BoundToLvalueReference? VK_LValue : VK_XValue, OK_Ordinary,
           Temporary->isTypeDependent(), Temporary->isValueDependent(),
           Temporary->isInstantiationDependent(),
           Temporary->containsUnexpandedParameterPack()),
      State(Temporary) {}

MaterializeTemporaryExpr(EmptyShell Empty)
    : Expr(MaterializeTemporaryExprClass, Empty) {}

Stmt *getTemporary() const {
  return State.is<Stmt *>() ? State.get<Stmt *>()
                            : State.get<ExtraState *>()->Temporary;
}

/// Retrieve the temporary-generating subexpression whose value will
/// be materialized into a glvalue.
Expr *GetTemporaryExpr() const { return static_cast<Expr *>(getTemporary()); }

/// Retrieve the storage duration for the materialized temporary.
StorageDuration getStorageDuration() const {
  const ValueDecl *ExtendingDecl = getExtendingDecl();
  if (!ExtendingDecl)
    return SD_FullExpression;
  // FIXME: This is not necessarily correct for a temporary materialized
  // within a default initializer.
  if (isa<FieldDecl>(ExtendingDecl))
    return SD_Automatic;
  // FIXME: This only works because storage class specifiers are not allowed
  // on decomposition declarations.
  if (isa<BindingDecl>(ExtendingDecl))
    return ExtendingDecl->getDeclContext()->isFunctionOrMethod()
               ? SD_Automatic
               : SD_Static;
  return cast<VarDecl>(ExtendingDecl)->getStorageDuration();
}

/// Get the declaration which triggered the lifetime-extension of this
/// temporary, if any.
const ValueDecl *getExtendingDecl() const {
  return State.is<Stmt *>() ? nullptr
                            : State.get<ExtraState *>()->ExtendingDecl;
}

void setExtendingDecl(const ValueDecl *ExtendedBy, unsigned ManglingNumber);

unsigned getManglingNumber() const {
  return State.is<Stmt *>() ? 0 : State.get<ExtraState *>()->ManglingNumber;
}

/// Determine whether this materialized temporary is bound to an
/// lvalue reference; otherwise, it's bound to an rvalue reference.
bool isBoundToLvalueReference() const {
  return getValueKind() == VK_LValue;
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getTemporary()->getLocStart();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return getTemporary()->getLocEnd();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == MaterializeTemporaryExprClass;
}

// Iterators
child_range children() {
  if (State.is<Stmt *>())
    return child_range(State.getAddrOfPtr1(), State.getAddrOfPtr1() + 1);

  auto ES = State.get<ExtraState *>();
  return child_range(&ES->Temporary, &ES->Temporary + 1);
}
4140};

4142/// Represents a folding of a pack over an operator.
4143///
4144/// This expression is always dependent and represents a pack expansion of the
4145/// forms:
4146///
4147///    ( expr op ... )
4148///    ( ... op expr )
4149///    ( expr op ... op expr )
4150class CXXFoldExpr : public Expr {
friend class ASTStmtReader;
friend class ASTStmtWriter;

SourceLocation LParenLoc;
SourceLocation EllipsisLoc;
SourceLocation RParenLoc;
Stmt *SubExprs[2];
BinaryOperatorKind Opcode;

4160public:
CXXFoldExpr(QualType T, SourceLocation LParenLoc, Expr *LHS,
            BinaryOperatorKind Opcode, SourceLocation EllipsisLoc, Expr *RHS,
            SourceLocation RParenLoc)
    : Expr(CXXFoldExprClass, T, VK_RValue, OK_Ordinary,
           /*Dependent*/ true, true, true,
           /*ContainsUnexpandedParameterPack*/ false),
      LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
      Opcode(Opcode) {
  SubExprs[0] = LHS;
  SubExprs[1] = RHS;
}

CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {}

Expr *getLHS() const { return static_cast<Expr*>(SubExprs[0]); }
Expr *getRHS() const { return static_cast<Expr*>(SubExprs[1]); }

/// Does this produce a right-associated sequence of operators?
bool isRightFold() const {
  return getLHS() && getLHS()->containsUnexpandedParameterPack();
}

/// Does this produce a left-associated sequence of operators?
bool isLeftFold() const { return !isRightFold(); }

/// Get the pattern, that is, the operand that contains an unexpanded pack.
Expr *getPattern() const { return isLeftFold() ? getRHS() : getLHS(); }

/// Get the operand that doesn't contain a pack, for a binary fold.
Expr *getInit() const { return isLeftFold() ? getLHS() : getRHS(); }

SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
BinaryOperatorKind getOperator() const { return Opcode; }

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() == CXXFoldExprClass;
}

// Iterators
child_range children() { return child_range(SubExprs, SubExprs + 2); }
4209};

4211/// Represents an expression that might suspend coroutine execution;
4212/// either a co_await or co_yield expression.
4213///
4214/// Evaluation of this expression first evaluates its 'ready' expression. If
4215/// that returns 'false':
4216///  -- execution of the coroutine is suspended
4217///  -- the 'suspend' expression is evaluated
4218///     -- if the 'suspend' expression returns 'false', the coroutine is
4219///        resumed
4220///     -- otherwise, control passes back to the resumer.
4221/// If the coroutine is not suspended, or when it is resumed, the 'resume'
4222/// expression is evaluated, and its result is the result of the overall
4223/// expression.
4224class CoroutineSuspendExpr : public Expr {
friend class ASTStmtReader;

SourceLocation KeywordLoc;

enum SubExpr { Common, Ready, Suspend, Resume, Count };

Stmt *SubExprs[SubExpr::Count];
OpaqueValueExpr *OpaqueValue = nullptr;

4234public:
CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, Expr *Common,
                     Expr *Ready, Expr *Suspend, Expr *Resume,
                     OpaqueValueExpr *OpaqueValue)
    : Expr(SC, Resume->getType(), Resume->getValueKind(),
           Resume->getObjectKind(), Resume->isTypeDependent(),
           Resume->isValueDependent(), Common->isInstantiationDependent(),
           Common->containsUnexpandedParameterPack()),
      KeywordLoc(KeywordLoc), OpaqueValue(OpaqueValue) {
  SubExprs[SubExpr::Common] = Common;
  SubExprs[SubExpr::Ready] = Ready;
  SubExprs[SubExpr::Suspend] = Suspend;
  SubExprs[SubExpr::Resume] = Resume;
}

CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, QualType Ty,
                     Expr *Common)
    : Expr(SC, Ty, VK_RValue, OK_Ordinary, true, true, true,
           Common->containsUnexpandedParameterPack()),
      KeywordLoc(KeywordLoc) {
  assert(Common->isTypeDependent() && Ty->isDependentType() &&(static_cast <bool> (Common->isTypeDependent() &&
 Ty->isDependentType() && "wrong constructor for non-dependent co_await/co_yield expression"
) ? void (0) : __assert_fail ("Common->isTypeDependent() && Ty->isDependentType() && \"wrong constructor for non-dependent co_await/co_yield expression\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 4255, __extension__ __PRETTY_FUNCTION__))
         "wrong constructor for non-dependent co_await/co_yield expression")(static_cast <bool> (Common->isTypeDependent() &&
 Ty->isDependentType() && "wrong constructor for non-dependent co_await/co_yield expression"
) ? void (0) : __assert_fail ("Common->isTypeDependent() && Ty->isDependentType() && \"wrong constructor for non-dependent co_await/co_yield expression\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 4255, __extension__ __PRETTY_FUNCTION__));
  SubExprs[SubExpr::Common] = Common;
  SubExprs[SubExpr::Ready] = nullptr;
  SubExprs[SubExpr::Suspend] = nullptr;
  SubExprs[SubExpr::Resume] = nullptr;
}

CoroutineSuspendExpr(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) {
  SubExprs[SubExpr::Common] = nullptr;
  SubExprs[SubExpr::Ready] = nullptr;
  SubExprs[SubExpr::Suspend] = nullptr;
  SubExprs[SubExpr::Resume] = nullptr;
}

SourceLocation getKeywordLoc() const { return KeywordLoc; }

Expr *getCommonExpr() const {
  return static_cast<Expr*>(SubExprs[SubExpr::Common]);
}

/// getOpaqueValue - Return the opaque value placeholder.
OpaqueValueExpr *getOpaqueValue() const { return OpaqueValue; }

Expr *getReadyExpr() const {
  return static_cast<Expr*>(SubExprs[SubExpr::Ready]);
}

Expr *getSuspendExpr() const {
  return static_cast<Expr*>(SubExprs[SubExpr::Suspend]);
}

Expr *getResumeExpr() const {
  return static_cast<Expr*>(SubExprs[SubExpr::Resume]);
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return KeywordLoc;
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return getCommonExpr()->getLocEnd();
}

child_range children() {
  return child_range(SubExprs, SubExprs + SubExpr::Count);
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CoawaitExprClass ||
         T->getStmtClass() == CoyieldExprClass;
}
4306};

4308/// Represents a 'co_await' expression.
4309class CoawaitExpr : public CoroutineSuspendExpr {
friend class ASTStmtReader;

4312public:
CoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand, Expr *Ready,
            Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue,
            bool IsImplicit = false)
    : CoroutineSuspendExpr(CoawaitExprClass, CoawaitLoc, Operand, Ready,
                           Suspend, Resume, OpaqueValue) {
  CoawaitBits.IsImplicit = IsImplicit;
}

CoawaitExpr(SourceLocation CoawaitLoc, QualType Ty, Expr *Operand,
            bool IsImplicit = false)
    : CoroutineSuspendExpr(CoawaitExprClass, CoawaitLoc, Ty, Operand) {
  CoawaitBits.IsImplicit = IsImplicit;
}

CoawaitExpr(EmptyShell Empty)
    : CoroutineSuspendExpr(CoawaitExprClass, Empty) {}

Expr *getOperand() const {
  // FIXME: Dig out the actual operand or store it.
  return getCommonExpr();
}

bool isImplicit() const { return CoawaitBits.IsImplicit; }
void setIsImplicit(bool value = true) { CoawaitBits.IsImplicit = value; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CoawaitExprClass;
}
4341};

4343/// Represents a 'co_await' expression while the type of the promise
4344/// is dependent.
4345class DependentCoawaitExpr : public Expr {
friend class ASTStmtReader;

SourceLocation KeywordLoc;
Stmt *SubExprs[2];

4351public:
DependentCoawaitExpr(SourceLocation KeywordLoc, QualType Ty, Expr *Op,
                     UnresolvedLookupExpr *OpCoawait)
    : Expr(DependentCoawaitExprClass, Ty, VK_RValue, OK_Ordinary,
           /*TypeDependent*/ true, /*ValueDependent*/ true,
           /*InstantiationDependent*/ true,
           Op->containsUnexpandedParameterPack()),
      KeywordLoc(KeywordLoc) {
  // NOTE: A co_await expression is dependent on the coroutines promise
  // type and may be dependent even when the `Op` expression is not.
  assert(Ty->isDependentType() &&(static_cast <bool> (Ty->isDependentType() &&
 "wrong constructor for non-dependent co_await/co_yield expression"
) ? void (0) : __assert_fail ("Ty->isDependentType() && \"wrong constructor for non-dependent co_await/co_yield expression\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 4362, __extension__ __PRETTY_FUNCTION__))
         "wrong constructor for non-dependent co_await/co_yield expression")(static_cast <bool> (Ty->isDependentType() &&
 "wrong constructor for non-dependent co_await/co_yield expression"
) ? void (0) : __assert_fail ("Ty->isDependentType() && \"wrong constructor for non-dependent co_await/co_yield expression\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include/clang/AST/ExprCXX.h"
, 4362, __extension__ __PRETTY_FUNCTION__));
  SubExprs[0] = Op;
  SubExprs[1] = OpCoawait;
}

DependentCoawaitExpr(EmptyShell Empty)
    : Expr(DependentCoawaitExprClass, Empty) {}

Expr *getOperand() const { return cast<Expr>(SubExprs[0]); }

UnresolvedLookupExpr *getOperatorCoawaitLookup() const {
  return cast<UnresolvedLookupExpr>(SubExprs[1]);
}

SourceLocation getKeywordLoc() const { return KeywordLoc; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return KeywordLoc; }

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  return getOperand()->getLocEnd();
}

child_range children() { return child_range(SubExprs, SubExprs + 2); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DependentCoawaitExprClass;
}
4389};

4391/// Represents a 'co_yield' expression.
4392class CoyieldExpr : public CoroutineSuspendExpr {
friend class ASTStmtReader;

4395public:
CoyieldExpr(SourceLocation CoyieldLoc, Expr *Operand, Expr *Ready,
            Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue)
    : CoroutineSuspendExpr(CoyieldExprClass, CoyieldLoc, Operand, Ready,
                           Suspend, Resume, OpaqueValue) {}
CoyieldExpr(SourceLocation CoyieldLoc, QualType Ty, Expr *Operand)
    : CoroutineSuspendExpr(CoyieldExprClass, CoyieldLoc, Ty, Operand) {}
CoyieldExpr(EmptyShell Empty)
    : CoroutineSuspendExpr(CoyieldExprClass, Empty) {}

Expr *getOperand() const {
  // FIXME: Dig out the actual operand or store it.
  return getCommonExpr();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CoyieldExprClass;
}
4413};

4415} // namespace clang

4417#endif // LLVM_CLANG_AST_EXPRCXX_H