/build/source/clang/lib/AST/ASTImporter.cpp

Bug Summary

File:	build/source/clang/lib/AST/ASTImporter.cpp
Warning:	line 9346, column 47 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ASTImporter.cpp -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 -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm -resource-dir /usr/lib/llvm-17/lib/clang/17 -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/lib/AST -I /build/source/clang/lib/AST -I /build/source/clang/include -I tools/clang/include -I include -I /build/source/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm=build-llvm -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm=build-llvm -fcoverage-prefix-map=/build/source/= -source-date-epoch 1680300532 -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-04-01-083001-16331-1 -x c++ /build/source/clang/lib/AST/ASTImporter.cpp
/build/source/clang/lib/AST/ASTImporter.cpp

→
1//===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file defines the ASTImporter class which imports AST nodes from one
10//  context into another context.
11//
12//===----------------------------------------------------------------------===//

14#include "clang/AST/ASTImporter.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/ASTDiagnostic.h"
17#include "clang/AST/ASTImporterSharedState.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/Builtins.h"
48#include "clang/Basic/ExceptionSpecificationType.h"
49#include "clang/Basic/FileManager.h"
50#include "clang/Basic/IdentifierTable.h"
51#include "clang/Basic/LLVM.h"
52#include "clang/Basic/LangOptions.h"
53#include "clang/Basic/SourceLocation.h"
54#include "clang/Basic/SourceManager.h"
55#include "clang/Basic/Specifiers.h"
56#include "llvm/ADT/APSInt.h"
57#include "llvm/ADT/ArrayRef.h"
58#include "llvm/ADT/DenseMap.h"
59#include "llvm/ADT/STLExtras.h"
60#include "llvm/ADT/ScopeExit.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 <optional>
70#include <type_traits>
71#include <utility>

73namespace clang {

using llvm::make_error;
using llvm::Error;
using llvm::Expected;
using ExpectedTypePtr = llvm::Expected<const Type *>;
using ExpectedType = llvm::Expected<QualType>;
using ExpectedStmt = llvm::Expected<Stmt *>;
using ExpectedExpr = llvm::Expected<Expr *>;
using ExpectedDecl = llvm::Expected<Decl *>;
using ExpectedSLoc = llvm::Expected<SourceLocation>;
using ExpectedName = llvm::Expected<DeclarationName>;

std::string ASTImportError::toString() const {
  // FIXME: Improve error texts.
  switch (Error) {
  case NameConflict:
    return "NameConflict";
  case UnsupportedConstruct:
    return "UnsupportedConstruct";
  case Unknown:
    return "Unknown error";
  }
  llvm_unreachable("Invalid error code.")::llvm::llvm_unreachable_internal("Invalid error code.", "clang/lib/AST/ASTImporter.cpp"
, 96);
  return "Invalid error code.";
}

void ASTImportError::log(raw_ostream &OS) const { OS << toString(); }

std::error_code ASTImportError::convertToErrorCode() const {
  llvm_unreachable("Function not implemented.")::llvm::llvm_unreachable_internal("Function not implemented."
, "clang/lib/AST/ASTImporter.cpp", 103);
}

char ASTImportError::ID;

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) {
  if (auto *FD = dyn_cast<FunctionDecl>(D))
    return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
  if (auto *VD = dyn_cast<VarDecl>(D))
    return getCanonicalForwardRedeclChain<VarDecl>(VD);
  if (auto *TD = dyn_cast<TagDecl>(D))
    return getCanonicalForwardRedeclChain<TagDecl>(TD);
  llvm_unreachable("Bad declaration kind")::llvm::llvm_unreachable_internal("Bad declaration kind", "clang/lib/AST/ASTImporter.cpp"
, 128);
}

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

/// How to handle import errors that occur when import of a child declaration
/// of a DeclContext fails.
class ChildErrorHandlingStrategy {
  /// This context is imported (in the 'from' domain).
  /// It is nullptr if a non-DeclContext is imported.
  const DeclContext *const FromDC;
  /// Ignore import errors of the children.
  /// If true, the context can be imported successfully if a child
  /// of it failed to import. Otherwise the import errors of the child nodes
  /// are accumulated (joined) into the import error object of the parent.
  /// (Import of a parent can fail in other ways.)
  bool const IgnoreChildErrors;

public:
  ChildErrorHandlingStrategy(const DeclContext *FromDC)
      : FromDC(FromDC), IgnoreChildErrors(!isa<TagDecl>(FromDC)) {}
  ChildErrorHandlingStrategy(const Decl *FromD)
      : FromDC(dyn_cast<DeclContext>(FromD)),
        IgnoreChildErrors(!isa<TagDecl>(FromD)) {}

  /// Process the import result of a child (of the current declaration).
  /// \param ResultErr The import error that can be used as result of
  /// importing the parent. This may be changed by the function.
  /// \param ChildErr Result of importing a child. Can be success or error.
  void handleChildImportResult(Error &ResultErr, Error &&ChildErr) {
    if (ChildErr && !IgnoreChildErrors)
      ResultErr = joinErrors(std::move(ResultErr), std::move(ChildErr));
    else
      consumeError(std::move(ChildErr));
  }

  /// Determine if import failure of a child does not cause import failure of
  /// its parent.
  bool ignoreChildErrorOnParent(Decl *FromChildD) const {
    if (!IgnoreChildErrors || !FromDC)
      return false;
    return FromDC->containsDecl(FromChildD);
  }
};

class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>,
                        public DeclVisitor<ASTNodeImporter, ExpectedDecl>,
                        public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
  ASTImporter &Importer;

  // Use this instead of Importer.importInto .
  template <typename ImportT>
  [[nodiscard]] Error importInto(ImportT &To, const ImportT &From) {
    return Importer.importInto(To, From);
  }

  // Use this to import pointers of specific type.
  template <typename ImportT>
  [[nodiscard]] Error importInto(ImportT *&To, ImportT *From) {
    auto ToOrErr = Importer.Import(From);
    if (ToOrErr)
      To = cast_or_null<ImportT>(*ToOrErr);
    return ToOrErr.takeError();
  }

  // Call the import function of ASTImporter for a baseclass of type `T` and
  // cast the return value to `T`.
  template <typename T>
  auto import(T *From)
      -> std::conditional_t<std::is_base_of_v<Type, T>, Expected<const T *>,
                            Expected<T *>> {
    auto ToOrErr = Importer.Import(From);
    if (!ToOrErr)
      return ToOrErr.takeError();
    return cast_or_null<T>(*ToOrErr);
  }

  template <typename T>
  auto import(const T *From) {
    return import(const_cast<T *>(From));
  }

  // Call the import function of ASTImporter for type `T`.
  template <typename T>
  Expected<T> import(const T &From) {
    return Importer.Import(From);
4
←
Calling 'ASTImporter::Import'→
  }

  // Import an std::optional<T> by importing the contained T, if any.
  template <typename T>
  Expected<std::optional<T>> import(std::optional<T> From) {
    if (!From)
      return std::nullopt;
    return import(*From);
  }

  ExplicitSpecifier importExplicitSpecifier(Error &Err,
                                            ExplicitSpecifier ESpec);

  // Wrapper for an overload set.
  template <typename ToDeclT> struct CallOverloadedCreateFun {
    template <typename... Args> decltype(auto) operator()(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>
  [[nodiscard]] 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>
  [[nodiscard]] 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>
  [[nodiscard]] bool
  GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
                                 FromDeclT *FromD, Args &&...args) {
    if (Importer.getImportDeclErrorIfAny(FromD)) {
      ToD = nullptr;
      return true; // Already imported but with error.
    }
    ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
    if (ToD)
      return true; // Already imported.
    ToD = CreateFun(std::forward<Args>(args)...);
    // Keep track of imported Decls.
    Importer.RegisterImportedDecl(FromD, ToD);
    Importer.SharedState->markAsNewDecl(ToD);
    InitializeImportedDecl(FromD, ToD);
    return false; // A new Decl is created.
  }

  void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
    ToD->IdentifierNamespace = FromD->IdentifierNamespace;
    if (FromD->isUsed())
      ToD->setIsUsed();
    if (FromD->isImplicit())
      ToD->setImplicit();
  }

  // Check if we have found an existing definition.  Returns with that
  // definition if yes, otherwise returns null.
  Decl *FindAndMapDefinition(FunctionDecl *D, FunctionDecl *FoundFunction) {
    const FunctionDecl *Definition = nullptr;
    if (D->doesThisDeclarationHaveABody() &&
        FoundFunction->hasBody(Definition))
      return Importer.MapImported(D, const_cast<FunctionDecl *>(Definition));
    return nullptr;
  }

  void addDeclToContexts(Decl *FromD, Decl *ToD) {
    if (Importer.isMinimalImport()) {
      // In minimal import case the decl must be added even if it is not
      // contained in original context, for LLDB compatibility.
      // FIXME: Check if a better solution is possible.
      if (!FromD->getDescribedTemplate() &&
          FromD->getFriendObjectKind() == Decl::FOK_None)
        ToD->getLexicalDeclContext()->addDeclInternal(ToD);
      return;
    }

    DeclContext *FromDC = FromD->getDeclContext();
    DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
    DeclContext *ToDC = ToD->getDeclContext();
    DeclContext *ToLexicalDC = ToD->getLexicalDeclContext();

    bool Visible = false;
    if (FromDC->containsDeclAndLoad(FromD)) {
      ToDC->addDeclInternal(ToD);
      Visible = true;
    }
    if (ToDC != ToLexicalDC && FromLexicalDC->containsDeclAndLoad(FromD)) {
      ToLexicalDC->addDeclInternal(ToD);
      Visible = true;
    }

    // If the Decl was added to any context, it was made already visible.
    // Otherwise it is still possible that it should be visible.
    if (!Visible) {
      if (auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
        auto *ToNamed = cast<NamedDecl>(ToD);
        DeclContextLookupResult FromLookup =
            FromDC->lookup(FromNamed->getDeclName());
        if (llvm::is_contained(FromLookup, FromNamed))
          ToDC->makeDeclVisibleInContext(ToNamed);
      }
    }
  }

  void updateLookupTableForTemplateParameters(TemplateParameterList &Params,
                                              DeclContext *OldDC) {
    ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable();
    if (!LT)
      return;

    for (NamedDecl *TP : Params)
      LT->update(TP, OldDC);
  }

  void updateLookupTableForTemplateParameters(TemplateParameterList &Params) {
    updateLookupTableForTemplateParameters(
        Params, Importer.getToContext().getTranslationUnitDecl());
  }

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

  using TypeVisitor<ASTNodeImporter, ExpectedType>::Visit;
  using DeclVisitor<ASTNodeImporter, ExpectedDecl>::Visit;
  using StmtVisitor<ASTNodeImporter, ExpectedStmt>::Visit;

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

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

  Expected<CXXCastPath> ImportCastPath(CastExpr *E);
  Expected<APValue> ImportAPValue(const APValue &FromValue);

  using Designator = DesignatedInitExpr::Designator;

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

  Error ImportInitializer(VarDecl *From, VarDecl *To);
  Error ImportDefinition(
      RecordDecl *From, RecordDecl *To,
      ImportDefinitionKind Kind = IDK_Default);
  Error ImportDefinition(
      EnumDecl *From, EnumDecl *To,
      ImportDefinitionKind Kind = IDK_Default);
  Error ImportDefinition(
      ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
      ImportDefinitionKind Kind = IDK_Default);
  Error ImportDefinition(
      ObjCProtocolDecl *From, ObjCProtocolDecl *To,
      ImportDefinitionKind Kind = IDK_Default);
  Error ImportTemplateArguments(ArrayRef<TemplateArgument> FromArgs,
                                SmallVectorImpl<TemplateArgument> &ToArgs);
  Expected<TemplateArgument>
  ImportTemplateArgument(const TemplateArgument &From);

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

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

  using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
  using FunctionTemplateAndArgsTy =
      std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
  Expected<FunctionTemplateAndArgsTy>
  ImportFunctionTemplateWithTemplateArgsFromSpecialization(
      FunctionDecl *FromFD);
  Error ImportTemplateParameterLists(const DeclaratorDecl *FromD,
                                     DeclaratorDecl *ToD);

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

  Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD);

  Error ImportDefaultArgOfParmVarDecl(const ParmVarDecl *FromParam,
                                      ParmVarDecl *ToParam);

  Expected<InheritedConstructor>
  ImportInheritedConstructor(const InheritedConstructor &From);

  template <typename T>
  bool hasSameVisibilityContextAndLinkage(T *Found, T *From);

  bool IsStructuralMatch(Decl *From, Decl *To, bool Complain = true);
  ExpectedDecl VisitDecl(Decl *D);
  ExpectedDecl VisitImportDecl(ImportDecl *D);
  ExpectedDecl VisitEmptyDecl(EmptyDecl *D);
  ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D);
  ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D);
  ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
  ExpectedDecl VisitBindingDecl(BindingDecl *D);
  ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D);
  ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
  ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
  ExpectedDecl VisitTypedefDecl(TypedefDecl *D);
  ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D);
  ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
  ExpectedDecl VisitLabelDecl(LabelDecl *D);
  ExpectedDecl VisitEnumDecl(EnumDecl *D);
  ExpectedDecl VisitRecordDecl(RecordDecl *D);
  ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D);
  ExpectedDecl VisitFunctionDecl(FunctionDecl *D);
  ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D);
  ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D);
  ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D);
  ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D);
  ExpectedDecl VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
  ExpectedDecl VisitFieldDecl(FieldDecl *D);
  ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D);
  ExpectedDecl VisitFriendDecl(FriendDecl *D);
  ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D);
  ExpectedDecl VisitVarDecl(VarDecl *D);
  ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D);
  ExpectedDecl VisitParmVarDecl(ParmVarDecl *D);
  ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D);
  ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
  ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D);
  ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D);
  ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D);
  ExpectedDecl VisitUsingDecl(UsingDecl *D);
  ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D);
  ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
  ExpectedDecl VisitUsingPackDecl(UsingPackDecl *D);
  ExpectedDecl ImportUsingShadowDecls(BaseUsingDecl *D, BaseUsingDecl *ToSI);
  ExpectedDecl VisitUsingEnumDecl(UsingEnumDecl *D);
  ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
  ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
  ExpectedDecl VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
  ExpectedDecl
  VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);

  Expected<ObjCTypeParamList *>
  ImportObjCTypeParamList(ObjCTypeParamList *list);

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

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

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

  // Helper for chaining together multiple imports. If an error is detected,
  // subsequent imports will return default constructed nodes, so that failure
  // can be detected with a single conditional branch after a sequence of
  // imports.
  template <typename T> T importChecked(Error &Err, const T &From) {
    // Don't attempt to import nodes if we hit an error earlier.
    if (Err)
2
←
Taking false branch→
      return T{};
    Expected<T> MaybeVal = import(From);
3
←
Calling 'ASTNodeImporter::import'→
    if (!MaybeVal) {
      Err = MaybeVal.takeError();
      return T{};
    }
    return *MaybeVal;
  }

  template<typename IIter, typename OIter>
  Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
    using ItemT = std::remove_reference_t<decltype(*Obegin)>;
    for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
      Expected<ItemT> ToOrErr = import(*Ibegin);
      if (!ToOrErr)
        return ToOrErr.takeError();
      *Obegin = *ToOrErr;
    }
    return Error::success();
  }

  // Import every item from a container structure into an output container.
  // If error occurs, stops at first error and returns the error.
  // The output container should have space for all needed elements (it is not
  // expanded, new items are put into from the beginning).
  template<typename InContainerTy, typename OutContainerTy>
  Error ImportContainerChecked(
      const InContainerTy &InContainer, OutContainerTy &OutContainer) {
    return ImportArrayChecked(
        InContainer.begin(), InContainer.end(), OutContainer.begin());
  }

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

  Error ImportOverriddenMethods(CXXMethodDecl *ToMethod,
                                CXXMethodDecl *FromMethod);

  Expected<FunctionDecl *> FindFunctionTemplateSpecialization(
      FunctionDecl *FromFD);

  // Returns true if the given function has a placeholder return type and
  // that type is declared inside the body of the function.
  // E.g. auto f() { struct X{}; return X(); }
  bool hasAutoReturnTypeDeclaredInside(FunctionDecl *D);
};

744template <typename InContainerTy>
745Error ASTNodeImporter::ImportTemplateArgumentListInfo(
  SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
  const InContainerTy &Container, TemplateArgumentListInfo &Result) {
auto ToLAngleLocOrErr = import(FromLAngleLoc);
if (!ToLAngleLocOrErr)
  return ToLAngleLocOrErr.takeError();
auto ToRAngleLocOrErr = import(FromRAngleLoc);
if (!ToRAngleLocOrErr)
  return ToRAngleLocOrErr.takeError();

TemplateArgumentListInfo ToTAInfo(*ToLAngleLocOrErr, *ToRAngleLocOrErr);
if (auto Err = ImportTemplateArgumentListInfo(Container, ToTAInfo))
  return Err;
Result = ToTAInfo;
return Error::success();
760}

762template <>
763Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
  const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
return ImportTemplateArgumentListInfo(
    From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
767}

769template <>
770Error ASTNodeImporter::ImportTemplateArgumentListInfo<
  ASTTemplateArgumentListInfo>(
      const ASTTemplateArgumentListInfo &From,
      TemplateArgumentListInfo &Result) {
return ImportTemplateArgumentListInfo(
    From.LAngleLoc, From.RAngleLoc, From.arguments(), Result);
776}

778Expected<ASTNodeImporter::FunctionTemplateAndArgsTy>
779ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
  FunctionDecl *FromFD) {
assert(FromFD->getTemplatedKind() ==(static_cast <bool> (FromFD->getTemplatedKind() == FunctionDecl
::TK_FunctionTemplateSpecialization) ? void (0) : __assert_fail
 ("FromFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplateSpecialization"
, "clang/lib/AST/ASTImporter.cpp", 782, __extension__ __PRETTY_FUNCTION__
))
    FunctionDecl::TK_FunctionTemplateSpecialization)(static_cast <bool> (FromFD->getTemplatedKind() == FunctionDecl
::TK_FunctionTemplateSpecialization) ? void (0) : __assert_fail
 ("FromFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplateSpecialization"
, "clang/lib/AST/ASTImporter.cpp", 782, __extension__ __PRETTY_FUNCTION__
));

FunctionTemplateAndArgsTy Result;

auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
if (Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate()))
  return std::move(Err);

// Import template arguments.
if (Error Err = ImportTemplateArguments(FTSInfo->TemplateArguments->asArray(),
                                        std::get<1>(Result)))
  return std::move(Err);

return Result;
796}

798template <>
799Expected<TemplateParameterList *>
800ASTNodeImporter::import(TemplateParameterList *From) {
SmallVector<NamedDecl *, 4> To(From->size());
if (Error Err = ImportContainerChecked(*From, To))
  return std::move(Err);

ExpectedExpr ToRequiresClause = import(From->getRequiresClause());
if (!ToRequiresClause)
  return ToRequiresClause.takeError();

auto ToTemplateLocOrErr = import(From->getTemplateLoc());
if (!ToTemplateLocOrErr)
  return ToTemplateLocOrErr.takeError();
auto ToLAngleLocOrErr = import(From->getLAngleLoc());
if (!ToLAngleLocOrErr)
  return ToLAngleLocOrErr.takeError();
auto ToRAngleLocOrErr = import(From->getRAngleLoc());
if (!ToRAngleLocOrErr)
  return ToRAngleLocOrErr.takeError();

return TemplateParameterList::Create(
    Importer.getToContext(),
    *ToTemplateLocOrErr,
    *ToLAngleLocOrErr,
    To,
    *ToRAngleLocOrErr,
    *ToRequiresClause);
826}

828template <>
829Expected<TemplateArgument>
830ASTNodeImporter::import(const TemplateArgument &From) {
switch (From.getKind()) {
case TemplateArgument::Null:
  return TemplateArgument();

case TemplateArgument::Type: {
  ExpectedType ToTypeOrErr = import(From.getAsType());
  if (!ToTypeOrErr)
    return ToTypeOrErr.takeError();
  return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/ false,
                          From.getIsDefaulted());
}

case TemplateArgument::Integral: {
  ExpectedType ToTypeOrErr = import(From.getIntegralType());
  if (!ToTypeOrErr)
    return ToTypeOrErr.takeError();
  return TemplateArgument(From, *ToTypeOrErr);
}

case TemplateArgument::Declaration: {
  Expected<ValueDecl *> ToOrErr = import(From.getAsDecl());
  if (!ToOrErr)
    return ToOrErr.takeError();
  ExpectedType ToTypeOrErr = import(From.getParamTypeForDecl());
  if (!ToTypeOrErr)
    return ToTypeOrErr.takeError();
  return TemplateArgument(*ToOrErr, *ToTypeOrErr, From.getIsDefaulted());
}

case TemplateArgument::NullPtr: {
  ExpectedType ToTypeOrErr = import(From.getNullPtrType());
  if (!ToTypeOrErr)
    return ToTypeOrErr.takeError();
  return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/ true,
                          From.getIsDefaulted());
}

case TemplateArgument::Template: {
  Expected<TemplateName> ToTemplateOrErr = import(From.getAsTemplate());
  if (!ToTemplateOrErr)
    return ToTemplateOrErr.takeError();

  return TemplateArgument(*ToTemplateOrErr, From.getIsDefaulted());
}

case TemplateArgument::TemplateExpansion: {
  Expected<TemplateName> ToTemplateOrErr =
      import(From.getAsTemplateOrTemplatePattern());
  if (!ToTemplateOrErr)
    return ToTemplateOrErr.takeError();

  return TemplateArgument(*ToTemplateOrErr, From.getNumTemplateExpansions(),
                          From.getIsDefaulted());
}

case TemplateArgument::Expression:
  if (ExpectedExpr ToExpr = import(From.getAsExpr()))
    return TemplateArgument(*ToExpr, From.getIsDefaulted());
  else
    return ToExpr.takeError();

case TemplateArgument::Pack: {
  SmallVector<TemplateArgument, 2> ToPack;
  ToPack.reserve(From.pack_size());
  if (Error Err = ImportTemplateArguments(From.pack_elements(), ToPack))
    return std::move(Err);

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

llvm_unreachable("Invalid template argument kind")::llvm::llvm_unreachable_internal("Invalid template argument kind"
, "clang/lib/AST/ASTImporter.cpp", 903);
904}

906template <>
907Expected<TemplateArgumentLoc>
908ASTNodeImporter::import(const TemplateArgumentLoc &TALoc) {
Expected<TemplateArgument> ArgOrErr = import(TALoc.getArgument());
if (!ArgOrErr)
  return ArgOrErr.takeError();
TemplateArgument Arg = *ArgOrErr;

TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();

TemplateArgumentLocInfo ToInfo;
if (Arg.getKind() == TemplateArgument::Expression) {
  ExpectedExpr E = import(FromInfo.getAsExpr());
  if (!E)
    return E.takeError();
  ToInfo = TemplateArgumentLocInfo(*E);
} else if (Arg.getKind() == TemplateArgument::Type) {
  if (auto TSIOrErr = import(FromInfo.getAsTypeSourceInfo()))
    ToInfo = TemplateArgumentLocInfo(*TSIOrErr);
  else
    return TSIOrErr.takeError();
} else {
  auto ToTemplateQualifierLocOrErr =
      import(FromInfo.getTemplateQualifierLoc());
  if (!ToTemplateQualifierLocOrErr)
    return ToTemplateQualifierLocOrErr.takeError();
  auto ToTemplateNameLocOrErr = import(FromInfo.getTemplateNameLoc());
  if (!ToTemplateNameLocOrErr)
    return ToTemplateNameLocOrErr.takeError();
  auto ToTemplateEllipsisLocOrErr =
      import(FromInfo.getTemplateEllipsisLoc());
  if (!ToTemplateEllipsisLocOrErr)
    return ToTemplateEllipsisLocOrErr.takeError();
  ToInfo = TemplateArgumentLocInfo(
      Importer.getToContext(), *ToTemplateQualifierLocOrErr,
      *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
}

return TemplateArgumentLoc(Arg, ToInfo);
945}

947template <>
948Expected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) {
if (DG.isNull())
  return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
size_t NumDecls = DG.end() - DG.begin();
SmallVector<Decl *, 1> ToDecls;
ToDecls.reserve(NumDecls);
for (Decl *FromD : DG) {
  if (auto ToDOrErr = import(FromD))
    ToDecls.push_back(*ToDOrErr);
  else
    return ToDOrErr.takeError();
}
return DeclGroupRef::Create(Importer.getToContext(),
                            ToDecls.begin(),
                            NumDecls);
963}

965template <>
966Expected<ASTNodeImporter::Designator>
967ASTNodeImporter::import(const Designator &D) {
if (D.isFieldDesignator()) {
  IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());

  ExpectedSLoc ToDotLocOrErr = import(D.getDotLoc());
  if (!ToDotLocOrErr)
    return ToDotLocOrErr.takeError();

  ExpectedSLoc ToFieldLocOrErr = import(D.getFieldLoc());
  if (!ToFieldLocOrErr)
    return ToFieldLocOrErr.takeError();

  return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
}

ExpectedSLoc ToLBracketLocOrErr = import(D.getLBracketLoc());
if (!ToLBracketLocOrErr)
  return ToLBracketLocOrErr.takeError();

ExpectedSLoc ToRBracketLocOrErr = import(D.getRBracketLoc());
if (!ToRBracketLocOrErr)
  return ToRBracketLocOrErr.takeError();

if (D.isArrayDesignator())
  return Designator(D.getFirstExprIndex(),
                    *ToLBracketLocOrErr, *ToRBracketLocOrErr);

ExpectedSLoc ToEllipsisLocOrErr = import(D.getEllipsisLoc());
if (!ToEllipsisLocOrErr)
  return ToEllipsisLocOrErr.takeError();

assert(D.isArrayRangeDesignator())(static_cast <bool> (D.isArrayRangeDesignator()) ? void
 (0) : __assert_fail ("D.isArrayRangeDesignator()", "clang/lib/AST/ASTImporter.cpp"
, 998, __extension__ __PRETTY_FUNCTION__));
return Designator(
    D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
    *ToRBracketLocOrErr);
1002}

1004template <>
1005Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
ValueDecl *Var = nullptr;
if (From.capturesVariable()) {
  if (auto VarOrErr = import(From.getCapturedVar()))
    Var = *VarOrErr;
  else
    return VarOrErr.takeError();
}

auto LocationOrErr = import(From.getLocation());
if (!LocationOrErr)
  return LocationOrErr.takeError();

SourceLocation EllipsisLoc;
if (From.isPackExpansion())
  if (Error Err = importInto(EllipsisLoc, From.getEllipsisLoc()))
    return std::move(Err);

return LambdaCapture(
    *LocationOrErr, From.isImplicit(), From.getCaptureKind(), Var,
    EllipsisLoc);
1026}

1028template <typename T>
1029bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(T *Found, T *From) {
if (Found->getLinkageInternal() != From->getLinkageInternal())
  return false;

if (From->hasExternalFormalLinkage())
  return Found->hasExternalFormalLinkage();
if (Importer.GetFromTU(Found) != From->getTranslationUnitDecl())
  return false;
if (From->isInAnonymousNamespace())
  return Found->isInAnonymousNamespace();
else
  return !Found->isInAnonymousNamespace() &&
         !Found->hasExternalFormalLinkage();
1042}

1044template <>
1045bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(TypedefNameDecl *Found,
                                             TypedefNameDecl *From) {
if (Found->getLinkageInternal() != From->getLinkageInternal())
  return false;

if (From->isInAnonymousNamespace() && Found->isInAnonymousNamespace())
  return Importer.GetFromTU(Found) == From->getTranslationUnitDecl();
return From->isInAnonymousNamespace() == Found->isInAnonymousNamespace();
1053}

1055} // namespace clang

1057//----------------------------------------------------------------------------
1058// Import Types
1059//----------------------------------------------------------------------------

1061using namespace clang;

1063ExpectedType ASTNodeImporter::VisitType(const Type *T) {
Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
  << T->getTypeClassName();
return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
1067}

1069ExpectedType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
ExpectedType UnderlyingTypeOrErr = import(T->getValueType());
if (!UnderlyingTypeOrErr)
  return UnderlyingTypeOrErr.takeError();

return Importer.getToContext().getAtomicType(*UnderlyingTypeOrErr);
1075}

1077ExpectedType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
switch (T->getKind()) {
1079#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id: \
  return Importer.getToContext().SingletonId;
1082#include "clang/Basic/OpenCLImageTypes.def"
1083#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id: \
  return Importer.getToContext().Id##Ty;
1086#include "clang/Basic/OpenCLExtensionTypes.def"
1087#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id: \
  return Importer.getToContext().SingletonId;
1090#include "clang/Basic/AArch64SVEACLETypes.def"
1091#define PPC_VECTOR_TYPE(Name, Id, Size) \
case BuiltinType::Id: \
  return Importer.getToContext().Id##Ty;
1094#include "clang/Basic/PPCTypes.def"
1095#define RVV_TYPE(Name, Id, SingletonId)                                        \
case BuiltinType::Id:                                                        \
  return Importer.getToContext().SingletonId;
1098#include "clang/Basic/RISCVVTypes.def"
1099#define WASM_TYPE(Name, Id, SingletonId)                                       \
case BuiltinType::Id:                                                        \
  return Importer.getToContext().SingletonId;
1102#include "clang/Basic/WebAssemblyReferenceTypes.def"
1103#define SHARED_SINGLETON_TYPE(Expansion)
1104#define BUILTIN_TYPE(Id, SingletonId) \
case BuiltinType::Id: return Importer.getToContext().SingletonId;
1106#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!"
, "clang/lib/AST/ASTImporter.cpp", 1139);
1140}

1142ExpectedType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
ExpectedType ToOriginalTypeOrErr = import(T->getOriginalType());
if (!ToOriginalTypeOrErr)
  return ToOriginalTypeOrErr.takeError();

return Importer.getToContext().getDecayedType(*ToOriginalTypeOrErr);
1148}

1150ExpectedType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
ExpectedType ToElementTypeOrErr = import(T->getElementType());
if (!ToElementTypeOrErr)
  return ToElementTypeOrErr.takeError();

return Importer.getToContext().getComplexType(*ToElementTypeOrErr);
1156}

1158ExpectedType ASTNodeImporter::VisitPointerType(const PointerType *T) {
ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
if (!ToPointeeTypeOrErr)
  return ToPointeeTypeOrErr.takeError();

return Importer.getToContext().getPointerType(*ToPointeeTypeOrErr);
1164}

1166ExpectedType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
// FIXME: Check for blocks support in "to" context.
ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
if (!ToPointeeTypeOrErr)
  return ToPointeeTypeOrErr.takeError();

return Importer.getToContext().getBlockPointerType(*ToPointeeTypeOrErr);
1173}

1175ExpectedType
1176ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
// FIXME: Check for C++ support in "to" context.
ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
if (!ToPointeeTypeOrErr)
  return ToPointeeTypeOrErr.takeError();

return Importer.getToContext().getLValueReferenceType(*ToPointeeTypeOrErr);
1183}

1185ExpectedType
1186ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
// FIXME: Check for C++0x support in "to" context.
ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
if (!ToPointeeTypeOrErr)
  return ToPointeeTypeOrErr.takeError();

return Importer.getToContext().getRValueReferenceType(*ToPointeeTypeOrErr);
1193}

1195ExpectedType
1196ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
// FIXME: Check for C++ support in "to" context.
ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
if (!ToPointeeTypeOrErr)
  return ToPointeeTypeOrErr.takeError();

ExpectedTypePtr ClassTypeOrErr = import(T->getClass());
if (!ClassTypeOrErr)
  return ClassTypeOrErr.takeError();

return Importer.getToContext().getMemberPointerType(*ToPointeeTypeOrErr,
                                                    *ClassTypeOrErr);
1208}

1210ExpectedType
1211ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
Error Err = Error::success();
auto ToElementType = importChecked(Err, T->getElementType());
auto ToSizeExpr = importChecked(Err, T->getSizeExpr());
if (Err)
  return std::move(Err);

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

1223ExpectedType
1224ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
ExpectedType ToElementTypeOrErr = import(T->getElementType());
if (!ToElementTypeOrErr)
  return ToElementTypeOrErr.takeError();

return Importer.getToContext().getIncompleteArrayType(*ToElementTypeOrErr,
                                                      T->getSizeModifier(),
                                              T->getIndexTypeCVRQualifiers());
1232}

1234ExpectedType
1235ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
Error Err = Error::success();
QualType ToElementType = importChecked(Err, T->getElementType());
Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
SourceRange ToBracketsRange = importChecked(Err, T->getBracketsRange());
if (Err)
  return std::move(Err);
return Importer.getToContext().getVariableArrayType(
    ToElementType, ToSizeExpr, T->getSizeModifier(),
    T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1245}

1247ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
  const DependentSizedArrayType *T) {
Error Err = Error::success();
QualType ToElementType = importChecked(Err, T->getElementType());
Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
SourceRange ToBracketsRange = importChecked(Err, T->getBracketsRange());
if (Err)
  return std::move(Err);
// SizeExpr may be null if size is not specified directly.
// For example, 'int a[]'.

return Importer.getToContext().getDependentSizedArrayType(
    ToElementType, ToSizeExpr, T->getSizeModifier(),
    T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1261}

1263ExpectedType ASTNodeImporter::VisitVectorType(const VectorType *T) {
ExpectedType ToElementTypeOrErr = import(T->getElementType());
if (!ToElementTypeOrErr)
  return ToElementTypeOrErr.takeError();

return Importer.getToContext().getVectorType(*ToElementTypeOrErr,
                                             T->getNumElements(),
                                             T->getVectorKind());
1271}

1273ExpectedType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
ExpectedType ToElementTypeOrErr = import(T->getElementType());
if (!ToElementTypeOrErr)
  return ToElementTypeOrErr.takeError();

return Importer.getToContext().getExtVectorType(*ToElementTypeOrErr,
                                                T->getNumElements());
1280}

1282ExpectedType
1283ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
// FIXME: What happens if we're importing a function without a prototype
// into C++? Should we make it variadic?
ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
if (!ToReturnTypeOrErr)
  return ToReturnTypeOrErr.takeError();

return Importer.getToContext().getFunctionNoProtoType(*ToReturnTypeOrErr,
                                                      T->getExtInfo());
1292}

1294ExpectedType
1295ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
if (!ToReturnTypeOrErr)
  return ToReturnTypeOrErr.takeError();

// Import argument types
SmallVector<QualType, 4> ArgTypes;
for (const auto &A : T->param_types()) {
  ExpectedType TyOrErr = import(A);
  if (!TyOrErr)
    return TyOrErr.takeError();
  ArgTypes.push_back(*TyOrErr);
}

// Import exception types
SmallVector<QualType, 4> ExceptionTypes;
for (const auto &E : T->exceptions()) {
  ExpectedType TyOrErr = import(E);
  if (!TyOrErr)
    return TyOrErr.takeError();
  ExceptionTypes.push_back(*TyOrErr);
}

FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
Error Err = Error::success();
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.NoexceptExpr =
    importChecked(Err, FromEPI.ExceptionSpec.NoexceptExpr);
ToEPI.ExceptionSpec.SourceDecl =
    importChecked(Err, FromEPI.ExceptionSpec.SourceDecl);
ToEPI.ExceptionSpec.SourceTemplate =
    importChecked(Err, FromEPI.ExceptionSpec.SourceTemplate);
ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;

if (Err)
  return std::move(Err);

return Importer.getToContext().getFunctionType(
    *ToReturnTypeOrErr, ArgTypes, ToEPI);
1340}

1342ExpectedType ASTNodeImporter::VisitUnresolvedUsingType(
  const UnresolvedUsingType *T) {
Error Err = Error::success();
auto ToD = importChecked(Err, T->getDecl());
auto ToPrevD = importChecked(Err, T->getDecl()->getPreviousDecl());
if (Err)
  return std::move(Err);

return Importer.getToContext().getTypeDeclType(
    ToD, cast_or_null<TypeDecl>(ToPrevD));
1352}

1354ExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) {
ExpectedType ToInnerTypeOrErr = import(T->getInnerType());
if (!ToInnerTypeOrErr)
  return ToInnerTypeOrErr.takeError();

return Importer.getToContext().getParenType(*ToInnerTypeOrErr);
1360}

1362ExpectedType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
Expected<TypedefNameDecl *> ToDeclOrErr = import(T->getDecl());
if (!ToDeclOrErr)
  return ToDeclOrErr.takeError();
ExpectedType ToUnderlyingTypeOrErr = import(T->desugar());
if (!ToUnderlyingTypeOrErr)
  return ToUnderlyingTypeOrErr.takeError();

return Importer.getToContext().getTypedefType(*ToDeclOrErr,
                                              *ToUnderlyingTypeOrErr);
1372}

1374ExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
if (!ToExprOrErr)
  return ToExprOrErr.takeError();
return Importer.getToContext().getTypeOfExprType(*ToExprOrErr, T->getKind());
1379}

1381ExpectedType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
ExpectedType ToUnderlyingTypeOrErr = import(T->getUnmodifiedType());
if (!ToUnderlyingTypeOrErr)
  return ToUnderlyingTypeOrErr.takeError();
return Importer.getToContext().getTypeOfType(*ToUnderlyingTypeOrErr,
                                             T->getKind());
1387}

1389ExpectedType ASTNodeImporter::VisitUsingType(const UsingType *T) {
Expected<UsingShadowDecl *> FoundOrErr = import(T->getFoundDecl());
if (!FoundOrErr)
  return FoundOrErr.takeError();
Expected<QualType> UnderlyingOrErr = import(T->getUnderlyingType());
if (!UnderlyingOrErr)
  return UnderlyingOrErr.takeError();

return Importer.getToContext().getUsingType(*FoundOrErr, *UnderlyingOrErr);
1398}

1400ExpectedType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
// FIXME: Make sure that the "to" context supports C++0x!
ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
if (!ToExprOrErr)
  return ToExprOrErr.takeError();

ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
if (!ToUnderlyingTypeOrErr)
  return ToUnderlyingTypeOrErr.takeError();

return Importer.getToContext().getDecltypeType(
    *ToExprOrErr, *ToUnderlyingTypeOrErr);
1412}

1414ExpectedType
1415ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
if (!ToBaseTypeOrErr)
  return ToBaseTypeOrErr.takeError();

ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
if (!ToUnderlyingTypeOrErr)
  return ToUnderlyingTypeOrErr.takeError();

return Importer.getToContext().getUnaryTransformType(
    *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->getUTTKind());
1426}

1428ExpectedType ASTNodeImporter::VisitAutoType(const AutoType *T) {
// FIXME: Make sure that the "to" context supports C++11!
ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
if (!ToDeducedTypeOrErr)
  return ToDeducedTypeOrErr.takeError();

ExpectedDecl ToTypeConstraintConcept = import(T->getTypeConstraintConcept());
if (!ToTypeConstraintConcept)
  return ToTypeConstraintConcept.takeError();

SmallVector<TemplateArgument, 2> ToTemplateArgs;
if (Error Err = ImportTemplateArguments(T->getTypeConstraintArguments(),
                                        ToTemplateArgs))
  return std::move(Err);

return Importer.getToContext().getAutoType(
    *ToDeducedTypeOrErr, T->getKeyword(), /*IsDependent*/false,
    /*IsPack=*/false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
    ToTemplateArgs);
1447}

1449ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
  const DeducedTemplateSpecializationType *T) {
// FIXME: Make sure that the "to" context supports C++17!
Expected<TemplateName> ToTemplateNameOrErr = import(T->getTemplateName());
if (!ToTemplateNameOrErr)
  return ToTemplateNameOrErr.takeError();
ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
if (!ToDeducedTypeOrErr)
  return ToDeducedTypeOrErr.takeError();

return Importer.getToContext().getDeducedTemplateSpecializationType(
    *ToTemplateNameOrErr, *ToDeducedTypeOrErr, T->isDependentType());
1461}

1463ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
  const InjectedClassNameType *T) {
Expected<CXXRecordDecl *> ToDeclOrErr = import(T->getDecl());
if (!ToDeclOrErr)
  return ToDeclOrErr.takeError();

// The InjectedClassNameType is created in VisitRecordDecl when the
// T->getDecl() is imported. Here we can return the existing type.
const Type *Ty = (*ToDeclOrErr)->getTypeForDecl();
assert(Ty && isa<InjectedClassNameType>(Ty))(static_cast <bool> (Ty && isa<InjectedClassNameType
>(Ty)) ? void (0) : __assert_fail ("Ty && isa<InjectedClassNameType>(Ty)"
, "clang/lib/AST/ASTImporter.cpp", 1472, __extension__ __PRETTY_FUNCTION__
));
return QualType(Ty, 0);
1474}

1476ExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) {
Expected<RecordDecl *> ToDeclOrErr = import(T->getDecl());
if (!ToDeclOrErr)
  return ToDeclOrErr.takeError();

return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
1482}

1484ExpectedType ASTNodeImporter::VisitEnumType(const EnumType *T) {
Expected<EnumDecl *> ToDeclOrErr = import(T->getDecl());
if (!ToDeclOrErr)
  return ToDeclOrErr.takeError();

return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
1490}

1492ExpectedType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
ExpectedType ToModifiedTypeOrErr = import(T->getModifiedType());
if (!ToModifiedTypeOrErr)
  return ToModifiedTypeOrErr.takeError();
ExpectedType ToEquivalentTypeOrErr = import(T->getEquivalentType());
if (!ToEquivalentTypeOrErr)
  return ToEquivalentTypeOrErr.takeError();

return Importer.getToContext().getAttributedType(T->getAttrKind(),
    *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1502}

1504ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
  const TemplateTypeParmType *T) {
Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(T->getDecl());
if (!ToDeclOrErr)
  return ToDeclOrErr.takeError();

return Importer.getToContext().getTemplateTypeParmType(
    T->getDepth(), T->getIndex(), T->isParameterPack(), *ToDeclOrErr);
1512}

1514ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
  const SubstTemplateTypeParmType *T) {
Expected<Decl *> ReplacedOrErr = import(T->getAssociatedDecl());
if (!ReplacedOrErr)
  return ReplacedOrErr.takeError();

ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType());
if (!ToReplacementTypeOrErr)
  return ToReplacementTypeOrErr.takeError();

return Importer.getToContext().getSubstTemplateTypeParmType(
    *ToReplacementTypeOrErr, *ReplacedOrErr, T->getIndex(),
    T->getPackIndex());
1527}

1529ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
  const SubstTemplateTypeParmPackType *T) {
Expected<Decl *> ReplacedOrErr = import(T->getAssociatedDecl());
if (!ReplacedOrErr)
  return ReplacedOrErr.takeError();

Expected<TemplateArgument> ToArgumentPack = import(T->getArgumentPack());
if (!ToArgumentPack)
  return ToArgumentPack.takeError();

return Importer.getToContext().getSubstTemplateTypeParmPackType(
    *ReplacedOrErr, T->getIndex(), T->getFinal(), *ToArgumentPack);
1541}

1543ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
                                     const TemplateSpecializationType *T) {
auto ToTemplateOrErr = import(T->getTemplateName());
if (!ToTemplateOrErr)
  return ToTemplateOrErr.takeError();

SmallVector<TemplateArgument, 2> ToTemplateArgs;
if (Error Err =
        ImportTemplateArguments(T->template_arguments(), ToTemplateArgs))
  return std::move(Err);

QualType ToCanonType;
if (!T->isCanonicalUnqualified()) {
  QualType FromCanonType
    = Importer.getFromContext().getCanonicalType(QualType(T, 0));
  if (ExpectedType TyOrErr = import(FromCanonType))
    ToCanonType = *TyOrErr;
  else
    return TyOrErr.takeError();
}
return Importer.getToContext().getTemplateSpecializationType(*ToTemplateOrErr,
                                                             ToTemplateArgs,
                                                             ToCanonType);
1566}

1568ExpectedType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
// Note: the qualifier in an ElaboratedType is optional.
auto ToQualifierOrErr = import(T->getQualifier());
if (!ToQualifierOrErr)
  return ToQualifierOrErr.takeError();

ExpectedType ToNamedTypeOrErr = import(T->getNamedType());
if (!ToNamedTypeOrErr)
  return ToNamedTypeOrErr.takeError();

Expected<TagDecl *> ToOwnedTagDeclOrErr = import(T->getOwnedTagDecl());
if (!ToOwnedTagDeclOrErr)
  return ToOwnedTagDeclOrErr.takeError();

return Importer.getToContext().getElaboratedType(T->getKeyword(),
                                                 *ToQualifierOrErr,
                                                 *ToNamedTypeOrErr,
                                                 *ToOwnedTagDeclOrErr);
1586}

1588ExpectedType
1589ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
ExpectedType ToPatternOrErr = import(T->getPattern());
if (!ToPatternOrErr)
  return ToPatternOrErr.takeError();

return Importer.getToContext().getPackExpansionType(*ToPatternOrErr,
                                                    T->getNumExpansions(),
                                                    /*ExpactPack=*/false);
1597}

1599ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
  const DependentTemplateSpecializationType *T) {
auto ToQualifierOrErr = import(T->getQualifier());
if (!ToQualifierOrErr)
  return ToQualifierOrErr.takeError();

IdentifierInfo *ToName = Importer.Import(T->getIdentifier());

SmallVector<TemplateArgument, 2> ToPack;
ToPack.reserve(T->template_arguments().size());
if (Error Err = ImportTemplateArguments(T->template_arguments(), ToPack))
  return std::move(Err);

return Importer.getToContext().getDependentTemplateSpecializationType(
    T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1614}

1616ExpectedType
1617ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
auto ToQualifierOrErr = import(T->getQualifier());
if (!ToQualifierOrErr)
  return ToQualifierOrErr.takeError();

IdentifierInfo *Name = Importer.Import(T->getIdentifier());

QualType Canon;
if (T != T->getCanonicalTypeInternal().getTypePtr()) {
  if (ExpectedType TyOrErr = import(T->getCanonicalTypeInternal()))
    Canon = (*TyOrErr).getCanonicalType();
  else
    return TyOrErr.takeError();
}

return Importer.getToContext().getDependentNameType(T->getKeyword(),
                                                    *ToQualifierOrErr,
                                                    Name, Canon);
1635}

1637ExpectedType
1638ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(T->getDecl());
if (!ToDeclOrErr)
  return ToDeclOrErr.takeError();

return Importer.getToContext().getObjCInterfaceType(*ToDeclOrErr);
1644}

1646ExpectedType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
if (!ToBaseTypeOrErr)
  return ToBaseTypeOrErr.takeError();

SmallVector<QualType, 4> TypeArgs;
for (auto TypeArg : T->getTypeArgsAsWritten()) {
  if (ExpectedType TyOrErr = import(TypeArg))
    TypeArgs.push_back(*TyOrErr);
  else
    return TyOrErr.takeError();
}

SmallVector<ObjCProtocolDecl *, 4> Protocols;
for (auto *P : T->quals()) {
  if (Expected<ObjCProtocolDecl *> ProtocolOrErr = import(P))
    Protocols.push_back(*ProtocolOrErr);
  else
    return ProtocolOrErr.takeError();

}

return Importer.getToContext().getObjCObjectType(*ToBaseTypeOrErr, TypeArgs,
                                                 Protocols,
                                                 T->isKindOfTypeAsWritten());
1671}

1673ExpectedType
1674ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
if (!ToPointeeTypeOrErr)
  return ToPointeeTypeOrErr.takeError();

return Importer.getToContext().getObjCObjectPointerType(*ToPointeeTypeOrErr);
1680}

1682//----------------------------------------------------------------------------
1683// Import Declarations
1684//----------------------------------------------------------------------------
1685Error 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);
// FIXME: We could support these constructs by importing a different type of
// this parameter and by importing the original type of the parameter only
// after the FunctionDecl is created. See
// VisitFunctionDecl::UsedDifferentProtoType.
DeclContext *OrigDC = D->getDeclContext();
FunctionDecl *FunDecl;
if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
    FunDecl->hasBody()) {
  auto getLeafPointeeType = [](const Type *T) {
    while (T->isPointerType() || T->isArrayType()) {
      T = T->getPointeeOrArrayElementType();
    }
    return T;
  };
  for (const ParmVarDecl *P : FunDecl->parameters()) {
    const Type *LeafT =
        getLeafPointeeType(P->getType().getCanonicalType().getTypePtr());
    auto *RT = dyn_cast<RecordType>(LeafT);
    if (RT && RT->getDecl() == D) {
      Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
          << D->getDeclKindName();
      return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
    }
  }
}

// Import the context of this declaration.
if (Error Err = ImportDeclContext(D, DC, LexicalDC))
  return Err;

// Import the name of this declaration.
if (Error Err = importInto(Name, D->getDeclName()))
  return Err;

// Import the location of this declaration.
if (Error Err = importInto(Loc, D->getLocation()))
  return Err;

ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
if (ToD)
  if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(D, ToD))
    return Err;

return Error::success();
1734}

1736Error ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclarationName &Name,
                                     NamedDecl *&ToD, SourceLocation &Loc) {

// Import the name of this declaration.
if (Error Err = importInto(Name, D->getDeclName()))
  return Err;

// Import the location of this declaration.
if (Error Err = importInto(Loc, D->getLocation()))
  return Err;

ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
if (ToD)
  if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(D, ToD))
    return Err;

return Error::success();
1753}

1755Error ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
if (!FromD)
  return Error::success();

if (!ToD)
  if (Error Err = importInto(ToD, FromD))
    return Err;

if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
  if (RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
    if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
        !ToRecord->getDefinition()) {
      if (Error Err = ImportDefinition(FromRecord, ToRecord))
        return Err;
    }
  }
  return Error::success();
}

if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
  if (EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
    if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
      if (Error Err = ImportDefinition(FromEnum, ToEnum))
        return Err;
    }
  }
  return Error::success();
}

return Error::success();
1785}

1787Error
1788ASTNodeImporter::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 Error::success();

case DeclarationName::CXXOperatorName: {
  if (auto ToRangeOrErr = import(From.getCXXOperatorNameRange()))
    To.setCXXOperatorNameRange(*ToRangeOrErr);
  else
    return ToRangeOrErr.takeError();
  return Error::success();
}
case DeclarationName::CXXLiteralOperatorName: {
  if (ExpectedSLoc LocOrErr = import(From.getCXXLiteralOperatorNameLoc()))
    To.setCXXLiteralOperatorNameLoc(*LocOrErr);
  else
    return LocOrErr.takeError();
  return Error::success();
}
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName: {
  if (auto ToTInfoOrErr = import(From.getNamedTypeInfo()))
    To.setNamedTypeInfo(*ToTInfoOrErr);
  else
    return ToTInfoOrErr.takeError();
  return Error::success();
}
}
llvm_unreachable("Unknown name kind.")::llvm::llvm_unreachable_internal("Unknown name kind.", "clang/lib/AST/ASTImporter.cpp"
, 1825);
1826}

1828Error
1829ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
if (Importer.isMinimalImport() && !ForceImport) {
  auto ToDCOrErr = Importer.ImportContext(FromDC);
  return ToDCOrErr.takeError();
}

// We use strict error handling in case of records and enums, but not
// with e.g. namespaces.
//
// FIXME Clients of the ASTImporter should be able to choose an
// appropriate error handling strategy for their needs.  For instance,
// they may not want to mark an entire namespace as erroneous merely
// because there is an ODR error with two typedefs.  As another example,
// the client may allow EnumConstantDecls with same names but with
// different values in two distinct translation units.
ChildErrorHandlingStrategy HandleChildErrors(FromDC);

Error ChildErrors = Error::success();
for (auto *From : FromDC->decls()) {
  ExpectedDecl ImportedOrErr = import(From);

  // If we are in the process of ImportDefinition(...) for a RecordDecl we
  // want to make sure that we are also completing each FieldDecl. There
  // are currently cases where this does not happen and this is correctness
  // fix since operations such as code generation will expect this to be so.
  if (ImportedOrErr) {
    FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
    Decl *ImportedDecl = *ImportedOrErr;
    FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
    if (FieldFrom && FieldTo) {
      RecordDecl *FromRecordDecl = nullptr;
      RecordDecl *ToRecordDecl = nullptr;
      // If we have a field that is an ArrayType we need to check if the array
      // element is a RecordDecl and if so we need to import the definition.
      if (FieldFrom->getType()->isArrayType()) {
        // getBaseElementTypeUnsafe(...) handles multi-dimensonal arrays for us.
        FromRecordDecl = FieldFrom->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
        ToRecordDecl = FieldTo->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
      }

      if (!FromRecordDecl || !ToRecordDecl) {
        const RecordType *RecordFrom =
            FieldFrom->getType()->getAs<RecordType>();
        const RecordType *RecordTo = FieldTo->getType()->getAs<RecordType>();

        if (RecordFrom && RecordTo) {
          FromRecordDecl = RecordFrom->getDecl();
          ToRecordDecl = RecordTo->getDecl();
        }
      }

      if (FromRecordDecl && ToRecordDecl) {
        if (FromRecordDecl->isCompleteDefinition() &&
            !ToRecordDecl->isCompleteDefinition()) {
          Error Err = ImportDefinition(FromRecordDecl, ToRecordDecl);
          HandleChildErrors.handleChildImportResult(ChildErrors,
                                                    std::move(Err));
        }
      }
    }
  } else {
    HandleChildErrors.handleChildImportResult(ChildErrors,
                                              ImportedOrErr.takeError());
  }
}

// We reorder declarations in RecordDecls because they may have another order
// in the "to" context than they have in the "from" context. This may happen
// e.g when we import a class like this:
//    struct declToImport {
//        int a = c + b;
//        int b = 1;
//        int c = 2;
//    };
// During the import of `a` we import first the dependencies in sequence,
// thus the order would be `c`, `b`, `a`. We will get the normal order by
// first removing the already imported members and then adding them in the
// order as they apper in the "from" context.
//
// Keeping field order is vital because it determines structure layout.
//
// Here and below, we cannot call field_begin() method and its callers on
// ToDC if it has an external storage. Calling field_begin() will
// automatically load all the fields by calling
// LoadFieldsFromExternalStorage(). LoadFieldsFromExternalStorage() would
// call ASTImporter::Import(). This is because the ExternalASTSource
// interface in LLDB is implemented by the means of the ASTImporter. However,
// calling an import at this point would result in an uncontrolled import, we
// must avoid that.
const auto *FromRD = dyn_cast<RecordDecl>(FromDC);
if (!FromRD)
  return ChildErrors;

auto ToDCOrErr = Importer.ImportContext(FromDC);
if (!ToDCOrErr) {
  consumeError(std::move(ChildErrors));
  return ToDCOrErr.takeError();
}

DeclContext *ToDC = *ToDCOrErr;
// Remove all declarations, which may be in wrong order in the
// lexical DeclContext and then add them in the proper order.
for (auto *D : FromRD->decls()) {
  if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FriendDecl>(D)) {
    assert(D && "DC contains a null decl")(static_cast <bool> (D && "DC contains a null decl"
) ? void (0) : __assert_fail ("D && \"DC contains a null decl\""
, "clang/lib/AST/ASTImporter.cpp", 1933, __extension__ __PRETTY_FUNCTION__
));
    Decl *ToD = Importer.GetAlreadyImportedOrNull(D);
    // Remove only the decls which we successfully imported.
    if (ToD) {
      assert(ToDC == ToD->getLexicalDeclContext() && ToDC->containsDecl(ToD))(static_cast <bool> (ToDC == ToD->getLexicalDeclContext
() && ToDC->containsDecl(ToD)) ? void (0) : __assert_fail
 ("ToDC == ToD->getLexicalDeclContext() && ToDC->containsDecl(ToD)"
, "clang/lib/AST/ASTImporter.cpp", 1937, __extension__ __PRETTY_FUNCTION__
));
      // Remove the decl from its wrong place in the linked list.
      ToDC->removeDecl(ToD);
      // Add the decl to the end of the linked list.
      // This time it will be at the proper place because the enclosing for
      // loop iterates in the original (good) order of the decls.
      ToDC->addDeclInternal(ToD);
    }
  }
}

return ChildErrors;
1949}

1951Error ASTNodeImporter::ImportDeclContext(
  Decl *FromD, DeclContext *&ToDC, DeclContext *&ToLexicalDC) {
auto ToDCOrErr = Importer.ImportContext(FromD->getDeclContext());
if (!ToDCOrErr)
  return ToDCOrErr.takeError();
ToDC = *ToDCOrErr;

if (FromD->getDeclContext() != FromD->getLexicalDeclContext()) {
  auto ToLexicalDCOrErr = Importer.ImportContext(
      FromD->getLexicalDeclContext());
  if (!ToLexicalDCOrErr)
    return ToLexicalDCOrErr.takeError();
  ToLexicalDC = *ToLexicalDCOrErr;
} else
  ToLexicalDC = ToDC;

return Error::success();
1968}

1970Error 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\""
, "clang/lib/AST/ASTImporter.cpp", 1973, __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\""
, "clang/lib/AST/ASTImporter.cpp", 1973, __extension__ __PRETTY_FUNCTION__
));

for (CXXMethodDecl *FromM : From->methods())
  if (FromM->isImplicit()) {
    Expected<CXXMethodDecl *> ToMOrErr = import(FromM);
    if (!ToMOrErr)
      return ToMOrErr.takeError();
  }

return Error::success();
1983}

1985static Error setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
                                     ASTImporter &Importer) {
if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
  if (ExpectedDecl ToTypedefOrErr = Importer.Import(FromTypedef))
    To->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(*ToTypedefOrErr));
  else
    return ToTypedefOrErr.takeError();
}
return Error::success();
1994}

1996Error ASTNodeImporter::ImportDefinition(
  RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind) {
auto DefinitionCompleter = [To]() {
  // There are cases in LLDB when we first import a class without its
  // members. The class will have DefinitionData, but no members. Then,
  // importDefinition is called from LLDB, which tries to get the members, so
  // when we get here, the class already has the DefinitionData set, so we
  // must unset the CompleteDefinition here to be able to complete again the
  // definition.
  To->setCompleteDefinition(false);
  To->completeDefinition();
};

if (To->getDefinition() || To->isBeingDefined()) {
  if (Kind == IDK_Everything ||
      // In case of lambdas, the class already has a definition ptr set, but
      // the contained decls are not imported yet. Also, isBeingDefined was
      // set in CXXRecordDecl::CreateLambda.  We must import the contained
      // decls here and finish the definition.
      (To->isLambda() && shouldForceImportDeclContext(Kind))) {
    if (To->isLambda()) {
      auto *FromCXXRD = cast<CXXRecordDecl>(From);
      SmallVector<LambdaCapture, 8> ToCaptures;
      ToCaptures.reserve(FromCXXRD->capture_size());
      for (const auto &FromCapture : FromCXXRD->captures()) {
        if (auto ToCaptureOrErr = import(FromCapture))
          ToCaptures.push_back(*ToCaptureOrErr);
        else
          return ToCaptureOrErr.takeError();
      }
      cast<CXXRecordDecl>(To)->setCaptures(Importer.getToContext(),
                                           ToCaptures);
    }

    Error Result = ImportDeclContext(From, /*ForceImport=*/true);
    // Finish the definition of the lambda, set isBeingDefined to false.
    if (To->isLambda())
      DefinitionCompleter();
    return Result;
  }

  return Error::success();
}

To->startDefinition();
// Set the definition to complete even if it is really not complete during
// import. Some AST constructs (expressions) require the record layout
// to be calculated (see 'clang::computeDependence') at the time they are
// constructed. Import of such AST node is possible during import of the
// same record, there is no way to have a completely defined record (all
// fields imported) at that time without multiple AST import passes.
if (!Importer.isMinimalImport())
  To->setCompleteDefinition(true);
// Complete the definition even if error is returned.
// The RecordDecl may be already part of the AST so it is better to
// have it in complete state even if something is wrong with it.
auto DefinitionCompleterScopeExit =
    llvm::make_scope_exit(DefinitionCompleter);

if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
  return Err;

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

  struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
  struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();

  #define FIELD(Name, Width, Merge) \
  ToData.Name = FromData.Name;
  #include "clang/AST/CXXRecordDeclDefinitionBits.def"

  // Copy over the data stored in RecordDeclBits
  ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());

  SmallVector<CXXBaseSpecifier *, 4> Bases;
  for (const auto &Base1 : FromCXX->bases()) {
    ExpectedType TyOrErr = import(Base1.getType());
    if (!TyOrErr)
      return TyOrErr.takeError();

    SourceLocation EllipsisLoc;
    if (Base1.isPackExpansion()) {
      if (ExpectedSLoc LocOrErr = import(Base1.getEllipsisLoc()))
        EllipsisLoc = *LocOrErr;
      else
        return LocOrErr.takeError();
    }

    // Ensure that we have a definition for the base.
    if (Error Err =
        ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()))
      return Err;

    auto RangeOrErr = import(Base1.getSourceRange());
    if (!RangeOrErr)
      return RangeOrErr.takeError();

    auto TSIOrErr = import(Base1.getTypeSourceInfo());
    if (!TSIOrErr)
      return TSIOrErr.takeError();

    Bases.push_back(
        new (Importer.getToContext()) CXXBaseSpecifier(
            *RangeOrErr,
            Base1.isVirtual(),
            Base1.isBaseOfClass(),
            Base1.getAccessSpecifierAsWritten(),
            *TSIOrErr,
            EllipsisLoc));
  }
  if (!Bases.empty())
    ToCXX->setBases(Bases.data(), Bases.size());
}

if (shouldForceImportDeclContext(Kind)) {
  if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
    return Err;
}

return Error::success();
2119}

2121Error ASTNodeImporter::ImportInitializer(VarDecl *From, VarDecl *To) {
if (To->getAnyInitializer())
  return Error::success();

Expr *FromInit = From->getInit();
if (!FromInit)
  return Error::success();

ExpectedExpr ToInitOrErr = import(FromInit);
if (!ToInitOrErr)
  return ToInitOrErr.takeError();

To->setInit(*ToInitOrErr);
if (EvaluatedStmt *FromEval = From->getEvaluatedStmt()) {
  EvaluatedStmt *ToEval = To->ensureEvaluatedStmt();
  ToEval->HasConstantInitialization = FromEval->HasConstantInitialization;
  ToEval->HasConstantDestruction = FromEval->HasConstantDestruction;
  // FIXME: Also import the initializer value.
}

// FIXME: Other bits to merge?
return Error::success();
2143}

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

To->startDefinition();

if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
  return Err;

ExpectedType ToTypeOrErr =
    import(Importer.getFromContext().getTypeDeclType(From));
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedType ToPromotionTypeOrErr = import(From->getPromotionType());
if (!ToPromotionTypeOrErr)
  return ToPromotionTypeOrErr.takeError();

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

// FIXME: we might need to merge the number of positive or negative bits
// if the enumerator lists don't match.
To->completeDefinition(*ToTypeOrErr, *ToPromotionTypeOrErr,
                       From->getNumPositiveBits(),
                       From->getNumNegativeBits());
return Error::success();
2177}

2179Error ASTNodeImporter::ImportTemplateArguments(
  ArrayRef<TemplateArgument> FromArgs,
  SmallVectorImpl<TemplateArgument> &ToArgs) {
for (const auto &Arg : FromArgs) {
  if (auto ToOrErr = import(Arg))
    ToArgs.push_back(*ToOrErr);
  else
    return ToOrErr.takeError();
}

return Error::success();
2190}

2192// FIXME: Do not forget to remove this and use only 'import'.
2193Expected<TemplateArgument>
2194ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
return import(From);
2196}

2198template <typename InContainerTy>
2199Error ASTNodeImporter::ImportTemplateArgumentListInfo(
  const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
for (const auto &FromLoc : Container) {
  if (auto ToLocOrErr = import(FromLoc))
    ToTAInfo.addArgument(*ToLocOrErr);
  else
    return ToLocOrErr.takeError();
}
return Error::success();
2208}

2210static StructuralEquivalenceKind
2211getStructuralEquivalenceKind(const ASTImporter &Importer) {
return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
                                  : StructuralEquivalenceKind::Default;
2214}

2216bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, 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(To);
if (ToOrigin) {
  To = ToOrigin;
}

StructuralEquivalenceContext Ctx(
    Importer.getFromContext(), Importer.getToContext(),
    Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
    false, Complain);
return Ctx.IsEquivalent(From, To);
2229}

2231ExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) {
Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
  << D->getDeclKindName();
return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
2235}

2237ExpectedDecl ASTNodeImporter::VisitImportDecl(ImportDecl *D) {
Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
    << D->getDeclKindName();
return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
2241}

2243ExpectedDecl ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
// Import the context of this declaration.
DeclContext *DC, *LexicalDC;
if (Error Err = ImportDeclContext(D, DC, LexicalDC))
  return std::move(Err);

// Import the location of this declaration.
ExpectedSLoc LocOrErr = import(D->getLocation());
if (!LocOrErr)
  return LocOrErr.takeError();

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

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

2263ExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
TranslationUnitDecl *ToD =
  Importer.getToContext().getTranslationUnitDecl();

Importer.MapImported(D, ToD);

return ToD;
2270}

2272ExpectedDecl ASTNodeImporter::VisitBindingDecl(BindingDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToND;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToND, Loc))
  return std::move(Err);
if (ToND)
  return ToND;

BindingDecl *ToD;
if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, Loc,
                            Name.getAsIdentifierInfo()))
  return ToD;

Error Err = Error::success();
QualType ToType = importChecked(Err, D->getType());
Expr *ToBinding = importChecked(Err, D->getBinding());
ValueDecl *ToDecomposedDecl = importChecked(Err, D->getDecomposedDecl());
if (Err)
  return std::move(Err);

ToD->setBinding(ToType, ToBinding);
ToD->setDecomposedDecl(ToDecomposedDecl);
addDeclToContexts(D, ToD);

return ToD;
2299}

2301ExpectedDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
ExpectedSLoc LocOrErr = import(D->getLocation());
if (!LocOrErr)
  return LocOrErr.takeError();
auto ColonLocOrErr = import(D->getColonLoc());
if (!ColonLocOrErr)
  return ColonLocOrErr.takeError();

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

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

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

return ToD;
2326}

2328ExpectedDecl ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
auto DCOrErr = Importer.ImportContext(D->getDeclContext());
if (!DCOrErr)
  return DCOrErr.takeError();
DeclContext *DC = *DCOrErr;
DeclContext *LexicalDC = DC;

Error Err = Error::success();
auto ToLocation = importChecked(Err, D->getLocation());
auto ToRParenLoc = importChecked(Err, D->getRParenLoc());
auto ToAssertExpr = importChecked(Err, D->getAssertExpr());
auto ToMessage = importChecked(Err, D->getMessage());
if (Err)
  return std::move(Err);

StaticAssertDecl *ToD;
if (GetImportedOrCreateDecl(
    ToD, D, Importer.getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
    ToRParenLoc, D->isFailed()))
  return ToD;

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

2354ExpectedDecl ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
// Import the major distinguishing characteristics of this namespace.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
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;
  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
  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()) {
    ExpectedName NameOrErr = Importer.HandleNameConflict(
        Name, DC, Decl::IDNS_Namespace, ConflictingDecls.data(),
        ConflictingDecls.size());
    if (NameOrErr)
      Name = NameOrErr.get();
    else
      return NameOrErr.takeError();
  }
}

ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
if (!BeginLocOrErr)
  return BeginLocOrErr.takeError();
ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
if (!RBraceLocOrErr)
  return RBraceLocOrErr.takeError();

// Create the "to" namespace, if needed.
NamespaceDecl *ToNamespace = MergeWithNamespace;
if (!ToNamespace) {
  if (GetImportedOrCreateDecl(ToNamespace, D, Importer.getToContext(), DC,
                              D->isInline(), *BeginLocOrErr, Loc,
                              Name.getAsIdentifierInfo(),
                              /*PrevDecl=*/nullptr, D->isNested()))
    return ToNamespace;
  ToNamespace->setRBraceLoc(*RBraceLocOrErr);
  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);

if (Error Err = ImportDeclContext(D))
  return std::move(Err);

return ToNamespace;
2435}

2437ExpectedDecl ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
// Import the major distinguishing characteristics of this namespace.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *LookupD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
  return std::move(Err);
if (LookupD)
  return LookupD;

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

Error Err = Error::success();
auto ToNamespaceLoc = importChecked(Err, D->getNamespaceLoc());
auto ToAliasLoc = importChecked(Err, D->getAliasLoc());
auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
auto ToTargetNameLoc = importChecked(Err, D->getTargetNameLoc());
auto ToNamespace = importChecked(Err, D->getNamespace());
if (Err)
  return std::move(Err);

IdentifierInfo *ToIdentifier = Importer.Import(D->getIdentifier());

NamespaceAliasDecl *ToD;
if (GetImportedOrCreateDecl(
    ToD, D, Importer.getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
    ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
  return ToD;

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

return ToD;
2471}

2473ExpectedDecl
2474ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
// Import the major distinguishing characteristics of this typedef.
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
// Do not import the DeclContext, we will import it once the TypedefNameDecl
// is created.
if (Error Err = ImportDeclParts(D, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

DeclContext *DC = cast_or_null<DeclContext>(
    Importer.GetAlreadyImportedOrNull(cast<Decl>(D->getDeclContext())));
DeclContext *LexicalDC =
    cast_or_null<DeclContext>(Importer.GetAlreadyImportedOrNull(
        cast<Decl>(D->getLexicalDeclContext())));

// 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).
// Note: Repeated typedefs are not valid in C99:
// 'typedef int T; typedef int T;' is invalid
// We do not care about this now.
if (DC && !DC->isFunctionOrMethod()) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  unsigned IDNS = Decl::IDNS_Ordinary;
  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;
    if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
      if (!hasSameVisibilityContextAndLinkage(FoundTypedef, D))
        continue;

      QualType FromUT = D->getUnderlyingType();
      QualType FoundUT = FoundTypedef->getUnderlyingType();
      if (Importer.IsStructurallyEquivalent(FromUT, FoundUT)) {
        // If the underlying declarations are unnamed records these can be
        // imported as different types. We should create a distinct typedef
        // node in this case.
        // If we found an existing underlying type with a record in a
        // different context (than the imported), this is already reason for
        // having distinct typedef nodes for these.
        // Again this can create situation like
        // 'typedef int T; typedef int T;' but this is hard to avoid without
        // a rename strategy at import.
        if (!FromUT.isNull() && !FoundUT.isNull()) {
          RecordDecl *FromR = FromUT->getAsRecordDecl();
          RecordDecl *FoundR = FoundUT->getAsRecordDecl();
          if (FromR && FoundR &&
              !hasSameVisibilityContextAndLinkage(FoundR, FromR))
            continue;
        }
        // If the "From" context has a complete underlying type but we
        // already have a complete underlying type then return with that.
        if (!FromUT->isIncompleteType() && !FoundUT->isIncompleteType())
          return Importer.MapImported(D, FoundTypedef);
        // FIXME Handle redecl chain. When you do that make consistent changes
        // in ASTImporterLookupTable too.
      } else {
        ConflictingDecls.push_back(FoundDecl);
      }
    }
  }

  if (!ConflictingDecls.empty()) {
    ExpectedName NameOrErr = Importer.HandleNameConflict(
        Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
    if (NameOrErr)
      Name = NameOrErr.get();
    else
      return NameOrErr.takeError();
  }
}

Error Err = Error::success();
auto ToUnderlyingType = importChecked(Err, D->getUnderlyingType());
auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
if (Err)
  return std::move(Err);

// Create the new typedef node.
// FIXME: ToUnderlyingType is not used.
(void)ToUnderlyingType;
TypedefNameDecl *ToTypedef;
if (IsAlias) {
  if (GetImportedOrCreateDecl<TypeAliasDecl>(
      ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
      Name.getAsIdentifierInfo(), ToTypeSourceInfo))
    return ToTypedef;
} else if (GetImportedOrCreateDecl<TypedefDecl>(
    ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
    Name.getAsIdentifierInfo(), ToTypeSourceInfo))
  return ToTypedef;

// Import the DeclContext and set it to the Typedef.
if ((Err = ImportDeclContext(D, DC, LexicalDC)))
  return std::move(Err);
ToTypedef->setDeclContext(DC);
ToTypedef->setLexicalDeclContext(LexicalDC);
// Add to the lookupTable because we could not do that in MapImported.
Importer.AddToLookupTable(ToTypedef);

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

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

return ToTypedef;
2587}

2589ExpectedDecl ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2591}

2593ExpectedDecl ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2595}

2597ExpectedDecl
2598ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
// Import the major distinguishing characteristics of this typedef.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *FoundD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
  return std::move(Err);
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;
  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
  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()) {
    ExpectedName NameOrErr = Importer.HandleNameConflict(
        Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
    if (NameOrErr)
      Name = NameOrErr.get();
    else
      return NameOrErr.takeError();
  }
}

Error Err = Error::success();
auto ToTemplateParameters = importChecked(Err, D->getTemplateParameters());
auto ToTemplatedDecl = importChecked(Err, D->getTemplatedDecl());
if (Err)
  return std::move(Err);

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

ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);

ToAlias->setAccess(D->getAccess());
ToAlias->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToAlias);
if (DC != Importer.getToContext().getTranslationUnitDecl())
  updateLookupTableForTemplateParameters(*ToTemplateParameters);
return ToAlias;
2653}

2655ExpectedDecl ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
// Import the major distinguishing characteristics of this label.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

assert(LexicalDC->isFunctionOrMethod())(static_cast <bool> (LexicalDC->isFunctionOrMethod()
) ? void (0) : __assert_fail ("LexicalDC->isFunctionOrMethod()"
, "clang/lib/AST/ASTImporter.cpp", 2666, __extension__ __PRETTY_FUNCTION__
));

LabelDecl *ToLabel;
if (D->isGnuLocal()) {
  ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
  if (!BeginLocOrErr)
    return BeginLocOrErr.takeError();
  if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc,
                              Name.getAsIdentifierInfo(), *BeginLocOrErr))
    return ToLabel;

} else {
  if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc,
                              Name.getAsIdentifierInfo()))
    return ToLabel;

}

Expected<LabelStmt *> ToStmtOrErr = import(D->getStmt());
if (!ToStmtOrErr)
  return ToStmtOrErr.takeError();

ToLabel->setStmt(*ToStmtOrErr);
ToLabel->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToLabel);
return ToLabel;
2692}

2694ExpectedDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
// Import the major distinguishing characteristics of this enum.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
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()) {
  if (Error Err = importInto(
      SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
    return std::move(Err);
  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.
EnumDecl *PrevDecl = nullptr;
if (!DC->isFunctionOrMethod() && SearchName) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  auto FoundDecls =
      Importer.findDeclsInToCtx(DC, SearchName);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;

    if (auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
      if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
        FoundDecl = Tag->getDecl();
    }

    if (auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
      if (!hasSameVisibilityContextAndLinkage(FoundEnum, D))
        continue;
      if (IsStructuralMatch(D, FoundEnum)) {
        EnumDecl *FoundDef = FoundEnum->getDefinition();
        if (D->isThisDeclarationADefinition() && FoundDef)
          return Importer.MapImported(D, FoundDef);
        PrevDecl = FoundEnum->getMostRecentDecl();
        break;
      }
      ConflictingDecls.push_back(FoundDecl);
    }
  }

  if (!ConflictingDecls.empty()) {
    ExpectedName NameOrErr = Importer.HandleNameConflict(
        SearchName, DC, IDNS, ConflictingDecls.data(),
        ConflictingDecls.size());
    if (NameOrErr)
      Name = NameOrErr.get();
    else
      return NameOrErr.takeError();
  }
}

Error Err = Error::success();
auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
auto ToIntegerType = importChecked(Err, D->getIntegerType());
auto ToBraceRange = importChecked(Err, D->getBraceRange());
if (Err)
  return std::move(Err);

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

D2->setQualifierInfo(ToQualifierLoc);
D2->setIntegerType(ToIntegerType);
D2->setBraceRange(ToBraceRange);
D2->setAccess(D->getAccess());
D2->setLexicalDeclContext(LexicalDC);
addDeclToContexts(D, D2);

if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
  TemplateSpecializationKind SK = MemberInfo->getTemplateSpecializationKind();
  EnumDecl *FromInst = D->getInstantiatedFromMemberEnum();
  if (Expected<EnumDecl *> ToInstOrErr = import(FromInst))
    D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
  else
    return ToInstOrErr.takeError();
  if (ExpectedSLoc POIOrErr = import(MemberInfo->getPointOfInstantiation()))
    D2->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
  else
    return POIOrErr.takeError();
}

// Import the definition
if (D->isCompleteDefinition())
  if (Error Err = ImportDefinition(D, D2))
    return std::move(Err);

return D2;
2798}

2800ExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
bool IsFriendTemplate = false;
if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
  IsFriendTemplate =
      DCXX->getDescribedClassTemplate() &&
      DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
          Decl::FOK_None;
}

// Import the major distinguishing characteristics of this record.
DeclContext *DC = nullptr, *LexicalDC = nullptr;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
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()) {
  if (Error Err = importInto(
      SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
    return std::move(Err);
  IDNS = Decl::IDNS_Ordinary;
} else if (Importer.getToContext().getLangOpts().CPlusPlus)
  IDNS |= Decl::IDNS_Ordinary | Decl::IDNS_TagFriend;

// We may already have a record of the same name; try to find and match it.
RecordDecl *PrevDecl = nullptr;
if (!DC->isFunctionOrMethod() && !D->isLambda()) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  auto FoundDecls =
      Importer.findDeclsInToCtx(DC, SearchName);
  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 (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
      // Do not emit false positive diagnostic in case of unnamed
      // struct/union and in case of anonymous structs.  Would be false
      // because there may be several anonymous/unnamed structs in a class.
      // E.g. these are both valid:
      //  struct A { // unnamed structs
      //    struct { struct A *next; } entry0;
      //    struct { struct A *next; } entry1;
      //  };
      //  struct X { struct { int a; }; struct { int b; }; }; // anon structs
      if (!SearchName)
        if (!IsStructuralMatch(D, FoundRecord, false))
          continue;

      if (!hasSameVisibilityContextAndLinkage(FoundRecord, D))
        continue;

      if (IsStructuralMatch(D, FoundRecord)) {
        RecordDecl *FoundDef = FoundRecord->getDefinition();
        if (D->isThisDeclarationADefinition() && FoundDef) {
          // 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\""
, "clang/lib/AST/ASTImporter.cpp", 2878, __extension__ __PRETTY_FUNCTION__
));

            if (!Importer.isMinimalImport())
              // FoundDef may not have every implicit method that D has
              // because implicit methods are created only if they are used.
              if (Error Err = ImportImplicitMethods(DCXX, FoundCXX))
                return std::move(Err);
          }
        }
        PrevDecl = FoundRecord->getMostRecentDecl();
        break;
      }
      ConflictingDecls.push_back(FoundDecl);
    } // kind is RecordDecl
  } // for

  if (!ConflictingDecls.empty() && SearchName) {
    ExpectedName NameOrErr = Importer.HandleNameConflict(
        SearchName, DC, IDNS, ConflictingDecls.data(),
        ConflictingDecls.size());
    if (NameOrErr)
      Name = NameOrErr.get();
    else
      return NameOrErr.takeError();
  }
}

ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
if (!BeginLocOrErr)
  return BeginLocOrErr.takeError();

// Create the record declaration.
RecordDecl *D2 = nullptr;
CXXRecordDecl *D2CXX = nullptr;
if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
  if (DCXX->isLambda()) {
    auto TInfoOrErr = import(DCXX->getLambdaTypeInfo());
    if (!TInfoOrErr)
      return TInfoOrErr.takeError();
    if (GetImportedOrCreateSpecialDecl(
            D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
            DC, *TInfoOrErr, Loc, DCXX->getLambdaDependencyKind(),
            DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
      return D2CXX;
    CXXRecordDecl::LambdaNumbering Numbering = DCXX->getLambdaNumbering();
    ExpectedDecl CDeclOrErr = import(Numbering.ContextDecl);
    if (!CDeclOrErr)
      return CDeclOrErr.takeError();
    Numbering.ContextDecl = *CDeclOrErr;
    D2CXX->setLambdaNumbering(Numbering);
 } else if (DCXX->isInjectedClassName()) {
    // We have to be careful to do a similar dance to the one in
    // Sema::ActOnStartCXXMemberDeclarations
    const bool DelayTypeCreation = true;
    if (GetImportedOrCreateDecl(
            D2CXX, D, Importer.getToContext(), D->getTagKind(), DC,
            *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
            cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
      return D2CXX;
    Importer.getToContext().getTypeDeclType(
        D2CXX, dyn_cast<CXXRecordDecl>(DC));
  } else {
    if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
                                D->getTagKind(), DC, *BeginLocOrErr, Loc,
                                Name.getAsIdentifierInfo(),
                                cast_or_null<CXXRecordDecl>(PrevDecl)))
      return D2CXX;
  }

  D2 = D2CXX;
  D2->setAccess(D->getAccess());
  D2->setLexicalDeclContext(LexicalDC);
  addDeclToContexts(D, D2);

  if (ClassTemplateDecl *FromDescribed =
      DCXX->getDescribedClassTemplate()) {
    ClassTemplateDecl *ToDescribed;
    if (Error Err = importInto(ToDescribed, FromDescribed))
      return std::move(Err);
    D2CXX->setDescribedClassTemplate(ToDescribed);
    if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
      // 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).
      CXXRecordDecl *Injected = nullptr;
      for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
        auto *Record = dyn_cast<CXXRecordDecl>(Found);
        if (Record && Record->isInjectedClassName()) {
          Injected = Record;
          break;
        }
      }
      // Create an injected type for the whole redecl chain.
      // The chain may contain an already existing injected type at the start,
      // if yes this should be reused. We must ensure that only one type
      // object exists for the injected type (including the injected record
      // declaration), ASTContext does not check it.
      SmallVector<Decl *, 2> Redecls =
          getCanonicalForwardRedeclChain(D2CXX);
      const Type *FrontTy =
          cast<CXXRecordDecl>(Redecls.front())->getTypeForDecl();
      QualType InjSpec;
      if (auto *InjTy = FrontTy->getAs<InjectedClassNameType>())
        InjSpec = InjTy->getInjectedSpecializationType();
      else
        InjSpec = ToDescribed->getInjectedClassNameSpecialization();
      for (auto *R : Redecls) {
        auto *RI = cast<CXXRecordDecl>(R);
        if (R != Redecls.front() ||
            !isa<InjectedClassNameType>(RI->getTypeForDecl()))
          RI->setTypeForDecl(nullptr);
        // This function tries to get the injected type from getTypeForDecl,
        // then from the previous declaration if possible. If not, it creates
        // a new type.
        Importer.getToContext().getInjectedClassNameType(RI, InjSpec);
      }
      // Set the new type for the injected decl too.
      if (Injected) {
        Injected->setTypeForDecl(nullptr);
        // This function will copy the injected type from D2CXX into Injected.
        // The injected decl does not have a previous decl to copy from.
        Importer.getToContext().getTypeDeclType(Injected, D2CXX);
      }
    }
  } else if (MemberSpecializationInfo *MemberInfo =
                 DCXX->getMemberSpecializationInfo()) {
      TemplateSpecializationKind SK =
          MemberInfo->getTemplateSpecializationKind();
      CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();

      if (Expected<CXXRecordDecl *> ToInstOrErr = import(FromInst))
        D2CXX->setInstantiationOfMemberClass(*ToInstOrErr, SK);
      else
        return ToInstOrErr.takeError();

      if (ExpectedSLoc POIOrErr =
          import(MemberInfo->getPointOfInstantiation()))
        D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
          *POIOrErr);
      else
        return POIOrErr.takeError();
  }

} else {
  if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
                              D->getTagKind(), DC, *BeginLocOrErr, Loc,
                              Name.getAsIdentifierInfo(), PrevDecl))
    return D2;
  D2->setLexicalDeclContext(LexicalDC);
  addDeclToContexts(D, D2);
}

if (auto BraceRangeOrErr = import(D->getBraceRange()))
  D2->setBraceRange(*BraceRangeOrErr);
else
  return BraceRangeOrErr.takeError();
if (auto QualifierLocOrErr = import(D->getQualifierLoc()))
  D2->setQualifierInfo(*QualifierLocOrErr);
else
  return QualifierLocOrErr.takeError();

if (D->isAnonymousStructOrUnion())
  D2->setAnonymousStructOrUnion(true);

if (D->isCompleteDefinition())
  if (Error Err = ImportDefinition(D, D2, IDK_Default))
    return std::move(Err);

return D2;
3048}

3050ExpectedDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
// Import the major distinguishing characteristics of this enumerator.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

// 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;
  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
  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()) {
    ExpectedName NameOrErr = Importer.HandleNameConflict(
        Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
    if (NameOrErr)
      Name = NameOrErr.get();
    else
      return NameOrErr.takeError();
  }
}

ExpectedType TypeOrErr = import(D->getType());
if (!TypeOrErr)
  return TypeOrErr.takeError();

ExpectedExpr InitOrErr = import(D->getInitExpr());
if (!InitOrErr)
  return InitOrErr.takeError();

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

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

3108Error ASTNodeImporter::ImportTemplateParameterLists(const DeclaratorDecl *FromD,
                                                  DeclaratorDecl *ToD) {
unsigned int Num = FromD->getNumTemplateParameterLists();
if (Num == 0)
  return Error::success();
SmallVector<TemplateParameterList *, 2> ToTPLists(Num);
for (unsigned int I = 0; I < Num; ++I)
  if (Expected<TemplateParameterList *> ToTPListOrErr =
          import(FromD->getTemplateParameterList(I)))
    ToTPLists[I] = *ToTPListOrErr;
  else
    return ToTPListOrErr.takeError();
ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);
return Error::success();
3122}

3124Error ASTNodeImporter::ImportTemplateInformation(
  FunctionDecl *FromFD, FunctionDecl *ToFD) {
switch (FromFD->getTemplatedKind()) {
case FunctionDecl::TK_NonTemplate:
case FunctionDecl::TK_FunctionTemplate:
  return Error::success();

case FunctionDecl::TK_DependentNonTemplate:
  if (Expected<FunctionDecl *> InstFDOrErr =
          import(FromFD->getInstantiatedFromDecl()))
    ToFD->setInstantiatedFromDecl(*InstFDOrErr);
  return Error::success();
case FunctionDecl::TK_MemberSpecialization: {
  TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();

  if (Expected<FunctionDecl *> InstFDOrErr =
      import(FromFD->getInstantiatedFromMemberFunction()))
    ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
  else
    return InstFDOrErr.takeError();

  if (ExpectedSLoc POIOrErr = import(
      FromFD->getMemberSpecializationInfo()->getPointOfInstantiation()))
    ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
  else
    return POIOrErr.takeError();

  return Error::success();
}

case FunctionDecl::TK_FunctionTemplateSpecialization: {
  auto FunctionAndArgsOrErr =
      ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
  if (!FunctionAndArgsOrErr)
    return FunctionAndArgsOrErr.takeError();

  TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
        Importer.getToContext(), std::get<1>(*FunctionAndArgsOrErr));

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

  ExpectedSLoc POIOrErr = import(FTSInfo->getPointOfInstantiation());
  if (!POIOrErr)
    return POIOrErr.takeError();

  if (Error Err = ImportTemplateParameterLists(FromFD, ToFD))
    return Err;

  TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
  ToFD->setFunctionTemplateSpecialization(
      std::get<0>(*FunctionAndArgsOrErr), ToTAList, /* InsertPos= */ nullptr,
      TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, *POIOrErr);
  return Error::success();
}

case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
  auto *FromInfo = FromFD->getDependentSpecializationInfo();
  UnresolvedSet<8> TemplDecls;
  unsigned NumTemplates = FromInfo->getNumTemplates();
  for (unsigned I = 0; I < NumTemplates; I++) {
    if (Expected<FunctionTemplateDecl *> ToFTDOrErr =
        import(FromInfo->getTemplate(I)))
      TemplDecls.addDecl(*ToFTDOrErr);
    else
      return ToFTDOrErr.takeError();
  }

  // Import TemplateArgumentListInfo.
  TemplateArgumentListInfo ToTAInfo;
  if (Error Err = ImportTemplateArgumentListInfo(
          FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
          llvm::ArrayRef(FromInfo->getTemplateArgs(),
                         FromInfo->getNumTemplateArgs()),
          ToTAInfo))
    return Err;

  ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
                                           TemplDecls, ToTAInfo);
  return Error::success();
}
}
llvm_unreachable("All cases should be covered!")::llvm::llvm_unreachable_internal("All cases should be covered!"
, "clang/lib/AST/ASTImporter.cpp", 3211);
3212}

3214Expected<FunctionDecl *>
3215ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
auto FunctionAndArgsOrErr =
    ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
if (!FunctionAndArgsOrErr)
  return FunctionAndArgsOrErr.takeError();

FunctionTemplateDecl *Template;
TemplateArgsTy ToTemplArgs;
std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
void *InsertPos = nullptr;
auto *FoundSpec = Template->findSpecialization(ToTemplArgs, InsertPos);
return FoundSpec;
3227}

3229Error ASTNodeImporter::ImportFunctionDeclBody(FunctionDecl *FromFD,
                                            FunctionDecl *ToFD) {
if (Stmt *FromBody = FromFD->getBody()) {
  if (ExpectedStmt ToBodyOrErr = import(FromBody))
    ToFD->setBody(*ToBodyOrErr);
  else
    return ToBodyOrErr.takeError();
}
return Error::success();
3238}

3240// Returns true if the given D has a DeclContext up to the TranslationUnitDecl
3241// which is equal to the given DC, or D is equal to DC.
3242static bool isAncestorDeclContextOf(const DeclContext *DC, const Decl *D) {
const DeclContext *DCi = dyn_cast<DeclContext>(D);
if (!DCi)
  DCi = D->getDeclContext();
assert(DCi && "Declaration should have a context")(static_cast <bool> (DCi && "Declaration should have a context"
) ? void (0) : __assert_fail ("DCi && \"Declaration should have a context\""
, "clang/lib/AST/ASTImporter.cpp", 3246, __extension__ __PRETTY_FUNCTION__
));
while (DCi != D->getTranslationUnitDecl()) {
  if (DCi == DC)
    return true;
  DCi = DCi->getParent();
}
return false;
3253}

3255// Check if there is a declaration that has 'DC' as parent context and is
3256// referenced from statement 'S' or one of its children. The search is done in
3257// BFS order through children of 'S'.
3258static bool isAncestorDeclContextOf(const DeclContext *DC, const Stmt *S) {
SmallVector<const Stmt *> ToProcess;
ToProcess.push_back(S);
while (!ToProcess.empty()) {
  const Stmt *CurrentS = ToProcess.pop_back_val();
  ToProcess.append(CurrentS->child_begin(), CurrentS->child_end());
  if (const auto *DeclRef = dyn_cast<DeclRefExpr>(CurrentS))
    if (const Decl *D = DeclRef->getDecl())
      if (isAncestorDeclContextOf(DC, D))
        return true;
}
return false;
3270}

3272namespace {
3273/// Check if a type has any reference to a declaration that is inside the body
3274/// of a function.
3275/// The \c CheckType(QualType) function should be used to determine
3276/// this property.
3277///
3278/// The type visitor visits one type object only (not recursive).
3279/// To find all referenced declarations we must discover all type objects until
3280/// the canonical type is reached (walk over typedef and similar objects). This
3281/// is done by loop over all "sugar" type objects. For every such type we must
3282/// check all declarations that are referenced from it. For this check the
3283/// visitor is used. In the visit functions all referenced declarations except
3284/// the one that follows in the sugar chain (if any) must be checked. For this
3285/// check the same visitor is re-used (it has no state-dependent data).
3286///
3287/// The visit functions have 3 possible return values:
3288///  - True, found a declaration inside \c ParentDC.
3289///  - False, found declarations only outside \c ParentDC and it is not possible
3290///    to find more declarations (the "sugar" chain does not continue).
3291///  - Empty optional value, found no declarations or only outside \c ParentDC,
3292///    but it is possible to find more declarations in the type "sugar" chain.
3293/// The loop over the "sugar" types can be implemented by using type visit
3294/// functions only (call \c CheckType with the desugared type). With the current
3295/// solution no visit function is needed if the type has only a desugared type
3296/// as data.
3297class IsTypeDeclaredInsideVisitor
  : public TypeVisitor<IsTypeDeclaredInsideVisitor, std::optional<bool>> {
3299public:
IsTypeDeclaredInsideVisitor(const FunctionDecl *ParentDC)
    : ParentDC(ParentDC) {}

bool CheckType(QualType T) {
  // Check the chain of "sugar" types.
  // The "sugar" types are typedef or similar types that have the same
  // canonical type.
  if (std::optional<bool> Res = Visit(T.getTypePtr()))
    return *Res;
  QualType DsT =
      T.getSingleStepDesugaredType(ParentDC->getParentASTContext());
  while (DsT != T) {
    if (std::optional<bool> Res = Visit(DsT.getTypePtr()))
      return *Res;
    T = DsT;
    DsT = T.getSingleStepDesugaredType(ParentDC->getParentASTContext());
  }
  return false;
}

std::optional<bool> VisitTagType(const TagType *T) {
  if (auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl()))
    for (const auto &Arg : Spec->getTemplateArgs().asArray())
      if (checkTemplateArgument(Arg))
        return true;
  return isAncestorDeclContextOf(ParentDC, T->getDecl());
}

std::optional<bool> VisitPointerType(const PointerType *T) {
  return CheckType(T->getPointeeType());
}

std::optional<bool> VisitReferenceType(const ReferenceType *T) {
  return CheckType(T->getPointeeTypeAsWritten());
}

std::optional<bool> VisitTypedefType(const TypedefType *T) {
  const TypedefNameDecl *TD = T->getDecl();
  assert(TD)(static_cast <bool> (TD) ? void (0) : __assert_fail ("TD"
, "clang/lib/AST/ASTImporter.cpp", 3338, __extension__ __PRETTY_FUNCTION__
));
  return isAncestorDeclContextOf(ParentDC, TD);
}

std::optional<bool> VisitUsingType(const UsingType *T) {
  if (T->getFoundDecl() &&
      isAncestorDeclContextOf(ParentDC, T->getFoundDecl()))
    return true;

  return {};
}

std::optional<bool>
VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
  for (const auto &Arg : T->template_arguments())
    if (checkTemplateArgument(Arg))
      return true;
  // This type is a "sugar" to a record type, it can have a desugared type.
  return {};
}

std::optional<bool> VisitConstantArrayType(const ConstantArrayType *T) {
  if (T->getSizeExpr() && isAncestorDeclContextOf(ParentDC, T->getSizeExpr()))
    return true;

  return CheckType(T->getElementType());
}

std::optional<bool> VisitVariableArrayType(const VariableArrayType *T) {
  llvm_unreachable(::llvm::llvm_unreachable_internal("Variable array should not occur in deduced return type of a function"
, "clang/lib/AST/ASTImporter.cpp", 3368)
      "Variable array should not occur in deduced return type of a function")::llvm::llvm_unreachable_internal("Variable array should not occur in deduced return type of a function"
, "clang/lib/AST/ASTImporter.cpp", 3368);
}

std::optional<bool> VisitIncompleteArrayType(const IncompleteArrayType *T) {
  llvm_unreachable("Incomplete array should not occur in deduced return type "::llvm::llvm_unreachable_internal("Incomplete array should not occur in deduced return type "
 "of a function", "clang/lib/AST/ASTImporter.cpp", 3373)
                   "of a function")::llvm::llvm_unreachable_internal("Incomplete array should not occur in deduced return type "
 "of a function", "clang/lib/AST/ASTImporter.cpp", 3373);
}

std::optional<bool> VisitDependentArrayType(const IncompleteArrayType *T) {
  llvm_unreachable("Dependent array should not occur in deduced return type "::llvm::llvm_unreachable_internal("Dependent array should not occur in deduced return type "
 "of a function", "clang/lib/AST/ASTImporter.cpp", 3378)
                   "of a function")::llvm::llvm_unreachable_internal("Dependent array should not occur in deduced return type "
 "of a function", "clang/lib/AST/ASTImporter.cpp", 3378);
}

3381private:
const DeclContext *const ParentDC;

bool checkTemplateArgument(const TemplateArgument &Arg) {
  switch (Arg.getKind()) {
  case TemplateArgument::Null:
    return false;
  case TemplateArgument::Integral:
    return CheckType(Arg.getIntegralType());
  case TemplateArgument::Type:
    return CheckType(Arg.getAsType());
  case TemplateArgument::Expression:
    return isAncestorDeclContextOf(ParentDC, Arg.getAsExpr());
  case TemplateArgument::Declaration:
    // FIXME: The declaration in this case is not allowed to be in a function?
    return isAncestorDeclContextOf(ParentDC, Arg.getAsDecl());
  case TemplateArgument::NullPtr:
    // FIXME: The type is not allowed to be in the function?
    return CheckType(Arg.getNullPtrType());
  case TemplateArgument::Pack:
    for (const auto &PackArg : Arg.getPackAsArray())
      if (checkTemplateArgument(PackArg))
        return true;
    return false;
  case TemplateArgument::Template:
    // Templates can not be defined locally in functions.
    // A template passed as argument can be not in ParentDC.
    return false;
  case TemplateArgument::TemplateExpansion:
    // Templates can not be defined locally in functions.
    // A template passed as argument can be not in ParentDC.
    return false;
  }
  llvm_unreachable("Unknown TemplateArgument::ArgKind enum")::llvm::llvm_unreachable_internal("Unknown TemplateArgument::ArgKind enum"
, "clang/lib/AST/ASTImporter.cpp", 3414);
};
3416};
3417} // namespace

3419bool ASTNodeImporter::hasAutoReturnTypeDeclaredInside(FunctionDecl *D) {
QualType FromTy = D->getType();
const auto *FromFPT = FromTy->getAs<FunctionProtoType>();
assert(FromFPT && "Must be called on FunctionProtoType")(static_cast <bool> (FromFPT && "Must be called on FunctionProtoType"
) ? void (0) : __assert_fail ("FromFPT && \"Must be called on FunctionProtoType\""
, "clang/lib/AST/ASTImporter.cpp", 3422, __extension__ __PRETTY_FUNCTION__
));

QualType RetT = FromFPT->getReturnType();
if (isa<AutoType>(RetT.getTypePtr())) {
  FunctionDecl *Def = D->getDefinition();
  IsTypeDeclaredInsideVisitor Visitor(Def ? Def : D);
  return Visitor.CheckType(RetT);
}

return false;
3432}

3434ExplicitSpecifier
3435ASTNodeImporter::importExplicitSpecifier(Error &Err, ExplicitSpecifier ESpec) {
Expr *ExplicitExpr = ESpec.getExpr();
if (ExplicitExpr)
  ExplicitExpr = importChecked(Err, ESpec.getExpr());
return ExplicitSpecifier(ExplicitExpr, ESpec.getKind());
3440}

3442ExpectedDecl 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) {
  ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
  if (!ToRedeclOrErr)
    return ToRedeclOrErr.takeError();
}
assert(*RedeclIt == D)(static_cast <bool> (*RedeclIt == D) ? void (0) : __assert_fail
 ("*RedeclIt == D", "clang/lib/AST/ASTImporter.cpp", 3453, __extension__
 __PRETTY_FUNCTION__));

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

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 lookup 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) {
  auto FoundFunctionOrErr = FindFunctionTemplateSpecialization(D);
  if (!FoundFunctionOrErr)
    return FoundFunctionOrErr.takeError();
  if (FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
    if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
      return Def;
    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;
  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;

    if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
      if (!hasSameVisibilityContextAndLinkage(FoundFunction, D))
        continue;

      if (IsStructuralMatch(D, FoundFunction)) {
        if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
          return Def;
        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::warn_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()) {
    ExpectedName NameOrErr = Importer.HandleNameConflict(
        Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
    if (NameOrErr)
      Name = NameOrErr.get();
    else
      return NameOrErr.takeError();
  }
}

// We do not allow more than one in-class declaration of a function. This is
// because AST clients like VTableBuilder asserts on this. VTableBuilder
// assumes there is only one in-class declaration. Building a redecl
// chain would result in more than one in-class declaration for
// overrides (even if they are part of the same redecl chain inside the
// derived class.)
if (FoundByLookup) {
  if (isa<CXXMethodDecl>(FoundByLookup)) {
    if (D->getLexicalDeclContext() == D->getDeclContext()) {
      if (!D->doesThisDeclarationHaveABody()) {
        if (FunctionTemplateDecl *DescribedD =
                D->getDescribedFunctionTemplate()) {
          // Handle a "templated" function together with its described
          // template. This avoids need for a similar check at import of the
          // described template.
          assert(FoundByLookup->getDescribedFunctionTemplate() &&(static_cast <bool> (FoundByLookup->getDescribedFunctionTemplate
() && "Templated function mapped to non-templated?") ?
 void (0) : __assert_fail ("FoundByLookup->getDescribedFunctionTemplate() && \"Templated function mapped to non-templated?\""
, "clang/lib/AST/ASTImporter.cpp", 3546, __extension__ __PRETTY_FUNCTION__
))
                 "Templated function mapped to non-templated?")(static_cast <bool> (FoundByLookup->getDescribedFunctionTemplate
() && "Templated function mapped to non-templated?") ?
 void (0) : __assert_fail ("FoundByLookup->getDescribedFunctionTemplate() && \"Templated function mapped to non-templated?\""
, "clang/lib/AST/ASTImporter.cpp", 3546, __extension__ __PRETTY_FUNCTION__
));
          Importer.MapImported(DescribedD,
                               FoundByLookup->getDescribedFunctionTemplate());
        }
        return Importer.MapImported(D, FoundByLookup);
      } else {
        // Let's continue and build up the redecl chain in this case.
        // FIXME Merge the functions into one decl.
      }
    }
  }
}

DeclarationNameInfo NameInfo(Name, Loc);
// Import additional name location/type info.
if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
  return std::move(Err);

QualType FromTy = D->getType();
TypeSourceInfo *FromTSI = D->getTypeSourceInfo();
// Set to true if we do not import the type of the function as is. There are
// cases when the original type would result in an infinite recursion during
// the import. To avoid an infinite recursion when importing, we create the
// FunctionDecl with a simplified function type and update it only after the
// relevant AST nodes are already imported.
// The type is related to TypeSourceInfo (it references the type), so we must
// do the same with TypeSourceInfo.
bool UsedDifferentProtoType = false;
if (const auto *FromFPT = FromTy->getAs<FunctionProtoType>()) {
  QualType FromReturnTy = FromFPT->getReturnType();
  // Functions with auto return type may define a struct inside their body
  // and the return type could refer to that struct.
  // E.g.: auto foo() { struct X{}; return X(); }
  // To avoid an infinite recursion when importing, create the FunctionDecl
  // with a simplified return type.
  if (hasAutoReturnTypeDeclaredInside(D)) {
    FromReturnTy = Importer.getFromContext().VoidTy;
    UsedDifferentProtoType = true;
  }
  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.
  if (FromEPI.ExceptionSpec.SourceDecl ||
      FromEPI.ExceptionSpec.SourceTemplate ||
      FromEPI.ExceptionSpec.NoexceptExpr) {
    FunctionProtoType::ExtProtoInfo DefaultEPI;
    FromEPI = DefaultEPI;
    UsedDifferentProtoType = true;
  }
  FromTy = Importer.getFromContext().getFunctionType(
      FromReturnTy, FromFPT->getParamTypes(), FromEPI);
  FromTSI = Importer.getFromContext().getTrivialTypeSourceInfo(
      FromTy, D->getBeginLoc());
}

Error Err = Error::success();
auto T = importChecked(Err, FromTy);
auto TInfo = importChecked(Err, FromTSI);
auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
auto ToEndLoc = importChecked(Err, D->getEndLoc());
auto ToDefaultLoc = importChecked(Err, D->getDefaultLoc());
auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
auto TrailingRequiresClause =
    importChecked(Err, D->getTrailingRequiresClause());
if (Err)
  return std::move(Err);

// Import the function parameters.
SmallVector<ParmVarDecl *, 8> Parameters;
for (auto *P : D->parameters()) {
  if (Expected<ParmVarDecl *> ToPOrErr = import(P))
    Parameters.push_back(*ToPOrErr);
  else
    return ToPOrErr.takeError();
}

// Create the imported function.
FunctionDecl *ToFunction = nullptr;
if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
  ExplicitSpecifier ESpec =
      importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
  if (Err)
    return std::move(Err);
  auto ToInheritedConstructor = InheritedConstructor();
  if (FromConstructor->isInheritingConstructor()) {
    Expected<InheritedConstructor> ImportedInheritedCtor =
        import(FromConstructor->getInheritedConstructor());
    if (!ImportedInheritedCtor)
      return ImportedInheritedCtor.takeError();
    ToInheritedConstructor = *ImportedInheritedCtor;
  }
  if (GetImportedOrCreateDecl<CXXConstructorDecl>(
          ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
          ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->UsesFPIntrin(),
          D->isInlineSpecified(), D->isImplicit(), D->getConstexprKind(),
          ToInheritedConstructor, TrailingRequiresClause))
    return ToFunction;
} else if (CXXDestructorDecl *FromDtor = dyn_cast<CXXDestructorDecl>(D)) {

  Error Err = Error::success();
  auto ToOperatorDelete = importChecked(
      Err, const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()));
  auto ToThisArg = importChecked(Err, FromDtor->getOperatorDeleteThisArg());
  if (Err)
    return std::move(Err);

  if (GetImportedOrCreateDecl<CXXDestructorDecl>(
          ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
          ToInnerLocStart, NameInfo, T, TInfo, D->UsesFPIntrin(),
          D->isInlineSpecified(), D->isImplicit(), D->getConstexprKind(),
          TrailingRequiresClause))
    return ToFunction;

  CXXDestructorDecl *ToDtor = cast<CXXDestructorDecl>(ToFunction);

  ToDtor->setOperatorDelete(ToOperatorDelete, ToThisArg);
} else if (CXXConversionDecl *FromConversion =
               dyn_cast<CXXConversionDecl>(D)) {
  ExplicitSpecifier ESpec =
      importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
  if (Err)
    return std::move(Err);
  if (GetImportedOrCreateDecl<CXXConversionDecl>(
          ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
          ToInnerLocStart, NameInfo, T, TInfo, D->UsesFPIntrin(),
          D->isInlineSpecified(), ESpec, D->getConstexprKind(),
          SourceLocation(), TrailingRequiresClause))
    return ToFunction;
} else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
  if (GetImportedOrCreateDecl<CXXMethodDecl>(
          ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
          ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
          Method->UsesFPIntrin(), Method->isInlineSpecified(),
          D->getConstexprKind(), SourceLocation(), TrailingRequiresClause))
    return ToFunction;
} else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
  ExplicitSpecifier ESpec =
      importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
  CXXConstructorDecl *Ctor =
      importChecked(Err, Guide->getCorrespondingConstructor());
  if (Err)
    return std::move(Err);
  if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
          ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart, ESpec,
          NameInfo, T, TInfo, ToEndLoc, Ctor))
    return ToFunction;
  cast<CXXDeductionGuideDecl>(ToFunction)
      ->setIsCopyDeductionCandidate(Guide->isCopyDeductionCandidate());
} else {
  if (GetImportedOrCreateDecl(
          ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart,
          NameInfo, T, TInfo, D->getStorageClass(), D->UsesFPIntrin(),
          D->isInlineSpecified(), D->hasWrittenPrototype(),
          D->getConstexprKind(), TrailingRequiresClause))
    return ToFunction;
}

// Connect the redecl chain.
if (FoundByLookup) {
  auto *Recent = const_cast<FunctionDecl *>(
        FoundByLookup->getMostRecentDecl());
  ToFunction->setPreviousDecl(Recent);
  // FIXME Probably we should merge exception specifications.  E.g. In the
  // "To" context the existing function may have exception specification with
  // noexcept-unevaluated, while the newly imported function may have an
  // evaluated noexcept.  A call to adjustExceptionSpec() on the imported
  // decl and its redeclarations may be required.
}

ToFunction->setQualifierInfo(ToQualifierLoc);
ToFunction->setAccess(D->getAccess());
ToFunction->setLexicalDeclContext(LexicalDC);
ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
ToFunction->setTrivial(D->isTrivial());
ToFunction->setPure(D->isPure());
ToFunction->setDefaulted(D->isDefaulted());
ToFunction->setExplicitlyDefaulted(D->isExplicitlyDefaulted());
ToFunction->setDeletedAsWritten(D->isDeletedAsWritten());
ToFunction->setFriendConstraintRefersToEnclosingTemplate(
    D->FriendConstraintRefersToEnclosingTemplate());
ToFunction->setRangeEnd(ToEndLoc);
ToFunction->setDefaultLoc(ToDefaultLoc);

// Set the parameters.
for (auto *Param : Parameters) {
  Param->setOwningFunction(ToFunction);
  ToFunction->addDeclInternal(Param);
  if (ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable())
    LT->update(Param, Importer.getToContext().getTranslationUnitDecl());
}
ToFunction->setParams(Parameters);

// 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]);
  }
}

// Import the describing template function, if any.
if (FromFT) {
  auto ToFTOrErr = import(FromFT);
  if (!ToFTOrErr)
    return ToFTOrErr.takeError();
}

// Import Ctor initializers.
if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
  if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
    SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers);
    // Import first, then allocate memory and copy if there was no error.
    if (Error Err = ImportContainerChecked(
        FromConstructor->inits(), CtorInitializers))
      return std::move(Err);
    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);
  }
}

// If it is a template, import all related things.
if (Error Err = ImportTemplateInformation(D, ToFunction))
  return std::move(Err);

if (D->doesThisDeclarationHaveABody()) {
  Error Err = ImportFunctionDeclBody(D, ToFunction);

  if (Err)
    return std::move(Err);
}

// Import and set the original type in case we used another type.
if (UsedDifferentProtoType) {
  if (ExpectedType TyOrErr = import(D->getType()))
    ToFunction->setType(*TyOrErr);
  else
    return TyOrErr.takeError();
  if (Expected<TypeSourceInfo *> TSIOrErr = import(D->getTypeSourceInfo()))
    ToFunction->setTypeSourceInfo(*TSIOrErr);
  else
    return TSIOrErr.takeError();
}

// FIXME: Other bits to merge?

addDeclToContexts(D, ToFunction);

if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
  if (Error Err = ImportOverriddenMethods(cast<CXXMethodDecl>(ToFunction),
                                          FromCXXMethod))
    return std::move(Err);

// Import the rest of the chain. I.e. import all subsequent declarations.
for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
  ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
  if (!ToRedeclOrErr)
    return ToRedeclOrErr.takeError();
}

return ToFunction;
3814}

3816ExpectedDecl ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
return VisitFunctionDecl(D);
3818}

3820ExpectedDecl ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
return VisitCXXMethodDecl(D);
3822}

3824ExpectedDecl ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
return VisitCXXMethodDecl(D);
3826}

3828ExpectedDecl ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
return VisitCXXMethodDecl(D);
3830}

3832ExpectedDecl
3833ASTNodeImporter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
return VisitFunctionDecl(D);
3835}

3837ExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
// Import the major distinguishing characteristics of a variable.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

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

    if (Importer.IsStructurallyEquivalent(D->getType(),
                                          FoundField->getType())) {
      Importer.MapImported(D, FoundField);
      // In case of a FieldDecl of a ClassTemplateSpecializationDecl, the
      // initializer of a FieldDecl might not had been instantiated in the
      // "To" context.  However, the "From" context might instantiated that,
      // thus we have to merge that.
      // Note: `hasInClassInitializer()` is not the same as non-null
      // `getInClassInitializer()` value.
      if (Expr *FromInitializer = D->getInClassInitializer()) {
        if (ExpectedExpr ToInitializerOrErr = import(FromInitializer)) {
          // Import of the FromInitializer may result in the setting of
          // InClassInitializer. If not, set it here.
          assert(FoundField->hasInClassInitializer() &&(static_cast <bool> (FoundField->hasInClassInitializer
() && "Field should have an in-class initializer if it has an "
 "expression for it.") ? void (0) : __assert_fail ("FoundField->hasInClassInitializer() && \"Field should have an in-class initializer if it has an \" \"expression for it.\""
, "clang/lib/AST/ASTImporter.cpp", 3873, __extension__ __PRETTY_FUNCTION__
))
                 "Field should have an in-class initializer if it has an "(static_cast <bool> (FoundField->hasInClassInitializer
() && "Field should have an in-class initializer if it has an "
 "expression for it.") ? void (0) : __assert_fail ("FoundField->hasInClassInitializer() && \"Field should have an in-class initializer if it has an \" \"expression for it.\""
, "clang/lib/AST/ASTImporter.cpp", 3873, __extension__ __PRETTY_FUNCTION__
))
                 "expression for it.")(static_cast <bool> (FoundField->hasInClassInitializer
() && "Field should have an in-class initializer if it has an "
 "expression for it.") ? void (0) : __assert_fail ("FoundField->hasInClassInitializer() && \"Field should have an in-class initializer if it has an \" \"expression for it.\""
, "clang/lib/AST/ASTImporter.cpp", 3873, __extension__ __PRETTY_FUNCTION__
));
          if (!FoundField->getInClassInitializer())
            FoundField->setInClassInitializer(*ToInitializerOrErr);
        } else {
            return ToInitializerOrErr.takeError();
        }
      }
      return FoundField;
    }

    // FIXME: Why is this case not handled with calling HandleNameConflict?
    Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
      << Name << D->getType() << FoundField->getType();
    Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
      << FoundField->getType();

    return make_error<ASTImportError>(ASTImportError::NameConflict);
  }
}

Error Err = Error::success();
auto ToType = importChecked(Err, D->getType());
auto ToTInfo = importChecked(Err, D->getTypeSourceInfo());
auto ToBitWidth = importChecked(Err, D->getBitWidth());
auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
auto ToInitializer = importChecked(Err, D->getInClassInitializer());
if (Err)
  return std::move(Err);
const Type *ToCapturedVLAType = nullptr;
if (Error Err = Importer.importInto(
        ToCapturedVLAType, cast_or_null<Type>(D->getCapturedVLAType())))
  return std::move(Err);

FieldDecl *ToField;
if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
                            ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
                            ToType, ToTInfo, ToBitWidth, D->isMutable(),
                            D->getInClassInitStyle()))
  return ToField;

// We need [[no_unqiue_address]] attributes to be added to FieldDecl, before
// we add fields in CXXRecordDecl::addedMember, otherwise record will be
// marked as having non-zero size.
Err = Importer.ImportAttrs(ToField, D);
if (Err)
  return std::move(Err);
ToField->setAccess(D->getAccess());
ToField->setLexicalDeclContext(LexicalDC);
if (ToInitializer)
  ToField->setInClassInitializer(ToInitializer);
ToField->setImplicit(D->isImplicit());
if (ToCapturedVLAType)
  ToField->setCapturedVLAType(cast<VariableArrayType>(ToCapturedVLAType));
LexicalDC->addDeclInternal(ToField);
return ToField;
3928}

3930ExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
// Import the major distinguishing characteristics of a variable.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

// Determine whether we've already imported this field.
auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
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 &&
        ASTImporter::getFieldIndex(D) !=
        ASTImporter::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;

    // FIXME: Why is this case not handled with calling HandleNameConflict?
    Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
      << Name << D->getType() << FoundField->getType();
    Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
      << FoundField->getType();

    return make_error<ASTImportError>(ASTImportError::NameConflict);
  }
}

// Import the type.
auto TypeOrErr = import(D->getType());
if (!TypeOrErr)
  return TypeOrErr.takeError();

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

unsigned i = 0;
for (auto *PI : D->chain())
  if (Expected<NamedDecl *> ToD = import(PI))
    NamedChain[i++] = *ToD;
  else
    return ToD.takeError();

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

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

4000/// Used as return type of getFriendCountAndPosition.
4001struct FriendCountAndPosition {
/// Number of similar looking friends.
unsigned int TotalCount;
/// Index of the specific FriendDecl.
unsigned int IndexOfDecl;
4006};

4008template <class T>
4009static FriendCountAndPosition getFriendCountAndPosition(
  const FriendDecl *FD,
  llvm::function_ref<T(const FriendDecl *)> GetCanTypeOrDecl) {
unsigned int FriendCount = 0;
std::optional<unsigned int> FriendPosition;
const auto *RD = cast<CXXRecordDecl>(FD->getLexicalDeclContext());

T TypeOrDecl = GetCanTypeOrDecl(FD);

for (const FriendDecl *FoundFriend : RD->friends()) {
  if (FoundFriend == FD) {
    FriendPosition = FriendCount;
    ++FriendCount;
  } else if (!FoundFriend->getFriendDecl() == !FD->getFriendDecl() &&
             GetCanTypeOrDecl(FoundFriend) == TypeOrDecl) {
    ++FriendCount;
  }
}

assert(FriendPosition && "Friend decl not found in own parent.")(static_cast <bool> (FriendPosition && "Friend decl not found in own parent."
) ? void (0) : __assert_fail ("FriendPosition && \"Friend decl not found in own parent.\""
, "clang/lib/AST/ASTImporter.cpp", 4028, __extension__ __PRETTY_FUNCTION__
));

return {FriendCount, *FriendPosition};
4031}

4033static FriendCountAndPosition getFriendCountAndPosition(const FriendDecl *FD) {
if (FD->getFriendType())
  return getFriendCountAndPosition<QualType>(FD, [](const FriendDecl *F) {
    if (TypeSourceInfo *TSI = F->getFriendType())
      return TSI->getType().getCanonicalType();
    llvm_unreachable("Wrong friend object type.")::llvm::llvm_unreachable_internal("Wrong friend object type."
, "clang/lib/AST/ASTImporter.cpp", 4038);
  });
else
  return getFriendCountAndPosition<Decl *>(FD, [](const FriendDecl *F) {
    if (Decl *D = F->getFriendDecl())
      return D->getCanonicalDecl();
    llvm_unreachable("Wrong friend object type.")::llvm::llvm_unreachable_internal("Wrong friend object type."
, "clang/lib/AST/ASTImporter.cpp", 4044);
  });
4046}

4048ExpectedDecl ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
// Import the major distinguishing characteristics of a declaration.
DeclContext *DC, *LexicalDC;
if (Error Err = ImportDeclContext(D, DC, LexicalDC))
  return std::move(Err);

// Determine whether we've already imported this decl.
// FriendDecl is not a NamedDecl so we cannot use lookup.
// We try to maintain order and count of redundant friend declarations.
const auto *RD = cast<CXXRecordDecl>(DC);
FriendDecl *ImportedFriend = RD->getFirstFriend();
SmallVector<FriendDecl *, 2> ImportedEquivalentFriends;

while (ImportedFriend) {
  bool Match = false;
  if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
    Match =
        IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(),
                          /*Complain=*/false);
  } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
    Match = Importer.IsStructurallyEquivalent(
        D->getFriendType()->getType(),
        ImportedFriend->getFriendType()->getType(), /*Complain=*/false);
  }
  if (Match)
    ImportedEquivalentFriends.push_back(ImportedFriend);

  ImportedFriend = ImportedFriend->getNextFriend();
}
FriendCountAndPosition CountAndPosition = getFriendCountAndPosition(D);

assert(ImportedEquivalentFriends.size() <= CountAndPosition.TotalCount &&(static_cast <bool> (ImportedEquivalentFriends.size() <=
 CountAndPosition.TotalCount && "Class with non-matching friends is imported, ODR check wrong?"
) ? void (0) : __assert_fail ("ImportedEquivalentFriends.size() <= CountAndPosition.TotalCount && \"Class with non-matching friends is imported, ODR check wrong?\""
, "clang/lib/AST/ASTImporter.cpp", 4080, __extension__ __PRETTY_FUNCTION__
))
       "Class with non-matching friends is imported, ODR check wrong?")(static_cast <bool> (ImportedEquivalentFriends.size() <=
 CountAndPosition.TotalCount && "Class with non-matching friends is imported, ODR check wrong?"
) ? void (0) : __assert_fail ("ImportedEquivalentFriends.size() <= CountAndPosition.TotalCount && \"Class with non-matching friends is imported, ODR check wrong?\""
, "clang/lib/AST/ASTImporter.cpp", 4080, __extension__ __PRETTY_FUNCTION__
));
if (ImportedEquivalentFriends.size() == CountAndPosition.TotalCount)
  return Importer.MapImported(
      D, ImportedEquivalentFriends[CountAndPosition.IndexOfDecl]);

// Not found. Create it.
// The declarations will be put into order later by ImportDeclContext.
FriendDecl::FriendUnion ToFU;
if (NamedDecl *FriendD = D->getFriendDecl()) {
  NamedDecl *ToFriendD;
  if (Error Err = importInto(ToFriendD, FriendD))
    return std::move(Err);

  if (FriendD->getFriendObjectKind() != Decl::FOK_None &&
      !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
    ToFriendD->setObjectOfFriendDecl(false);

  ToFU = ToFriendD;
} else { // The friend is a type, not a decl.
  if (auto TSIOrErr = import(D->getFriendType()))
    ToFU = *TSIOrErr;
  else
    return TSIOrErr.takeError();
}

SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
for (unsigned I = 0; I < D->NumTPLists; I++) {
  if (auto ListOrErr = import(FromTPLists[I]))
    ToTPLists[I] = *ListOrErr;
  else
    return ListOrErr.takeError();
}

auto LocationOrErr = import(D->getLocation());
if (!LocationOrErr)
  return LocationOrErr.takeError();
auto FriendLocOrErr = import(D->getFriendLoc());
if (!FriendLocOrErr)
  return FriendLocOrErr.takeError();

FriendDecl *FrD;
if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
                            *LocationOrErr, ToFU,
                            *FriendLocOrErr, ToTPLists))
  return FrD;

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

4133ExpectedDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
// Import the major distinguishing characteristics of an ivar.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

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

    Importer.ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
      << Name << D->getType() << FoundIvar->getType();
    Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
      << FoundIvar->getType();

    return make_error<ASTImportError>(ASTImportError::NameConflict);
  }
}

Error Err = Error::success();
auto ToType = importChecked(Err, D->getType());
auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
auto ToBitWidth = importChecked(Err, D->getBitWidth());
auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
if (Err)
  return std::move(Err);

ObjCIvarDecl *ToIvar;
if (GetImportedOrCreateDecl(
        ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
        ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
        ToType, ToTypeSourceInfo,
        D->getAccessControl(),ToBitWidth, D->getSynthesize()))
  return ToIvar;

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

4184ExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *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) {
  ExpectedDecl RedeclOrErr = import(*RedeclIt);
  if (!RedeclOrErr)
    return RedeclOrErr.takeError();
}
assert(*RedeclIt == D)(static_cast <bool> (*RedeclIt == D) ? void (0) : __assert_fail
 ("*RedeclIt == D", "clang/lib/AST/ASTImporter.cpp", 4195, __extension__
 __PRETTY_FUNCTION__));

// Import the major distinguishing characteristics of a variable.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
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.
VarDecl *FoundByLookup = nullptr;
if (D->isFileVarDecl()) {
  SmallVector<NamedDecl *, 4> ConflictingDecls;
  unsigned IDNS = Decl::IDNS_Ordinary;
  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
  for (auto *FoundDecl : FoundDecls) {
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;

    if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
      if (!hasSameVisibilityContextAndLinkage(FoundVar, D))
        continue;
      if (Importer.IsStructurallyEquivalent(D->getType(),
                                            FoundVar->getType())) {

        // The VarDecl in the "From" context has a definition, but in the
        // "To" context we already have a definition.
        VarDecl *FoundDef = FoundVar->getDefinition();
        if (D->isThisDeclarationADefinition() && FoundDef)
          // FIXME Check for ODR error if the two definitions have
          // different initializers?
          return Importer.MapImported(D, FoundDef);

        // The VarDecl in the "From" context has an initializer, but in the
        // "To" context we already have an initializer.
        const VarDecl *FoundDInit = nullptr;
        if (D->getInit() && FoundVar->getAnyInitializer(FoundDInit))
          // FIXME Diagnose ODR error if the two initializers are different?
          return Importer.MapImported(D, const_cast<VarDecl*>(FoundDInit));

        FoundByLookup = 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.
          if (auto TyOrErr = import(D->getType()))
            FoundVar->setType(*TyOrErr);
          else
            return TyOrErr.takeError();

          FoundByLookup = FoundVar;
          break;
        } else if (isa<IncompleteArrayType>(TArray) &&
                   isa<ConstantArrayType>(FoundArray)) {
          FoundByLookup = FoundVar;
          break;
        }
      }

      Importer.ToDiag(Loc, diag::warn_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 (!ConflictingDecls.empty()) {
    ExpectedName NameOrErr = Importer.HandleNameConflict(
        Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
    if (NameOrErr)
      Name = NameOrErr.get();
    else
      return NameOrErr.takeError();
  }
}

Error Err = Error::success();
auto ToType = importChecked(Err, D->getType());
auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
if (Err)
  return std::move(Err);

VarDecl *ToVar;
if (auto *FromDecomp = dyn_cast<DecompositionDecl>(D)) {
  SmallVector<BindingDecl *> Bindings(FromDecomp->bindings().size());
  if (Error Err =
          ImportArrayChecked(FromDecomp->bindings(), Bindings.begin()))
    return std::move(Err);
  DecompositionDecl *ToDecomp;
  if (GetImportedOrCreateDecl(
          ToDecomp, FromDecomp, Importer.getToContext(), DC, ToInnerLocStart,
          Loc, ToType, ToTypeSourceInfo, D->getStorageClass(), Bindings))
    return ToDecomp;
  ToVar = ToDecomp;
} else {
  // Create the imported variable.
  if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC,
                              ToInnerLocStart, Loc,
                              Name.getAsIdentifierInfo(), ToType,
                              ToTypeSourceInfo, D->getStorageClass()))
    return ToVar;
}

ToVar->setTSCSpec(D->getTSCSpec());
ToVar->setQualifierInfo(ToQualifierLoc);
ToVar->setAccess(D->getAccess());
ToVar->setLexicalDeclContext(LexicalDC);

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

// Import the described template, if any.
if (D->getDescribedVarTemplate()) {
  auto ToVTOrErr = import(D->getDescribedVarTemplate());
  if (!ToVTOrErr)
    return ToVTOrErr.takeError();
}

if (Error Err = ImportInitializer(D, ToVar))
  return std::move(Err);

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

addDeclToContexts(D, ToVar);

// Import the rest of the chain. I.e. import all subsequent declarations.
for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
  ExpectedDecl RedeclOrErr = import(*RedeclIt);
  if (!RedeclOrErr)
    return RedeclOrErr.takeError();
}

return ToVar;
4345}

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

Error Err = Error::success();
auto ToDeclName = importChecked(Err, D->getDeclName());
auto ToLocation = importChecked(Err, D->getLocation());
auto ToType = importChecked(Err, D->getType());
if (Err)
  return std::move(Err);

// Create the imported parameter.
ImplicitParamDecl *ToParm = nullptr;
if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
                            ToLocation, ToDeclName.getAsIdentifierInfo(),
                            ToType, D->getParameterKind()))
  return ToParm;
return ToParm;
4366}

4368Error ASTNodeImporter::ImportDefaultArgOfParmVarDecl(
  const ParmVarDecl *FromParam, ParmVarDecl *ToParam) {
ToParam->setHasInheritedDefaultArg(FromParam->hasInheritedDefaultArg());
ToParam->setKNRPromoted(FromParam->isKNRPromoted());

if (FromParam->hasUninstantiatedDefaultArg()) {
  if (auto ToDefArgOrErr = import(FromParam->getUninstantiatedDefaultArg()))
    ToParam->setUninstantiatedDefaultArg(*ToDefArgOrErr);
  else
    return ToDefArgOrErr.takeError();
} else if (FromParam->hasUnparsedDefaultArg()) {
  ToParam->setUnparsedDefaultArg();
} else if (FromParam->hasDefaultArg()) {
  if (auto ToDefArgOrErr = import(FromParam->getDefaultArg()))
    ToParam->setDefaultArg(*ToDefArgOrErr);
  else
    return ToDefArgOrErr.takeError();
}

return Error::success();
4388}

4390Expected<InheritedConstructor>
4391ASTNodeImporter::ImportInheritedConstructor(const InheritedConstructor &From) {
Error Err = Error::success();
CXXConstructorDecl *ToBaseCtor = importChecked(Err, From.getConstructor());
ConstructorUsingShadowDecl *ToShadow =
    importChecked(Err, From.getShadowDecl());
if (Err)
  return std::move(Err);
return InheritedConstructor(ToShadow, ToBaseCtor);
4399}

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

Error Err = Error::success();
auto ToDeclName = importChecked(Err, D->getDeclName());
auto ToLocation = importChecked(Err, D->getLocation());
auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
auto ToType = importChecked(Err, D->getType());
auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
if (Err)
  return std::move(Err);

ParmVarDecl *ToParm;
if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
                            ToInnerLocStart, ToLocation,
                            ToDeclName.getAsIdentifierInfo(), ToType,
                            ToTypeSourceInfo, D->getStorageClass(),
                            /*DefaultArg*/ nullptr))
  return ToParm;

// Set the default argument. It should be no problem if it was already done.
// Do not import the default expression before GetImportedOrCreateDecl call
// to avoid possible infinite import loop because circular dependency.
if (Error Err = ImportDefaultArgOfParmVarDecl(D, ToParm))
  return std::move(Err);

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

return ToParm;
4438}

4440ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
// Import the major distinguishing characteristics of a method.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
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::warn_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 make_error<ASTImportError>(ASTImportError::NameConflict);
    }

    // Check the number of parameters.
    if (D->param_size() != FoundMethod->param_size()) {
      Importer.ToDiag(Loc, diag::warn_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 make_error<ASTImportError>(ASTImportError::NameConflict);
    }

    // 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::warn_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 make_error<ASTImportError>(ASTImportError::NameConflict);
      }
    }

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

      return make_error<ASTImportError>(ASTImportError::NameConflict);
    }

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

Error Err = Error::success();
auto ToEndLoc = importChecked(Err, D->getEndLoc());
auto ToReturnType = importChecked(Err, D->getReturnType());
auto ToReturnTypeSourceInfo =
    importChecked(Err, D->getReturnTypeSourceInfo());
if (Err)
  return std::move(Err);

ObjCMethodDecl *ToMethod;
if (GetImportedOrCreateDecl(
        ToMethod, D, Importer.getToContext(), Loc, ToEndLoc,
        Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
        D->isInstanceMethod(), D->isVariadic(), D->isPropertyAccessor(),
        D->isSynthesizedAccessorStub(), 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()) {
  if (Expected<ParmVarDecl *> ToPOrErr = import(FromP))
    ToParams.push_back(*ToPOrErr);
  else
    return ToPOrErr.takeError();
}

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

SmallVector<SourceLocation, 12> FromSelLocs;
D->getSelectorLocs(FromSelLocs);
SmallVector<SourceLocation, 12> ToSelLocs(FromSelLocs.size());
if (Error Err = ImportContainerChecked(FromSelLocs, ToSelLocs))
  return std::move(Err);

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

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

// Implicit params are declared when Sema encounters the definition but this
// never happens when the method is imported. Manually declare the implicit
// params now that the MethodDecl knows its class interface.
if (D->getSelfDecl())
  ToMethod->createImplicitParams(Importer.getToContext(),
                                 ToMethod->getClassInterface());

return ToMethod;
4570}

4572ExpectedDecl ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
// Import the major distinguishing characteristics of a category.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

Error Err = Error::success();
auto ToVarianceLoc = importChecked(Err, D->getVarianceLoc());
auto ToLocation = importChecked(Err, D->getLocation());
auto ToColonLoc = importChecked(Err, D->getColonLoc());
auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
if (Err)
  return std::move(Err);

ObjCTypeParamDecl *Result;
if (GetImportedOrCreateDecl(
        Result, D, Importer.getToContext(), DC, D->getVariance(),
        ToVarianceLoc, D->getIndex(),
        ToLocation, Name.getAsIdentifierInfo(),
        ToColonLoc, ToTypeSourceInfo))
  return Result;

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

4603ExpectedDecl ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
// Import the major distinguishing characteristics of a category.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

ObjCInterfaceDecl *ToInterface;
if (Error Err = importInto(ToInterface, D->getClassInterface()))
  return std::move(Err);

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

  Error Err = Error::success();
  auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
  auto ToCategoryNameLoc = importChecked(Err, D->getCategoryNameLoc());
  auto ToIvarLBraceLoc = importChecked(Err, D->getIvarLBraceLoc());
  auto ToIvarRBraceLoc = importChecked(Err, D->getIvarRBraceLoc());
  if (Err)
    return std::move(Err);

  if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
                              ToAtStartLoc, Loc,
                              ToCategoryNameLoc,
                              Name.getAsIdentifierInfo(), ToInterface,
                              /*TypeParamList=*/nullptr,
                              ToIvarLBraceLoc,
                              ToIvarRBraceLoc))
    return ToCategory;

  ToCategory->setLexicalDeclContext(LexicalDC);
  LexicalDC->addDeclInternal(ToCategory);
  // Import the type parameter list after MapImported, to avoid
  // loops when bringing in their DeclContext.
  if (auto PListOrErr = ImportObjCTypeParamList(D->getTypeParamList()))
    ToCategory->setTypeParamList(*PListOrErr);
  else
    return PListOrErr.takeError();

  // 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) {
    if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
      Protocols.push_back(*ToProtoOrErr);
    else
      return ToProtoOrErr.takeError();

    if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
      ProtocolLocs.push_back(*ToProtoLocOrErr);
    else
      return ToProtoLocOrErr.takeError();
  }

  // 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.
if (Error Err = ImportDeclContext(D))
  return std::move(Err);

// If we have an implementation, import it as well.
if (D->getImplementation()) {
  if (Expected<ObjCCategoryImplDecl *> ToImplOrErr =
      import(D->getImplementation()))
    ToCategory->setImplementation(*ToImplOrErr);
  else
    return ToImplOrErr.takeError();
}

return ToCategory;
4692}

4694Error ASTNodeImporter::ImportDefinition(
  ObjCProtocolDecl *From, ObjCProtocolDecl *To, ImportDefinitionKind Kind) {
if (To->getDefinition()) {
  if (shouldForceImportDeclContext(Kind))
    if (Error Err = ImportDeclContext(From))
      return Err;
  return Error::success();
}

// 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) {
  if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
    Protocols.push_back(*ToProtoOrErr);
  else
    return ToProtoOrErr.takeError();

  if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
    ProtocolLocs.push_back(*ToProtoLocOrErr);
  else
    return ToProtoLocOrErr.takeError();

}

// 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.
  if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
    return Err;
}
return Error::success();
4737}

4739ExpectedDecl 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) {
  if (ExpectedDecl ImportedDefOrErr = import(Definition))
    return Importer.MapImported(D, *ImportedDefOrErr);
  else
    return ImportedDefOrErr.takeError();
}

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

ObjCProtocolDecl *MergeWithProtocol = nullptr;
auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
for (auto *FoundDecl : FoundDecls) {
  if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
    continue;

  if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
    break;
}

ObjCProtocolDecl *ToProto = MergeWithProtocol;
if (!ToProto) {
  auto ToAtBeginLocOrErr = import(D->getAtStartLoc());
  if (!ToAtBeginLocOrErr)
    return ToAtBeginLocOrErr.takeError();

  if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC,
                              Name.getAsIdentifierInfo(), Loc,
                              *ToAtBeginLocOrErr,
                              /*PrevDecl=*/nullptr))
    return ToProto;
  ToProto->setLexicalDeclContext(LexicalDC);
  LexicalDC->addDeclInternal(ToProto);
}

Importer.MapImported(D, ToProto);

if (D->isThisDeclarationADefinition())
  if (Error Err = ImportDefinition(D, ToProto))
    return std::move(Err);

return ToProto;
4793}

4795ExpectedDecl ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
DeclContext *DC, *LexicalDC;
if (Error Err = ImportDeclContext(D, DC, LexicalDC))
  return std::move(Err);

ExpectedSLoc ExternLocOrErr = import(D->getExternLoc());
if (!ExternLocOrErr)
  return ExternLocOrErr.takeError();

ExpectedSLoc LangLocOrErr = import(D->getLocation());
if (!LangLocOrErr)
  return LangLocOrErr.takeError();

bool HasBraces = D->hasBraces();

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

if (HasBraces) {
  ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
  if (!RBraceLocOrErr)
    return RBraceLocOrErr.takeError();
  ToLinkageSpec->setRBraceLoc(*RBraceLocOrErr);
}

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

return ToLinkageSpec;
4827}

4829ExpectedDecl ASTNodeImporter::ImportUsingShadowDecls(BaseUsingDecl *D,
                                                   BaseUsingDecl *ToSI) {
for (UsingShadowDecl *FromShadow : D->shadows()) {
  if (Expected<UsingShadowDecl *> ToShadowOrErr = import(FromShadow))
    ToSI->addShadowDecl(*ToShadowOrErr);
  else
    // FIXME: We return error here but the definition is already created
    // and available with lookups. How to fix this?..
    return ToShadowOrErr.takeError();
}
return ToSI;
4840}

4842ExpectedDecl ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

Error Err = Error::success();
auto ToLoc = importChecked(Err, D->getNameInfo().getLoc());
auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
if (Err)
  return std::move(Err);

DeclarationNameInfo NameInfo(Name, ToLoc);
if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
  return std::move(Err);

UsingDecl *ToUsing;
if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
                            ToUsingLoc, ToQualifierLoc, NameInfo,
                            D->hasTypename()))
  return ToUsing;

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

if (NamedDecl *FromPattern =
    Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
  if (Expected<NamedDecl *> ToPatternOrErr = import(FromPattern))
    Importer.getToContext().setInstantiatedFromUsingDecl(
        ToUsing, *ToPatternOrErr);
  else
    return ToPatternOrErr.takeError();
}

return ImportUsingShadowDecls(D, ToUsing);
4882}

4884ExpectedDecl ASTNodeImporter::VisitUsingEnumDecl(UsingEnumDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

Error Err = Error::success();
auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
auto ToEnumLoc = importChecked(Err, D->getEnumLoc());
auto ToNameLoc = importChecked(Err, D->getLocation());
auto *ToEnumType = importChecked(Err, D->getEnumType());
if (Err)
  return std::move(Err);

UsingEnumDecl *ToUsingEnum;
if (GetImportedOrCreateDecl(ToUsingEnum, D, Importer.getToContext(), DC,
                            ToUsingLoc, ToEnumLoc, ToNameLoc, ToEnumType))
  return ToUsingEnum;

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

if (UsingEnumDecl *FromPattern =
        Importer.getFromContext().getInstantiatedFromUsingEnumDecl(D)) {
  if (Expected<UsingEnumDecl *> ToPatternOrErr = import(FromPattern))
    Importer.getToContext().setInstantiatedFromUsingEnumDecl(ToUsingEnum,
                                                             *ToPatternOrErr);
  else
    return ToPatternOrErr.takeError();
}

return ImportUsingShadowDecls(D, ToUsingEnum);
4920}

4922ExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

Expected<BaseUsingDecl *> ToIntroducerOrErr = import(D->getIntroducer());
if (!ToIntroducerOrErr)
  return ToIntroducerOrErr.takeError();

Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl());
if (!ToTargetOrErr)
  return ToTargetOrErr.takeError();

UsingShadowDecl *ToShadow;
if (auto *FromConstructorUsingShadow =
        dyn_cast<ConstructorUsingShadowDecl>(D)) {
  Error Err = Error::success();
  ConstructorUsingShadowDecl *Nominated = importChecked(
      Err, FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());
  if (Err)
    return std::move(Err);
  // The 'Target' parameter of ConstructorUsingShadowDecl constructor
  // is really the "NominatedBaseClassShadowDecl" value if it exists
  // (see code of ConstructorUsingShadowDecl::ConstructorUsingShadowDecl).
  // We should pass the NominatedBaseClassShadowDecl to it (if non-null) to
  // get the correct values.
  if (GetImportedOrCreateDecl<ConstructorUsingShadowDecl>(
          ToShadow, D, Importer.getToContext(), DC, Loc,
          cast<UsingDecl>(*ToIntroducerOrErr),
          Nominated ? Nominated : *ToTargetOrErr,
          FromConstructorUsingShadow->constructsVirtualBase()))
    return ToShadow;
} else {
  if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
                              Name, *ToIntroducerOrErr, *ToTargetOrErr))
    return ToShadow;
}

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

if (UsingShadowDecl *FromPattern =
    Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
  if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern))
    Importer.getToContext().setInstantiatedFromUsingShadowDecl(
        ToShadow, *ToPatternOrErr);
  else
    // FIXME: We return error here but the definition is already created
    // and available with lookups. How to fix this?..
    return ToPatternOrErr.takeError();
}

LexicalDC->addDeclInternal(ToShadow);

return ToShadow;
4982}

4984ExpectedDecl ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

auto ToComAncestorOrErr = Importer.ImportContext(D->getCommonAncestor());
if (!ToComAncestorOrErr)
  return ToComAncestorOrErr.takeError();

Error Err = Error::success();
auto ToNominatedNamespace = importChecked(Err, D->getNominatedNamespace());
auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
auto ToNamespaceKeyLocation =
    importChecked(Err, D->getNamespaceKeyLocation());
auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
auto ToIdentLocation = importChecked(Err, D->getIdentLocation());
if (Err)
  return std::move(Err);

UsingDirectiveDecl *ToUsingDir;
if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
                            ToUsingLoc,
                            ToNamespaceKeyLocation,
                            ToQualifierLoc,
                            ToIdentLocation,
                            ToNominatedNamespace, *ToComAncestorOrErr))
  return ToUsingDir;

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

return ToUsingDir;
5021}

5023ExpectedDecl ASTNodeImporter::VisitUsingPackDecl(UsingPackDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

auto ToInstantiatedFromUsingOrErr =
    Importer.Import(D->getInstantiatedFromUsingDecl());
if (!ToInstantiatedFromUsingOrErr)
  return ToInstantiatedFromUsingOrErr.takeError();
SmallVector<NamedDecl *, 4> Expansions(D->expansions().size());
if (Error Err = ImportArrayChecked(D->expansions(), Expansions.begin()))
  return std::move(Err);

UsingPackDecl *ToUsingPack;
if (GetImportedOrCreateDecl(ToUsingPack, D, Importer.getToContext(), DC,
                            cast<NamedDecl>(*ToInstantiatedFromUsingOrErr),
                            Expansions))
  return ToUsingPack;

addDeclToContexts(D, ToUsingPack);

return ToUsingPack;
5050}

5052ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingValueDecl(
  UnresolvedUsingValueDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

Error Err = Error::success();
auto ToLoc = importChecked(Err, D->getNameInfo().getLoc());
auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
auto ToEllipsisLoc = importChecked(Err, D->getEllipsisLoc());
if (Err)
  return std::move(Err);

DeclarationNameInfo NameInfo(Name, ToLoc);
if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
  return std::move(Err);

UnresolvedUsingValueDecl *ToUsingValue;
if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
                            ToUsingLoc, ToQualifierLoc, NameInfo,
                            ToEllipsisLoc))
  return ToUsingValue;

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

return ToUsingValue;
5086}

5088ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
  UnresolvedUsingTypenameDecl *D) {
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD = nullptr;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

Error Err = Error::success();
auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
auto ToTypenameLoc = importChecked(Err, D->getTypenameLoc());
auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
auto ToEllipsisLoc = importChecked(Err, D->getEllipsisLoc());
if (Err)
  return std::move(Err);

UnresolvedUsingTypenameDecl *ToUsing;
if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
                            ToUsingLoc, ToTypenameLoc,
                            ToQualifierLoc, Loc, Name, ToEllipsisLoc))
  return ToUsing;

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

return ToUsing;
5118}

5120ExpectedDecl ASTNodeImporter::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
Decl* ToD = nullptr;
switch (D->getBuiltinTemplateKind()) {
case BuiltinTemplateKind::BTK__make_integer_seq:
  ToD = Importer.getToContext().getMakeIntegerSeqDecl();
  break;
case BuiltinTemplateKind::BTK__type_pack_element:
  ToD = Importer.getToContext().getTypePackElementDecl();
  break;
}
assert(ToD && "BuiltinTemplateDecl of unsupported kind!")(static_cast <bool> (ToD && "BuiltinTemplateDecl of unsupported kind!"
) ? void (0) : __assert_fail ("ToD && \"BuiltinTemplateDecl of unsupported kind!\""
, "clang/lib/AST/ASTImporter.cpp", 5130, __extension__ __PRETTY_FUNCTION__
));
Importer.MapImported(D, ToD);
return ToD;
5133}

5135Error ASTNodeImporter::ImportDefinition(
  ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) {
if (To->getDefinition()) {
  // Check consistency of superclass.
  ObjCInterfaceDecl *FromSuper = From->getSuperClass();
  if (FromSuper) {
    if (auto FromSuperOrErr = import(FromSuper))
      FromSuper = *FromSuperOrErr;
    else
      return FromSuperOrErr.takeError();
  }

  ObjCInterfaceDecl *ToSuper = To->getSuperClass();
  if ((bool)FromSuper != (bool)ToSuper ||
      (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
    Importer.ToDiag(To->getLocation(),
                    diag::warn_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))
    if (Error Err = ImportDeclContext(From))
      return Err;
  return Error::success();
}

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

// If this class has a superclass, import it.
if (From->getSuperClass()) {
  if (auto SuperTInfoOrErr = import(From->getSuperClassTInfo()))
    To->setSuperClass(*SuperTInfoOrErr);
  else
    return SuperTInfoOrErr.takeError();
}

// 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) {
  if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
    Protocols.push_back(*ToProtoOrErr);
  else
    return ToProtoOrErr.takeError();

  if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
    ProtocolLocs.push_back(*ToProtoLocOrErr);
  else
    return ToProtoLocOrErr.takeError();

}

// 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()) {
  auto ToCatOrErr = import(Cat);
  if (!ToCatOrErr)
    return ToCatOrErr.takeError();
}

// If we have an @implementation, import it as well.
if (From->getImplementation()) {
  if (Expected<ObjCImplementationDecl *> ToImplOrErr =
      import(From->getImplementation()))
    To->setImplementation(*ToImplOrErr);
  else
    return ToImplOrErr.takeError();
}

// Import all of the members of this class.
if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
  return Err;

return Error::success();
5233}

5235Expected<ObjCTypeParamList *>
5236ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
if (!list)
  return nullptr;

SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
for (auto *fromTypeParam : *list) {
  if (auto toTypeParamOrErr = import(fromTypeParam))
    toTypeParams.push_back(*toTypeParamOrErr);
  else
    return toTypeParamOrErr.takeError();
}

auto LAngleLocOrErr = import(list->getLAngleLoc());
if (!LAngleLocOrErr)
  return LAngleLocOrErr.takeError();

auto RAngleLocOrErr = import(list->getRAngleLoc());
if (!RAngleLocOrErr)
  return RAngleLocOrErr.takeError();

return ObjCTypeParamList::create(Importer.getToContext(),
                                 *LAngleLocOrErr,
                                 toTypeParams,
                                 *RAngleLocOrErr);
5260}

5262ExpectedDecl 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) {
  if (ExpectedDecl ImportedDefOrErr = import(Definition))
    return Importer.MapImported(D, *ImportedDefOrErr);
  else
    return ImportedDefOrErr.takeError();
}

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

// Look for an existing interface with the same name.
ObjCInterfaceDecl *MergeWithIface = nullptr;
auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
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) {
  ExpectedSLoc AtBeginLocOrErr = import(D->getAtStartLoc());
  if (!AtBeginLocOrErr)
    return AtBeginLocOrErr.takeError();

  if (GetImportedOrCreateDecl(
          ToIface, D, Importer.getToContext(), DC,
          *AtBeginLocOrErr, 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 MapImported, to avoid
// loops when bringing in their DeclContext.
if (auto ToPListOrErr =
    ImportObjCTypeParamList(D->getTypeParamListAsWritten()))
  ToIface->setTypeParamList(*ToPListOrErr);
else
  return ToPListOrErr.takeError();

if (D->isThisDeclarationADefinition())
  if (Error Err = ImportDefinition(D, ToIface))
    return std::move(Err);

return ToIface;
5325}

5327ExpectedDecl
5328ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
ObjCCategoryDecl *Category;
if (Error Err = importInto(Category, D->getCategoryDecl()))
  return std::move(Err);

ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
if (!ToImpl) {
  DeclContext *DC, *LexicalDC;
  if (Error Err = ImportDeclContext(D, DC, LexicalDC))
    return std::move(Err);

  Error Err = Error::success();
  auto ToLocation = importChecked(Err, D->getLocation());
  auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
  auto ToCategoryNameLoc = importChecked(Err, D->getCategoryNameLoc());
  if (Err)
    return std::move(Err);

  if (GetImportedOrCreateDecl(
          ToImpl, D, Importer.getToContext(), DC,
          Importer.Import(D->getIdentifier()), Category->getClassInterface(),
          ToLocation, ToAtStartLoc, ToCategoryNameLoc))
    return ToImpl;

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

Importer.MapImported(D, ToImpl);
if (Error Err = ImportDeclContext(D))
  return std::move(Err);

return ToImpl;
5362}

5364ExpectedDecl
5365ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
// Find the corresponding interface.
ObjCInterfaceDecl *Iface;
if (Error Err = importInto(Iface, D->getClassInterface()))
  return std::move(Err);

// Import the superclass, if any.
ObjCInterfaceDecl *Super;
if (Error Err = importInto(Super, D->getSuperClass()))
  return std::move(Err);

ObjCImplementationDecl *Impl = Iface->getImplementation();
if (!Impl) {
  // We haven't imported an implementation yet. Create a new @implementation
  // now.
  DeclContext *DC, *LexicalDC;
  if (Error Err = ImportDeclContext(D, DC, LexicalDC))
    return std::move(Err);

  Error Err = Error::success();
  auto ToLocation = importChecked(Err, D->getLocation());
  auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
  auto ToSuperClassLoc = importChecked(Err, D->getSuperClassLoc());
  auto ToIvarLBraceLoc = importChecked(Err, D->getIvarLBraceLoc());
  auto ToIvarRBraceLoc = importChecked(Err, D->getIvarRBraceLoc());
  if (Err)
    return std::move(Err);

  if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
                              DC, Iface, Super,
                              ToLocation,
                              ToAtStartLoc,
                              ToSuperClassLoc,
                              ToIvarLBraceLoc,
                              ToIvarRBraceLoc))
    return Impl;

  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::warn_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 make_error<ASTImportError>(ASTImportError::NameConflict);
  }
}

// Import all of the members of this @implementation.
if (Error Err = ImportDeclContext(D))
  return std::move(Err);

return Impl;
5445}

5447ExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
// Import the major distinguishing characteristics of an @property.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
if (ToD)
  return ToD;

// Check whether we have already imported this property.
auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
for (auto *FoundDecl : FoundDecls) {
  if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
    // Instance and class properties can share the same name but are different
    // declarations.
    if (FoundProp->isInstanceProperty() != D->isInstanceProperty())
      continue;

    // Check property types.
    if (!Importer.IsStructurallyEquivalent(D->getType(),
                                           FoundProp->getType())) {
      Importer.ToDiag(Loc, diag::warn_odr_objc_property_type_inconsistent)
        << Name << D->getType() << FoundProp->getType();
      Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
        << FoundProp->getType();

      return make_error<ASTImportError>(ASTImportError::NameConflict);
    }

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

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

Error Err = Error::success();
auto ToType = importChecked(Err, D->getType());
auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
auto ToAtLoc = importChecked(Err, D->getAtLoc());
auto ToLParenLoc = importChecked(Err, D->getLParenLoc());
if (Err)
  return std::move(Err);

// Create the new property.
ObjCPropertyDecl *ToProperty;
if (GetImportedOrCreateDecl(
        ToProperty, D, Importer.getToContext(), DC, Loc,
        Name.getAsIdentifierInfo(), ToAtLoc,
        ToLParenLoc, ToType,
        ToTypeSourceInfo, D->getPropertyImplementation()))
  return ToProperty;

auto ToGetterName = importChecked(Err, D->getGetterName());
auto ToSetterName = importChecked(Err, D->getSetterName());
auto ToGetterNameLoc = importChecked(Err, D->getGetterNameLoc());
auto ToSetterNameLoc = importChecked(Err, D->getSetterNameLoc());
auto ToGetterMethodDecl = importChecked(Err, D->getGetterMethodDecl());
auto ToSetterMethodDecl = importChecked(Err, D->getSetterMethodDecl());
auto ToPropertyIvarDecl = importChecked(Err, D->getPropertyIvarDecl());
if (Err)
  return std::move(Err);

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

ToProperty->setPropertyAttributes(D->getPropertyAttributes());
ToProperty->setPropertyAttributesAsWritten(
                                    D->getPropertyAttributesAsWritten());
ToProperty->setGetterName(ToGetterName, ToGetterNameLoc);
ToProperty->setSetterName(ToSetterName, ToSetterNameLoc);
ToProperty->setGetterMethodDecl(ToGetterMethodDecl);
ToProperty->setSetterMethodDecl(ToSetterMethodDecl);
ToProperty->setPropertyIvarDecl(ToPropertyIvarDecl);
return ToProperty;
5525}

5527ExpectedDecl
5528ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
ObjCPropertyDecl *Property;
if (Error Err = importInto(Property, D->getPropertyDecl()))
  return std::move(Err);

DeclContext *DC, *LexicalDC;
if (Error Err = ImportDeclContext(D, DC, LexicalDC))
  return std::move(Err);

auto *InImpl = cast<ObjCImplDecl>(LexicalDC);

// Import the ivar (for an @synthesize).
ObjCIvarDecl *Ivar = nullptr;
if (Error Err = importInto(Ivar, D->getPropertyIvarDecl()))
  return std::move(Err);

ObjCPropertyImplDecl *ToImpl
  = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
                                 Property->getQueryKind());
if (!ToImpl) {

  Error Err = Error::success();
  auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
  auto ToLocation = importChecked(Err, D->getLocation());
  auto ToPropertyIvarDeclLoc =
      importChecked(Err, D->getPropertyIvarDeclLoc());
  if (Err)
    return std::move(Err);

  if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
                              ToBeginLoc,
                              ToLocation, Property,
                              D->getPropertyImplementation(), Ivar,
                              ToPropertyIvarDeclLoc))
    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::warn_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 make_error<ASTImportError>(ASTImportError::NameConflict);
  }

  // For @synthesize, check that we have the same
  if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
      Ivar != ToImpl->getPropertyIvarDecl()) {
    Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
                    diag::warn_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 make_error<ASTImportError>(ASTImportError::NameConflict);
  }

  // Merge the existing implementation with the new implementation.
  Importer.MapImported(D, ToImpl);
}

return ToImpl;
5603}

5605ExpectedDecl
5606ASTNodeImporter::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.

ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
if (!BeginLocOrErr)
  return BeginLocOrErr.takeError();

ExpectedSLoc LocationOrErr = import(D->getLocation());
if (!LocationOrErr)
  return LocationOrErr.takeError();

TemplateTypeParmDecl *ToD = nullptr;
if (GetImportedOrCreateDecl(
    ToD, D, Importer.getToContext(),
    Importer.getToContext().getTranslationUnitDecl(),
    *BeginLocOrErr, *LocationOrErr,
    D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
    D->wasDeclaredWithTypename(), D->isParameterPack(),
    D->hasTypeConstraint()))
  return ToD;

// Import the type-constraint
if (const TypeConstraint *TC = D->getTypeConstraint()) {

  Error Err = Error::success();
  auto ToNNS = importChecked(Err, TC->getNestedNameSpecifierLoc());
  auto ToName = importChecked(Err, TC->getConceptNameInfo().getName());
  auto ToNameLoc = importChecked(Err, TC->getConceptNameInfo().getLoc());
  auto ToFoundDecl = importChecked(Err, TC->getFoundDecl());
  auto ToNamedConcept = importChecked(Err, TC->getNamedConcept());
  auto ToIDC = importChecked(Err, TC->getImmediatelyDeclaredConstraint());
  if (Err)
    return std::move(Err);

  TemplateArgumentListInfo ToTAInfo;
  const auto *ASTTemplateArgs = TC->getTemplateArgsAsWritten();
  if (ASTTemplateArgs)
    if (Error Err = ImportTemplateArgumentListInfo(*ASTTemplateArgs,
                                                   ToTAInfo))
      return std::move(Err);

  ToD->setTypeConstraint(ToNNS, DeclarationNameInfo(ToName, ToNameLoc),
      ToFoundDecl, ToNamedConcept,
      ASTTemplateArgs ?
          ASTTemplateArgumentListInfo::Create(Importer.getToContext(),
                                              ToTAInfo) : nullptr,
      ToIDC);
}

if (D->hasDefaultArgument()) {
  Expected<TypeSourceInfo *> ToDefaultArgOrErr =
      import(D->getDefaultArgumentInfo());
  if (!ToDefaultArgOrErr)
    return ToDefaultArgOrErr.takeError();
  ToD->setDefaultArgument(*ToDefaultArgOrErr);
}

return ToD;
5666}

5668ExpectedDecl
5669ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {

Error Err = Error::success();
auto ToDeclName = importChecked(Err, D->getDeclName());
auto ToLocation = importChecked(Err, D->getLocation());
auto ToType = importChecked(Err, D->getType());
auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
if (Err)
  return std::move(Err);

NonTypeTemplateParmDecl *ToD = nullptr;
if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(),
                            Importer.getToContext().getTranslationUnitDecl(),
                            ToInnerLocStart, ToLocation, D->getDepth(),
                            D->getPosition(),
                            ToDeclName.getAsIdentifierInfo(), ToType,
                            D->isParameterPack(), ToTypeSourceInfo))
  return ToD;

if (D->hasDefaultArgument()) {
  ExpectedExpr ToDefaultArgOrErr = import(D->getDefaultArgument());
  if (!ToDefaultArgOrErr)
    return ToDefaultArgOrErr.takeError();
  ToD->setDefaultArgument(*ToDefaultArgOrErr);
}

return ToD;
5697}

5699ExpectedDecl
5700ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
// Import the name of this declaration.
auto NameOrErr = import(D->getDeclName());
if (!NameOrErr)
  return NameOrErr.takeError();

// Import the location of this declaration.
ExpectedSLoc LocationOrErr = import(D->getLocation());
if (!LocationOrErr)
  return LocationOrErr.takeError();

// Import template parameters.
auto TemplateParamsOrErr = import(D->getTemplateParameters());
if (!TemplateParamsOrErr)
  return TemplateParamsOrErr.takeError();

TemplateTemplateParmDecl *ToD = nullptr;
if (GetImportedOrCreateDecl(
        ToD, D, Importer.getToContext(),
        Importer.getToContext().getTranslationUnitDecl(), *LocationOrErr,
        D->getDepth(), D->getPosition(), D->isParameterPack(),
        (*NameOrErr).getAsIdentifierInfo(), *TemplateParamsOrErr))
  return ToD;

if (D->hasDefaultArgument()) {
  Expected<TemplateArgumentLoc> ToDefaultArgOrErr =
      import(D->getDefaultArgument());
  if (!ToDefaultArgOrErr)
    return ToDefaultArgOrErr.takeError();
  ToD->setDefaultArgument(Importer.getToContext(), *ToDefaultArgOrErr);
}

return ToD;
5733}

5735// Returns the definition for a (forward) declaration of a TemplateDecl, if
5736// it has any definition in the redecl chain.
5737template <typename T> static auto getTemplateDefinition(T *D) -> T * {
assert(D->getTemplatedDecl() && "Should be called on templates only")(static_cast <bool> (D->getTemplatedDecl() &&
 "Should be called on templates only") ? void (0) : __assert_fail
 ("D->getTemplatedDecl() && \"Should be called on templates only\""
, "clang/lib/AST/ASTImporter.cpp", 5738, __extension__ __PRETTY_FUNCTION__
));
auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
if (!ToTemplatedDef)
  return nullptr;
auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate();
return cast_or_null<T>(TemplateWithDef);
5744}

5746ExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {

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

ClassTemplateDecl *FoundByLookup = nullptr;

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

    Decl *Found = FoundDecl;
    auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found);
    if (FoundTemplate) {
      if (!hasSameVisibilityContextAndLinkage(FoundTemplate, D))
        continue;

      if (IsStructuralMatch(D, FoundTemplate)) {
        ClassTemplateDecl *TemplateWithDef =
            getTemplateDefinition(FoundTemplate);
        if (D->isThisDeclarationADefinition() && TemplateWithDef)
          return Importer.MapImported(D, TemplateWithDef);
        if (!FoundByLookup)
          FoundByLookup = FoundTemplate;
        // Search in all matches because there may be multiple decl chains,
        // see ASTTests test ImportExistingFriendClassTemplateDef.
        continue;
      }
      ConflictingDecls.push_back(FoundDecl);
    }
  }

  if (!ConflictingDecls.empty()) {
    ExpectedName NameOrErr = Importer.HandleNameConflict(
        Name, DC, Decl::IDNS_Ordinary, ConflictingDecls.data(),
        ConflictingDecls.size());
    if (NameOrErr)
      Name = NameOrErr.get();
    else
      return NameOrErr.takeError();
  }
}

CXXRecordDecl *FromTemplated = D->getTemplatedDecl();

auto TemplateParamsOrErr = import(D->getTemplateParameters());
if (!TemplateParamsOrErr)
  return TemplateParamsOrErr.takeError();

// Create the declaration that is being templated.
CXXRecordDecl *ToTemplated;
if (Error Err = importInto(ToTemplated, FromTemplated))
  return std::move(Err);

// Create the class template declaration itself.
ClassTemplateDecl *D2;
if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
                            *TemplateParamsOrErr, ToTemplated))
  return D2;

ToTemplated->setDescribedClassTemplate(D2);

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

addDeclToContexts(D, D2);
updateLookupTableForTemplateParameters(**TemplateParamsOrErr);

if (FoundByLookup) {
  auto *Recent =
      const_cast<ClassTemplateDecl *>(FoundByLookup->getMostRecentDecl());

  // It is possible that during the import of the class template definition
  // we start the import of a fwd friend decl of the very same class template
  // and we add the fwd friend decl to the lookup table. But the ToTemplated
  // had been created earlier and by that time the lookup could not find
  // anything existing, so it has no previous decl. Later, (still during the
  // import of the fwd friend decl) we start to import the definition again
  // and this time the lookup finds the previous fwd friend class template.
  // In this case we must set up the previous decl for the templated decl.
  if (!ToTemplated->getPreviousDecl()) {
    assert(FoundByLookup->getTemplatedDecl() &&(static_cast <bool> (FoundByLookup->getTemplatedDecl
() && "Found decl must have its templated decl set") ?
 void (0) : __assert_fail ("FoundByLookup->getTemplatedDecl() && \"Found decl must have its templated decl set\""
, "clang/lib/AST/ASTImporter.cpp", 5840, __extension__ __PRETTY_FUNCTION__
))
           "Found decl must have its templated decl set")(static_cast <bool> (FoundByLookup->getTemplatedDecl
() && "Found decl must have its templated decl set") ?
 void (0) : __assert_fail ("FoundByLookup->getTemplatedDecl() && \"Found decl must have its templated decl set\""
, "clang/lib/AST/ASTImporter.cpp", 5840, __extension__ __PRETTY_FUNCTION__
));
    CXXRecordDecl *PrevTemplated =
        FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
    if (ToTemplated != PrevTemplated)
      ToTemplated->setPreviousDecl(PrevTemplated);
  }

  D2->setPreviousDecl(Recent);
}

return D2;
5851}

5853ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
                                        ClassTemplateSpecializationDecl *D) {
ClassTemplateDecl *ClassTemplate;
if (Error Err = importInto(ClassTemplate, D->getSpecializedTemplate()))
  return std::move(Err);

// Import the context of this declaration.
DeclContext *DC, *LexicalDC;
if (Error Err = ImportDeclContext(D, DC, LexicalDC))
  return std::move(Err);

// Import template arguments.
SmallVector<TemplateArgument, 2> TemplateArgs;
if (Error Err =
        ImportTemplateArguments(D->getTemplateArgs().asArray(), TemplateArgs))
  return std::move(Err);
// Try to find an existing specialization with these template arguments and
// template parameter list.
void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl = nullptr;
ClassTemplatePartialSpecializationDecl *PartialSpec =
          dyn_cast<ClassTemplatePartialSpecializationDecl>(D);

// Import template parameters.
TemplateParameterList *ToTPList = nullptr;

if (PartialSpec) {
  auto ToTPListOrErr = import(PartialSpec->getTemplateParameters());
  if (!ToTPListOrErr)
    return ToTPListOrErr.takeError();
  ToTPList = *ToTPListOrErr;
  PrevDecl = ClassTemplate->findPartialSpecialization(TemplateArgs,
                                                      *ToTPListOrErr,
                                                      InsertPos);
} else
  PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);

if (PrevDecl) {
  if (IsStructuralMatch(D, PrevDecl)) {
    CXXRecordDecl *PrevDefinition = PrevDecl->getDefinition();
    if (D->isThisDeclarationADefinition() && PrevDefinition) {
      Importer.MapImported(D, PrevDefinition);
      // Import those default field initializers which have been
      // instantiated in the "From" context, but not in the "To" context.
      for (auto *FromField : D->fields()) {
        auto ToOrErr = import(FromField);
        if (!ToOrErr)
          return ToOrErr.takeError();
      }

      // Import those methods which have been instantiated in the
      // "From" context, but not in the "To" context.
      for (CXXMethodDecl *FromM : D->methods()) {
        auto ToOrErr = import(FromM);
        if (!ToOrErr)
          return ToOrErr.takeError();
      }

      // TODO Import instantiated default arguments.
      // TODO Import instantiated exception specifications.
      //
      // Generally, ASTCommon.h/DeclUpdateKind enum gives a very good hint
      // what else could be fused during an AST merge.
      return PrevDefinition;
    }
  } else { // ODR violation.
    // FIXME HandleNameConflict
    return make_error<ASTImportError>(ASTImportError::NameConflict);
  }
}

// Import the location of this declaration.
ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
if (!BeginLocOrErr)
  return BeginLocOrErr.takeError();
ExpectedSLoc IdLocOrErr = import(D->getLocation());
if (!IdLocOrErr)
  return IdLocOrErr.takeError();

// Create the specialization.
ClassTemplateSpecializationDecl *D2 = nullptr;
if (PartialSpec) {
  // Import TemplateArgumentListInfo.
  TemplateArgumentListInfo ToTAInfo;
  const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
  if (Error Err = ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
    return std::move(Err);

  QualType CanonInjType;
  if (Error Err = importInto(
      CanonInjType, PartialSpec->getInjectedSpecializationType()))
    return std::move(Err);
  CanonInjType = CanonInjType.getCanonicalType();

  if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
          D2, D, Importer.getToContext(), D->getTagKind(), DC, *BeginLocOrErr,
          *IdLocOrErr, ToTPList, ClassTemplate,
          llvm::ArrayRef(TemplateArgs.data(), TemplateArgs.size()), ToTAInfo,
          CanonInjType,
          cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))
    return D2;

  // Update InsertPos, because preceding import calls may have invalidated
  // it by adding new specializations.
  auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(D2);
  if (!ClassTemplate->findPartialSpecialization(TemplateArgs, ToTPList,
                                                InsertPos))
    // Add this partial specialization to the class template.
    ClassTemplate->AddPartialSpecialization(PartSpec2, InsertPos);

  updateLookupTableForTemplateParameters(*ToTPList);
} else { // Not a partial specialization.
  if (GetImportedOrCreateDecl(
          D2, D, Importer.getToContext(), D->getTagKind(), DC,
          *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,
          PrevDecl))
    return D2;

  // Update InsertPos, because preceding import calls may have invalidated
  // it by adding new specializations.
  if (!ClassTemplate->findSpecialization(TemplateArgs, InsertPos))
    // Add this specialization to the class template.
    ClassTemplate->AddSpecialization(D2, InsertPos);
}

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

// 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 (auto BraceRangeOrErr = import(D->getBraceRange()))
  D2->setBraceRange(*BraceRangeOrErr);
else
  return BraceRangeOrErr.takeError();

// Import the qualifier, if any.
if (auto LocOrErr = import(D->getQualifierLoc()))
  D2->setQualifierInfo(*LocOrErr);
else
  return LocOrErr.takeError();

if (auto *TSI = D->getTypeAsWritten()) {
  if (auto TInfoOrErr = import(TSI))
    D2->setTypeAsWritten(*TInfoOrErr);
  else
    return TInfoOrErr.takeError();

  if (auto LocOrErr = import(D->getTemplateKeywordLoc()))
    D2->setTemplateKeywordLoc(*LocOrErr);
  else
    return LocOrErr.takeError();

  if (auto LocOrErr = import(D->getExternLoc()))
    D2->setExternLoc(*LocOrErr);
  else
    return LocOrErr.takeError();
}

if (D->getPointOfInstantiation().isValid()) {
  if (auto POIOrErr = import(D->getPointOfInstantiation()))
    D2->setPointOfInstantiation(*POIOrErr);
  else
    return POIOrErr.takeError();
}

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

if (auto P = D->getInstantiatedFrom()) {
  if (auto *CTD = P.dyn_cast<ClassTemplateDecl *>()) {
    if (auto CTDorErr = import(CTD))
      D2->setInstantiationOf(*CTDorErr);
  } else {
    auto *CTPSD = cast<ClassTemplatePartialSpecializationDecl *>(P);
    auto CTPSDOrErr = import(CTPSD);
    if (!CTPSDOrErr)
      return CTPSDOrErr.takeError();
    const TemplateArgumentList &DArgs = D->getTemplateInstantiationArgs();
    SmallVector<TemplateArgument, 2> D2ArgsVec(DArgs.size());
    for (unsigned I = 0; I < DArgs.size(); ++I) {
      const TemplateArgument &DArg = DArgs[I];
      if (auto ArgOrErr = import(DArg))
        D2ArgsVec[I] = *ArgOrErr;
      else
        return ArgOrErr.takeError();
    }
    D2->setInstantiationOf(
        *CTPSDOrErr,
        TemplateArgumentList::CreateCopy(Importer.getToContext(), D2ArgsVec));
  }
}

if (D->isCompleteDefinition())
  if (Error Err = ImportDefinition(D, D2))
    return std::move(Err);

return D2;
6054}

6056ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
// Import the major distinguishing characteristics of this variable template.
DeclContext *DC, *LexicalDC;
DeclarationName Name;
SourceLocation Loc;
NamedDecl *ToD;
if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
  return std::move(Err);
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\""
, "clang/lib/AST/ASTImporter.cpp", 6069, __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\""
, "clang/lib/AST/ASTImporter.cpp", 6069, __extension__ __PRETTY_FUNCTION__
));

SmallVector<NamedDecl *, 4> ConflictingDecls;
auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
VarTemplateDecl *FoundByLookup = nullptr;
for (auto *FoundDecl : FoundDecls) {
  if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
    continue;

  if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(FoundDecl)) {
    // Use the templated decl, some linkage flags are set only there.
    if (!hasSameVisibilityContextAndLinkage(FoundTemplate->getTemplatedDecl(),
                                            D->getTemplatedDecl()))
      continue;
    if (IsStructuralMatch(D, FoundTemplate)) {
      // The Decl in the "From" context has a definition, but in the
      // "To" context we already have a definition.
      VarTemplateDecl *FoundDef = getTemplateDefinition(FoundTemplate);
      if (D->isThisDeclarationADefinition() && FoundDef)
        // FIXME Check for ODR error if the two definitions have
        // different initializers?
        return Importer.MapImported(D, FoundDef);

      FoundByLookup = FoundTemplate;
      break;
    }
    ConflictingDecls.push_back(FoundDecl);
  }
}

if (!ConflictingDecls.empty()) {
  ExpectedName NameOrErr = Importer.HandleNameConflict(
      Name, DC, Decl::IDNS_Ordinary, ConflictingDecls.data(),
      ConflictingDecls.size());
  if (NameOrErr)
    Name = NameOrErr.get();
  else
    return NameOrErr.takeError();
}

VarDecl *DTemplated = D->getTemplatedDecl();

// Import the type.
// FIXME: Value not used?
ExpectedType TypeOrErr = import(DTemplated->getType());
if (!TypeOrErr)
  return TypeOrErr.takeError();

// Create the declaration that is being templated.
VarDecl *ToTemplated;
if (Error Err = importInto(ToTemplated, DTemplated))
  return std::move(Err);

// Create the variable template declaration itself.
auto TemplateParamsOrErr = import(D->getTemplateParameters());
if (!TemplateParamsOrErr)
  return TemplateParamsOrErr.takeError();

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

ToTemplated->setDescribedVarTemplate(ToVarTD);

ToVarTD->setAccess(D->getAccess());
ToVarTD->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToVarTD);
if (DC != Importer.getToContext().getTranslationUnitDecl())
  updateLookupTableForTemplateParameters(**TemplateParamsOrErr);

if (FoundByLookup) {
  auto *Recent =
      const_cast<VarTemplateDecl *>(FoundByLookup->getMostRecentDecl());
  if (!ToTemplated->getPreviousDecl()) {
    auto *PrevTemplated =
        FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
    if (ToTemplated != PrevTemplated)
      ToTemplated->setPreviousDecl(PrevTemplated);
  }
  ToVarTD->setPreviousDecl(Recent);
}

return ToVarTD;
6153}

6155ExpectedDecl 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) {
  if (ExpectedDecl ImportedDefOrErr = import(Definition))
    return Importer.MapImported(D, *ImportedDefOrErr);
  else
    return ImportedDefOrErr.takeError();
}

VarTemplateDecl *VarTemplate = nullptr;
if (Error Err = importInto(VarTemplate, D->getSpecializedTemplate()))
  return std::move(Err);

// Import the context of this declaration.
DeclContext *DC, *LexicalDC;
if (Error Err = ImportDeclContext(D, DC, LexicalDC))
  return std::move(Err);

// Import the location of this declaration.
ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
if (!BeginLocOrErr)
  return BeginLocOrErr.takeError();

auto IdLocOrErr = import(D->getLocation());
if (!IdLocOrErr)
  return IdLocOrErr.takeError();

// Import template arguments.
SmallVector<TemplateArgument, 2> TemplateArgs;
if (Error Err =
        ImportTemplateArguments(D->getTemplateArgs().asArray(), TemplateArgs))
  