/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp

Bug Summary

File:	clang/lib/AST/ASTImporter.cpp
Warning:	line 211, column 16 6th function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ASTImporter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-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 -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/AST -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D CLANG_ROUND_TRIP_CC1_ARGS=ON -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include -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-14/lib/clang/14.0.0/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 -O2 -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 -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/AST -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -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-2021-08-28-193554-24367-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp

/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/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/ASTImporterSharedState.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/ASTDiagnostic.h"
18#include "clang/AST/ASTStructuralEquivalence.h"
19#include "clang/AST/Attr.h"
20#include "clang/AST/Decl.h"
21#include "clang/AST/DeclAccessPair.h"
22#include "clang/AST/DeclBase.h"
23#include "clang/AST/DeclCXX.h"
24#include "clang/AST/DeclFriend.h"
25#include "clang/AST/DeclGroup.h"
26#include "clang/AST/DeclObjC.h"
27#include "clang/AST/DeclTemplate.h"
28#include "clang/AST/DeclVisitor.h"
29#include "clang/AST/DeclarationName.h"
30#include "clang/AST/Expr.h"
31#include "clang/AST/ExprCXX.h"
32#include "clang/AST/ExprObjC.h"
33#include "clang/AST/ExternalASTSource.h"
34#include "clang/AST/LambdaCapture.h"
35#include "clang/AST/NestedNameSpecifier.h"
36#include "clang/AST/OperationKinds.h"
37#include "clang/AST/Stmt.h"
38#include "clang/AST/StmtCXX.h"
39#include "clang/AST/StmtObjC.h"
40#include "clang/AST/StmtVisitor.h"
41#include "clang/AST/TemplateBase.h"
42#include "clang/AST/TemplateName.h"
43#include "clang/AST/Type.h"
44#include "clang/AST/TypeLoc.h"
45#include "clang/AST/TypeVisitor.h"
46#include "clang/AST/UnresolvedSet.h"
47#include "clang/Basic/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/None.h"
60#include "llvm/ADT/Optional.h"
61#include "llvm/ADT/ScopeExit.h"
62#include "llvm/ADT/STLExtras.h"
63#include "llvm/ADT/SmallVector.h"
64#include "llvm/Support/Casting.h"
65#include "llvm/Support/ErrorHandling.h"
66#include "llvm/Support/MemoryBuffer.h"
67#include <algorithm>
68#include <cassert>
69#include <cstddef>
70#include <memory>
71#include <type_traits>
72#include <utility>

74namespace clang {

using llvm::make_error;
using llvm::Error;
using llvm::Expected;
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 ImportError::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.", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 96);
  return "Invalid error code.";
}

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

std::error_code ImportError::convertToErrorCode() const {
  llvm_unreachable("Function not implemented.")::llvm::llvm_unreachable_internal("Function not implemented."
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 105);
}

char ImportError::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", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 130);
}

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

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

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

  // Use this to import pointers of specific type.
  template <typename ImportT>
  LLVM_NODISCARD[[clang::warn_unused_result]] Error importInto(ImportT *&To, ImportT *From) {
    auto ToOrErr = Importer.Import(From);
    if (ToOrErr)
29
←
Taking false branch→
      To = cast_or_null<ImportT>(*ToOrErr);
    return ToOrErr.takeError();
30
←
Returning without writing to 'To'→
  }

  // Call the import function of ASTImporter for a baseclass of type `T` and
  // cast the return value to `T`.
  template <typename T>
  Expected<T *> import(T *From) {
    auto ToOrErr = Importer.Import(From);
1
Calling 'ASTImporter::Import'→
    if (!ToOrErr)
      return ToOrErr.takeError();
    return cast_or_null<T>(*ToOrErr);
  }

  template <typename T>
  Expected<T *> 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);
  }

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

  // 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)
      return T{};
    Expected<T> MaybeVal = import(From);
    if (!MaybeVal) {
      Err = MaybeVal.takeError();
      return T{};
    }
    return *MaybeVal;
  }

  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)...);
54
←
Passing 'args' via 1st parameter '__t'→
55
←
Calling 'forward<clang::FunctionDecl *&>'→
57
←
Returning from 'forward<clang::FunctionDecl *&>'→
58
←
6th function call argument is an uninitialized value
    }
  };

  // Always use these functions to create a Decl during import. There are
  // certain tasks which must be done after the Decl was created, e.g. we
  // must immediately register that as an imported Decl.  The parameter `ToD`
  // will be set to the newly created Decl or if had been imported before
  // then to the already imported Decl.  Returns a bool value set to true if
  // the `FromD` had been imported before.
  template <typename ToDeclT, typename FromDeclT, typename... Args>
  LLVM_NODISCARD[[clang::warn_unused_result]] bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
                                              Args &&... args) {
    // There may be several overloads of ToDeclT::Create. We must make sure
    // to call the one which would be chosen by the arguments, thus we use a
    // wrapper for the overload set.
    CallOverloadedCreateFun<ToDeclT> OC;
    return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
43
←
Calling 'ASTNodeImporter::GetImportedOrCreateSpecialDecl'→
                                          std::forward<Args>(args)...);
38
←
Passing 'args' via 1st parameter '__t'→
39
←
Calling 'forward<clang::FunctionDecl *&>'→
41
←
Returning from 'forward<clang::FunctionDecl *&>'→
42
←
Passing value via 9th parameter 'args'→
  }
  // Use this overload if a special Type is needed to be created.  E.g if we
  // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
  // then:
  // TypedefNameDecl *ToTypedef;
  // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
  template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
            typename... Args>
  LLVM_NODISCARD[[clang::warn_unused_result]] bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
                                              Args &&... args) {
    CallOverloadedCreateFun<NewDeclT> OC;
    return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
                                          std::forward<Args>(args)...);
  }
  // Use this version if a special create function must be
  // used, e.g. CXXRecordDecl::CreateLambda .
  template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
            typename... Args>
  LLVM_NODISCARD[[clang::warn_unused_result]] bool
  GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
                                 FromDeclT *FromD, Args &&... args) {
    if (Importer.getImportDeclErrorIfAny(FromD)) {
44
←
Assuming the condition is false→
45
←
Taking false branch→
      ToD = nullptr;
      return true; // Already imported but with error.
    }
    ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
46
←
Assuming null pointer is passed into cast→
    if (ToD46.1
'ToD' is null
1
'ToD' is null
1
'ToD' is null
1
'ToD' is null
1
'ToD' is null
1
'ToD' is null
)
47
←
Taking false branch→
      return true; // Already imported.
    ToD = CreateFun(std::forward<Args>(args)...);
48
←
Passing 'args' via 1st parameter '__t'→
49
←
Calling 'forward<clang::FunctionDecl *&>'→
51
←
Returning from 'forward<clang::FunctionDecl *&>'→
52
←
Passing value via 6th parameter 'args'→
53
←
Calling 'CallOverloadedCreateFun::operator()'→
    // Keep track of imported Decls.
    Importer.RegisterImportedDecl(FromD, 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());
        for (NamedDecl *ND : FromLookup)
          if (ND == FromNamed) {
            ToDC->makeDeclVisibleInContext(ToNamed);
            break;
          }
      }
    }
  }

  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 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 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(
      const TemplateArgument *FromArgs, unsigned NumFromArgs,
      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);

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

  bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
  bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
                         bool Complain = true);
  bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
                         bool Complain = true);
  bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
  bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
  bool IsStructuralMatch(FunctionTemplateDecl *From,
                         FunctionTemplateDecl *To);
  bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
  bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
  bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
  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 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 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);

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

710template <typename InContainerTy>
711Error 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();
726}

728template <>
729Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
  const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
return ImportTemplateArgumentListInfo(
    From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
733}

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

744Expected<ASTNodeImporter::FunctionTemplateAndArgsTy>
745ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
  FunctionDecl *FromFD) {
assert(FromFD->getTemplatedKind() ==(static_cast <bool> (FromFD->getTemplatedKind() == FunctionDecl
::TK_FunctionTemplateSpecialization) ? void (0) : __assert_fail
 ("FromFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplateSpecialization"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 748, __extension__ __PRETTY_FUNCTION__))
    FunctionDecl::TK_FunctionTemplateSpecialization)(static_cast <bool> (FromFD->getTemplatedKind() == FunctionDecl
::TK_FunctionTemplateSpecialization) ? void (0) : __assert_fail
 ("FromFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplateSpecialization"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 748, __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.
auto TemplArgs = FTSInfo->TemplateArguments->asArray();
if (Error Err = ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
    std::get<1>(Result)))
  return std::move(Err);

return Result;
763}

765template <>
766Expected<TemplateParameterList *>
767ASTNodeImporter::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);
793}

795template <>
796Expected<TemplateArgument>
797ASTNodeImporter::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);
}

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

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

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

  return TemplateArgument(*ToTemplateOrErr);
}

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

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

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

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

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

llvm_unreachable("Invalid template argument kind")::llvm::llvm_unreachable_internal("Invalid template argument kind"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 869);
870}

872template <>
873Expected<TemplateArgumentLoc>
874ASTNodeImporter::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);
911}

913template <>
914Expected<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);
929}

931template <>
932Expected<ASTNodeImporter::Designator>
933ASTNodeImporter::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()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 964, __extension__ __PRETTY_FUNCTION__));
return Designator(
    D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
    *ToRBracketLocOrErr);
968}

970template <>
971Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
VarDecl *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);
992}

994template <typename T>
995bool 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();
1008}

1010template <>
1011bool 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();
1019}

1021} // namespace clang

1023//----------------------------------------------------------------------------
1024// Import Types
1025//----------------------------------------------------------------------------

1027using namespace clang;

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

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

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

1043ExpectedType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
switch (T->getKind()) {
1045#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id: \
  return Importer.getToContext().SingletonId;
1048#include "clang/Basic/OpenCLImageTypes.def"
1049#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id: \
  return Importer.getToContext().Id##Ty;
1052#include "clang/Basic/OpenCLExtensionTypes.def"
1053#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id: \
  return Importer.getToContext().SingletonId;
1056#include "clang/Basic/AArch64SVEACLETypes.def"
1057#define PPC_VECTOR_TYPE(Name, Id, Size) \
case BuiltinType::Id: \
  return Importer.getToContext().Id##Ty;
1060#include "clang/Basic/PPCTypes.def"
1061#define RVV_TYPE(Name, Id, SingletonId)                                        \
case BuiltinType::Id:                                                        \
  return Importer.getToContext().SingletonId;
1064#include "clang/Basic/RISCVVTypes.def"
1065#define SHARED_SINGLETON_TYPE(Expansion)
1066#define BUILTIN_TYPE(Id, SingletonId) \
case BuiltinType::Id: return Importer.getToContext().SingletonId;
1068#include "clang/AST/BuiltinTypes.def"

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

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

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

  return Importer.getToContext().CharTy;

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

  return Importer.getToContext().CharTy;

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

llvm_unreachable("Invalid BuiltinType Kind!")::llvm::llvm_unreachable_internal("Invalid BuiltinType Kind!"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 1101);
1102}

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

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

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

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

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

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

1128ExpectedType 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);
1135}

1137ExpectedType
1138ASTNodeImporter::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);
1145}

1147ExpectedType
1148ASTNodeImporter::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);
1155}

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

ExpectedType ClassTypeOrErr = import(QualType(T->getClass(), 0));
if (!ClassTypeOrErr)
  return ClassTypeOrErr.takeError();

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

1172ExpectedType
1173ASTNodeImporter::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());
1183}

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

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

1196ExpectedType
1197ASTNodeImporter::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);
1207}

1209ExpectedType 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);
1223}

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

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

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

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

1244ExpectedType
1245ASTNodeImporter::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());
1254}

1256ExpectedType
1257ASTNodeImporter::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);
1302}

1304ExpectedType 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));
1314}

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

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

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

return Importer.getToContext().getTypeDeclType(*ToDeclOrErr);
1330}

1332ExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
if (!ToExprOrErr)
  return ToExprOrErr.takeError();

return Importer.getToContext().getTypeOfExprType(*ToExprOrErr);
1338}

1340ExpectedType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
if (!ToUnderlyingTypeOrErr)
  return ToUnderlyingTypeOrErr.takeError();

return Importer.getToContext().getTypeOfType(*ToUnderlyingTypeOrErr);
1346}

1348ExpectedType 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);
1360}

1362ExpectedType
1363ASTNodeImporter::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());
1374}

1376ExpectedType 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;
ArrayRef<TemplateArgument> FromTemplateArgs = T->getTypeConstraintArguments();
if (Error Err = ImportTemplateArguments(FromTemplateArgs.data(),
                                        FromTemplateArgs.size(),
                                        ToTemplateArgs))
  return std::move(Err);

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

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

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

ExpectedType ToInjTypeOrErr = import(T->getInjectedSpecializationType());
if (!ToInjTypeOrErr)
  return ToInjTypeOrErr.takeError();

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

return QualType(new (Importer.getToContext(), TypeAlignment)
                InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0);
1433}

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

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

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

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

1451ExpectedType 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);
1461}

1463ExpectedType 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);
1471}

1473ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
  const SubstTemplateTypeParmType *T) {
ExpectedType ReplacedOrErr = import(QualType(T->getReplacedParameter(), 0));
if (!ReplacedOrErr)
  return ReplacedOrErr.takeError();
const TemplateTypeParmType *Replaced =
    cast<TemplateTypeParmType>((*ReplacedOrErr).getTypePtr());

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

return Importer.getToContext().getSubstTemplateTypeParmType(
      Replaced, (*ToReplacementTypeOrErr).getCanonicalType());
1487}

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

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

QualType ToCanonType;
if (!QualType(T, 0).isCanonical()) {
  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);
1512}

1514ExpectedType 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);
1532}

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

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

1545ExpectedType 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->getNumArgs());
if (Error Err = ImportTemplateArguments(
    T->getArgs(), T->getNumArgs(), ToPack))
  return std::move(Err);

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

1563ExpectedType
1564ASTNodeImporter::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);
1582}

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

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

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

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

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

1629//----------------------------------------------------------------------------
1630// Import Declarations
1631//----------------------------------------------------------------------------
1632Error 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<ImportError>(ImportError::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();
1681}

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

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

1734Error
1735ASTNodeImporter::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.", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 1772);
1773}

1775Error
1776ASTNodeImporter::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.
bool AccumulateChildErrors = isa<TagDecl>(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 defintion.
      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);

          if (Err && AccumulateChildErrors)
            ChildErrors =  joinErrors(std::move(ChildErrors), std::move(Err));
          else
            consumeError(std::move(Err));
        }
      }
    }
  } else {
    if (AccumulateChildErrors)
      ChildErrors =
          joinErrors(std::move(ChildErrors), ImportedOrErr.takeError());
    else
      consumeError(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\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 1886, __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)"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 1890, __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;
1902}

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

1923Error ASTNodeImporter::ImportImplicitMethods(
  const CXXRecordDecl *From, CXXRecordDecl *To) {
assert(From->isCompleteDefinition() && To->getDefinition() == To &&(static_cast <bool> (From->isCompleteDefinition() &&
 To->getDefinition() == To && "Import implicit methods to or from non-definition"
) ? void (0) : __assert_fail ("From->isCompleteDefinition() && To->getDefinition() == To && \"Import implicit methods to or from non-definition\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 1926, __extension__ __PRETTY_FUNCTION__))
    "Import implicit methods to or from non-definition")(static_cast <bool> (From->isCompleteDefinition() &&
 To->getDefinition() == To && "Import implicit methods to or from non-definition"
) ? void (0) : __assert_fail ("From->isCompleteDefinition() && To->getDefinition() == To && \"Import implicit methods to or from non-definition\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 1926, __extension__ __PRETTY_FUNCTION__));

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

return Error::success();
1936}

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

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

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

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

2123Error ASTNodeImporter::ImportTemplateArguments(
  const TemplateArgument *FromArgs, unsigned NumFromArgs,
  SmallVectorImpl<TemplateArgument> &ToArgs) {
for (unsigned I = 0; I != NumFromArgs; ++I) {
  if (auto ToOrErr = import(FromArgs[I]))
    ToArgs.push_back(*ToOrErr);
  else
    return ToOrErr.takeError();
}

return Error::success();
2134}

2136// FIXME: Do not forget to remove this and use only 'import'.
2137Expected<TemplateArgument>
2138ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
return import(From);
2140}

2142template <typename InContainerTy>
2143Error 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();
2152}

2154static StructuralEquivalenceKind
2155getStructuralEquivalenceKind(const ASTImporter &Importer) {
return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
                                  : StructuralEquivalenceKind::Default;
2158}

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

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

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

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

2196bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
// Eliminate a potential failure point where we attempt to re-import
// something we're trying to import while completing ToEnum.
if (Decl *ToOrigin = Importer.GetOriginalDecl(ToEnum))
  if (auto *ToOriginEnum = dyn_cast<EnumDecl>(ToOrigin))
      ToEnum = ToOriginEnum;

StructuralEquivalenceContext Ctx(
    Importer.getFromContext(), Importer.getToContext(),
    Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
return Ctx.IsEquivalent(FromEnum, ToEnum);
2207}

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

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

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

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

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

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

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

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

2266ExpectedDecl 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;
2284}

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

Importer.MapImported(D, ToD);

return ToD;
2293}

2295ExpectedDecl 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;
2322}

2324ExpectedDecl 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;
2349}

2351ExpectedDecl 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;
2375}

2377ExpectedDecl 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))
    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;
2458}

2460ExpectedDecl 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;
2494}

2496ExpectedDecl
2497ASTNodeImporter::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 "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;
2594}

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

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

2604ExpectedDecl
2605ASTNodeImporter::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;
2660}

2662ExpectedDecl 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()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 2673, __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;
2699}

2701ExpectedDecl 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;
2805}

2807ExpectedDecl 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\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 2885, __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->isDependentLambda(),
            DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
      return D2CXX;
    ExpectedDecl CDeclOrErr = import(DCXX->getLambdaContextDecl());
    if (!CDeclOrErr)
      return CDeclOrErr.takeError();
    D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), *CDeclOrErr,
                             DCXX->hasKnownLambdaInternalLinkage());
    D2CXX->setDeviceLambdaManglingNumber(
        DCXX->getDeviceLambdaManglingNumber());
 } 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).
      // FIXME: The previous type is cleared but not removed from
      // ASTContext's internal storage.
      CXXRecordDecl *Injected = nullptr;
      for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
        auto *Record = dyn_cast<CXXRecordDecl>(Found);
        if (Record && Record->isInjectedClassName()) {
          Injected = Record;
          break;
        }
      }
      // Create an injected type for the whole redecl chain.
      SmallVector<Decl *, 2> Redecls =
          getCanonicalForwardRedeclChain(D2CXX);
      for (auto *R : Redecls) {
        auto *RI = cast<CXXRecordDecl>(R);
        RI->setTypeForDecl(nullptr);
        // Below we create a new injected type and assign that to the
        // canonical decl, subsequent declarations in the chain will reuse
        // that type.
        Importer.getToContext().getInjectedClassNameType(
            RI, ToDescribed->getInjectedClassNameSpecialization());
      }
      // Set the new type for the previous injected decl too.
      if (Injected) {
        Injected->setTypeForDecl(nullptr);
        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;
3044}

3046ExpectedDecl 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;
3102}

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

3120Error ASTNodeImporter::ImportTemplateInformation(
  FunctionDecl *FromFD, FunctionDecl *ToFD) {
switch (FromFD->getTemplatedKind()) {
case FunctionDecl::TK_NonTemplate:
case FunctionDecl::TK_FunctionTemplate:
  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::makeArrayRef(
          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!"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3202);
3203}

3205Expected<FunctionDecl *>
3206ASTNodeImporter::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;
3218}

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

3231// Returns true if the given D has a DeclContext up to the TranslationUnitDecl
3232// which is equal to the given DC.
3233static bool isAncestorDeclContextOf(const DeclContext *DC, const Decl *D) {
const DeclContext *DCi = D->getDeclContext();
while (DCi != D->getTranslationUnitDecl()) {
  if (DCi == DC)
    return true;
  DCi = DCi->getParent();
}
return false;
3241}

3243bool ASTNodeImporter::hasAutoReturnTypeDeclaredInside(FunctionDecl *D) {
QualType FromTy = D->getType();
const FunctionProtoType *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\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3246, __extension__ __PRETTY_FUNCTION__));
if (AutoType *AutoT = FromFPT->getReturnType()->getContainedAutoType()) {
  QualType DeducedT = AutoT->getDeducedType();
  if (const RecordType *RecordT =
          DeducedT.isNull() ? nullptr : dyn_cast<RecordType>(DeducedT)) {
    RecordDecl *RD = RecordT->getDecl();
    assert(RD)(static_cast <bool> (RD) ? void (0) : __assert_fail ("RD"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3252, __extension__ __PRETTY_FUNCTION__));
    if (isAncestorDeclContextOf(D, RD)) {
      assert(RD->getLexicalDeclContext() == RD->getDeclContext())(static_cast <bool> (RD->getLexicalDeclContext() == RD
->getDeclContext()) ? void (0) : __assert_fail ("RD->getLexicalDeclContext() == RD->getDeclContext()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3254, __extension__ __PRETTY_FUNCTION__));
      return true;
    }
  }
}
if (const TypedefType *TypedefT =
        dyn_cast<TypedefType>(FromFPT->getReturnType())) {
  TypedefNameDecl *TD = TypedefT->getDecl();
  assert(TD)(static_cast <bool> (TD) ? void (0) : __assert_fail ("TD"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3262, __extension__ __PRETTY_FUNCTION__));
  if (isAncestorDeclContextOf(D, TD)) {
    assert(TD->getLexicalDeclContext() == TD->getDeclContext())(static_cast <bool> (TD->getLexicalDeclContext() == TD
->getDeclContext()) ? void (0) : __assert_fail ("TD->getLexicalDeclContext() == TD->getDeclContext()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3264, __extension__ __PRETTY_FUNCTION__));
    return true;
  }
}
return false;
3269}

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

3279ExpectedDecl 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", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3290, __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?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3383, __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?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3383, __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();
// 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.
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);
}

Error Err = Error::success();
auto T = importChecked(Err, FromTy);
auto TInfo = importChecked(Err, D->getTypeSourceInfo());
auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
auto ToEndLoc = importChecked(Err, D->getEndLoc());
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);
  if (GetImportedOrCreateDecl<CXXConstructorDecl>(
          ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
          ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->UsesFPIntrin(),
          D->isInlineSpecified(), D->isImplicit(), D->getConstexprKind(),
          InheritedConstructor(), // FIXME: Properly import inherited
                                  // constructor info
          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->setRangeEnd(ToEndLoc);

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

// FIXME: Other bits to merge?

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

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

3634ExpectedDecl ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
return VisitFunctionDecl(D);
3636}

3638ExpectedDecl ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
return VisitCXXMethodDecl(D);
3640}

3642ExpectedDecl ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
return VisitCXXMethodDecl(D);
3644}

3646ExpectedDecl ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
return VisitCXXMethodDecl(D);
3648}

3650ExpectedDecl
3651ASTNodeImporter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
return VisitFunctionDecl(D);
3653}

3655ExpectedDecl 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.
      if (Expr *FromInitializer = D->getInClassInitializer()) {
        // We don't have yet the initializer set.
        if (FoundField->hasInClassInitializer() &&
            !FoundField->getInClassInitializer()) {
          if (ExpectedExpr ToInitializerOrErr = import(FromInitializer))
            FoundField->setInClassInitializer(*ToInitializerOrErr);
          else {
            // We can't return error here,
            // since we already mapped D as imported.
            // FIXME: warning message?
            consumeError(ToInitializerOrErr.takeError());
            return FoundField;
          }
        }
      }
      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<ImportError>(ImportError::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;

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

3742ExpectedDecl 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<ImportError>(ImportError::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;
3810}

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

3820template <class T>
3821static FriendCountAndPosition getFriendCountAndPosition(
  const FriendDecl *FD,
  llvm::function_ref<T(const FriendDecl *)> GetCanTypeOrDecl) {
unsigned int FriendCount = 0;
llvm::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.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3840, __extension__ __PRETTY_FUNCTION__));

return {FriendCount, *FriendPosition};
3843}

3845static 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."
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3850);
  });
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."
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3856);
  });
3858}

3860ExpectedDecl 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?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3892, __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?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 3892, __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;
3943}

3945ExpectedDecl 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<ImportError>(ImportError::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;
3994}

3996ExpectedDecl 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", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 4007, __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;
4157}

4159ExpectedDecl 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;
4178}

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

4202ExpectedDecl 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;
4239}

4241ExpectedDecl 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<ImportError>(ImportError::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<ImportError>(ImportError::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<ImportError>(ImportError::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<ImportError>(ImportError::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;
4371}

4373ExpectedDecl 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;
4402}

4404ExpectedDecl 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;
4493}

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

4540ExpectedDecl 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;
4594}

4596ExpectedDecl 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;
4628}

4630ExpectedDecl 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;
4641}

4643ExpectedDecl 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);
4683}

4685ExpectedDecl 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 ToEnumDecl = importChecked(Err, D->getEnumDecl());
if (Err)
  return std::move(Err);

UsingEnumDecl *ToUsingEnum;
if (GetImportedOrCreateDecl(ToUsingEnum, D, Importer.getToContext(), DC,
                            ToUsingLoc, ToEnumLoc, Loc, ToEnumDecl))
  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);
4720}

4722ExpectedDecl 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 (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;
4762}

4764ExpectedDecl 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;
4801}

4803ExpectedDecl 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;
4837}

4839ExpectedDecl 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;
4869}

4871ExpectedDecl 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!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 4881, __extension__ __PRETTY_FUNCTION__));
Importer.MapImported(D, ToD);
return ToD;
4884}

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

4986Expected<ObjCTypeParamList *>
4987ASTNodeImporter::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);
5011}

5013ExpectedDecl 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;
5076}

5078ExpectedDecl
5079ASTNodeImporter::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;
5113}

5115ExpectedDecl
5116ASTNodeImporter::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<ImportError>(ImportError::NameConflict);
  }
}

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

return Impl;
5196}

5198ExpectedDecl 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<ImportError>(ImportError::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;
5276}

5278ExpectedDecl
5279ASTNodeImporter::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<ImportError>(ImportError::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<ImportError>(ImportError::NameConflict);
  }

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

return ToImpl;
5354}

5356ExpectedDecl
5357ASTNodeImporter::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;
5417}

5419ExpectedDecl
5420ASTNodeImporter::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;
5448}

5450ExpectedDecl
5451ASTNodeImporter::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;
5484}

5486// Returns the definition for a (forward) declaration of a TemplateDecl, if
5487// it has any definition in the redecl chain.
5488template <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\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 5489, __extension__ __PRETTY_FUNCTION__));
auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
if (!ToTemplatedDef)
  return nullptr;
auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate();
return cast_or_null<T>(TemplateWithDef);
5495}

5497ExpectedDecl 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\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 5591, __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\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 5591, __extension__ __PRETTY_FUNCTION__));
    CXXRecordDecl *PrevTemplated =
        FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
    if (ToTemplated != PrevTemplated)
      ToTemplated->setPreviousDecl(PrevTemplated);
  }

  D2->setPreviousDecl(Recent);
}

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

return D2;
5607}

5609ExpectedDecl 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().data(), D->getTemplateArgs().size(), 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<ImportError>(ImportError::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::makeArrayRef(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 (D->isCompleteDefinition())
  if (Error Err = ImportDefinition(D, D2))
    return std::move(Err);

return D2;
5786}

5788ExpectedDecl 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\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 5801, __extension__ __PRETTY_FUNCTION__))
       "Variable templates cannot be declared at function scope")(static_cast <bool> (!DC->isFunctionOrMethod() &&
 "Variable templates cannot be declared at function scope") ?
 void (0) : __assert_fail ("!DC->isFunctionOrMethod() && \"Variable templates cannot be declared at function scope\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 5801, __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);
}

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

return ToVarTD;
5890}

5892ExpectedDecl 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().data(), D->getTemplateArgs().size(), TemplateArgs))
  return std::move(Err);

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

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

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

  auto TInfoOrErr = import(D->getTypeSourceInfo());
  if (!TInfoOrErr)
    return TInfoOrErr.takeError();

  TemplateArgumentListInfo ToTAInfo;
  if (Error Err = ImportTemplateArgumentListInfo(
      D->getTemplateArgsInfo(), ToTAInfo))
    return std::move(Err);

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

    auto ToTPListOrErr = import(FromPartial->getTemplateParameters());
    if (!ToTPListOrErr)
      return ToTPListOrErr.takeError();

    PartVarSpecDecl *ToPartial;
    if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
                                *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
                                VarTemplate, T, *TInfoOrErr,
                                D->getStorageClass(), TemplateArgs, ArgInfos))
      return ToPartial;

    if (Expected<PartVarSpecDecl *> ToInstOrErr = import(
        FromPartial->getInstantiatedFromMember()))
      ToPartial->setInstantiatedFromMember(*ToInstOrErr);
    else
      return ToInstOrErr.takeError();

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

    D2 = ToPartial;

    // FIXME: Use this update if VarTemplatePartialSpecializationDecl is fixed
    // to adopt template parameters.
    // updateLookupTableForTemplateParameters(**ToTPListOrErr);
  } else { // Full specialization
    if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC,
                                *BeginLocOrErr, *IdLocOrErr, VarTemplate,
                                T, *TInfoOrErr,
                                D->getStorageClass(), TemplateArgs))
      return D2;
  }

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

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

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

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

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

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

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

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

return D2;
6040}

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

if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
11
←
Assuming the condition is false→
12
←
Taking false branch→
  return std::move(Err);

if (ToD)
13
←
Assuming 'ToD' is null→
14
←
Taking false branch→
  return ToD;

const FunctionTemplateDecl *FoundByLookup = nullptr;

// 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.
// FIXME Split this into a separate function.
if (!LexicalDC->isFunctionOrMethod()) {
15
←
Calling 'DeclContext::isFunctionOrMethod'→
19
←
Returning from 'DeclContext::isFunctionOrMethod'→
20
←
Taking true branch→
  unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
  for (auto *FoundDecl : FoundDecls) {
21
←
Assuming '__begin2' is equal to '__end2'→
    if (!FoundDecl->isInIdentifierNamespace(IDNS))
      continue;

    if (auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
      if (!hasSameVisibilityContextAndLinkage(FoundTemplate, D))
        continue;
      if (IsStructuralMatch(D, FoundTemplate)) {
        FunctionTemplateDecl *TemplateWithDef =
            getTemplateDefinition(FoundTemplate);
        if (D->isThisDeclarationADefinition() && TemplateWithDef)
          return Importer.MapImported(D, TemplateWithDef);

        FoundByLookup = FoundTemplate;
        break;
        // TODO: handle conflicting names
      }
    }
  }
}

auto ParamsOrErr = import(D->getTemplateParameters());
if (!ParamsOrErr)
22
←
Calling 'Expected::operator bool'→
25
←
Returning from 'Expected::operator bool'→
26
←
Taking false branch→
  return ParamsOrErr.takeError();
TemplateParameterList *Params = *ParamsOrErr;

FunctionDecl *TemplatedFD;
27
←
'TemplatedFD' declared without an initial value→
if (Error Err = importInto(TemplatedFD, D->getTemplatedDecl()))
28
←
Calling 'ASTNodeImporter::importInto'→
31
←
Returning from 'ASTNodeImporter::importInto'→
32
←
Assuming the condition is false→
33
←
Taking false branch→
  return std::move(Err);

// Template parameters of the ClassTemplateDecl and FunctionTemplateDecl are
// shared, if the FunctionTemplateDecl is a deduction guide for the class.
// At import the ClassTemplateDecl object is always created first (FIXME: is
// this really true?) because the dependency, then the FunctionTemplateDecl.
// The DeclContext of the template parameters is changed when the
// FunctionTemplateDecl is created, but was set already when the class
// template was created. So here it is not the TU (default value) any more.
// FIXME: The DeclContext of the parameters is now set finally to the
// CXXDeductionGuideDecl object that was imported later. This may not be the
// same that is in the original AST, specially if there are multiple deduction
// guides.
DeclContext *OldParamDC = nullptr;
if (Params->size() > 0)
34
←
Assuming the condition is false→
35
←
Taking false branch→
  OldParamDC = Params->getParam(0)->getDeclContext();

FunctionTemplateDecl *ToFunc;
if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
37
←
Calling 'ASTNodeImporter::GetImportedOrCreateDecl'→
                            Params, TemplatedFD))
36
←
Passing value via 8th parameter 'args'→
  return ToFunc;

TemplatedFD->setDescribedFunctionTemplate(ToFunc);

ToFunc->setAccess(D->getAccess());
ToFunc->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(ToFunc);
updateLookupTableForTemplateParameters(*Params, OldParamDC);

if (FoundByLookup) {
  auto *Recent =
      const_cast<FunctionTemplateDecl *>(FoundByLookup->getMostRecentDecl());
  if (!TemplatedFD->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\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 6125, __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\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 6125, __extension__ __PRETTY_FUNCTION__));
    auto *PrevTemplated =
        FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
    if (TemplatedFD != PrevTemplated)
      TemplatedFD->setPreviousDecl(PrevTemplated);
  }
  ToFunc->setPreviousDecl(Recent);
}

return ToFunc;
6135}

6137//----------------------------------------------------------------------------
6138// Import Statements
6139//----------------------------------------------------------------------------

6141ExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) {
Importer.FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
    << S->getStmtClassName();
return make_error<ImportError>(ImportError::UnsupportedConstruct);
6145}


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

for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
  IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
  // ToII is nullptr when no symbolic name is given for input operand
  // see ParseStmtAsm::ParseAsmOperandsOpt
  Names.push_back(ToII);
}

SmallVector<StringLiteral *, 4> Clobbers;
for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
  if (auto ClobberOrErr = import(S->getClobberStringLiteral(I)))
    Clobbers.push_back(*ClobberOrErr);
  else
    return ClobberOrErr.takeError();

}

SmallVector<StringLiteral *, 4> Constraints;
for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
  if (auto OutputOrErr = import(S->getOutputConstraintLiteral(I)))
    Constraints.push_back(*OutputOrErr);
  else
    return OutputOrErr.takeError();
}

for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
  if (auto InputOrErr = import(S->getInputConstraintLiteral(I)))
    Constraints.push_back(*InputOrErr);
  else
    return InputOrErr.takeError();
}

SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() +
                             S->getNumLabels());
if (Error Err = ImportContainerChecked(S->outputs(), Exprs))
  return std::move(Err);

if (Error Err =
        ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
  return std::move(Err);

if (Error Err = ImportArrayChecked(
        S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
  return std::move(Err);

ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc());
if (!AsmLocOrErr)
  return AsmLocOrErr.takeError();
auto AsmStrOrErr = import(S->getAsmString());
if (!AsmStrOrErr)
  return AsmStrOrErr.takeError();
ExpectedSLoc RParenLocOrErr = import(S->getRParenLoc());
if (!RParenLocOrErr)
  return RParenLocOrErr.takeError();

return new (Importer.getToContext()) GCCAsmStmt(
    Importer.getToContext(),
    *AsmLocOrErr,
    S->isSimple(),
    S->isVolatile(),
    S->getNumOutputs(),
    S->getNumInputs(),
    Names.data(),
    Constraints.data(),
    Exprs.data(),
    *AsmStrOrErr,
    S->getNumClobbers(),
    Clobbers.data(),
    S->getNumLabels(),
    *RParenLocOrErr);
6228}

6230ExpectedStmt ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {

Error Err = Error::success();
auto ToDG = importChecked(Err, S->getDeclGroup());
auto ToBeginLoc = importChecked(Err, S->getBeginLoc());
auto ToEndLoc = importChecked(Err, S->getEndLoc());
if (Err)
  return std::move(Err);
return new (Importer.getToContext()) DeclStmt(ToDG, ToBeginLoc, ToEndLoc);
6239}

6241ExpectedStmt ASTNodeImporter::VisitNullStmt(NullStmt *S) {
ExpectedSLoc ToSemiLocOrErr = import(S->getSemiLoc());
if (!ToSemiLocOrErr)
  return ToSemiLocOrErr.takeError();
return new (Importer.getToContext()) NullStmt(
    *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
6247}

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

if (Error Err = ImportContainerChecked(S->body(), ToStmts))
  return std::move(Err);

ExpectedSLoc ToLBracLocOrErr = import(S->getLBracLoc());
if (!ToLBracLocOrErr)
  return ToLBracLocOrErr.takeError();

ExpectedSLoc ToRBracLocOrErr = import(S->getRBracLoc());
if (!ToRBracLocOrErr)
  return ToRBracLocOrErr.takeError();

return CompoundStmt::Create(
    Importer.getToContext(), ToStmts,
    *ToLBracLocOrErr, *ToRBracLocOrErr);
6266}

6268ExpectedStmt ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {

Error Err = Error::success();
auto ToLHS = importChecked(Err, S->getLHS());
auto ToRHS = importChecked(Err, S->getRHS());
auto ToSubStmt = importChecked(Err, S->getSubStmt());
auto ToCaseLoc = importChecked(Err, S->getCaseLoc());
auto ToEllipsisLoc = importChecked(Err, S->getEllipsisLoc());
auto ToColonLoc = importChecked(Err, S->getColonLoc());
if (Err)
  return std::move(Err);

auto *ToStmt = CaseStmt::Create(Importer.getToContext(), ToLHS, ToRHS,
                                ToCaseLoc, ToEllipsisLoc, ToColonLoc);
ToStmt->setSubStmt(ToSubStmt);

return ToStmt;
6285}

6287ExpectedStmt ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {

Error Err = Error::success();
auto ToDefaultLoc = importChecked(Err, S->getDefaultLoc());
auto ToColonLoc = importChecked(Err, S->getColonLoc());
auto ToSubStmt = importChecked(Err, S->getSubStmt());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) DefaultStmt(
  ToDefaultLoc, ToColonLoc, ToSubStmt);
6298}

6300ExpectedStmt ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {

Error Err = Error::success();
auto ToIdentLoc = importChecked(Err, S->getIdentLoc());
auto ToLabelDecl = importChecked(Err, S->getDecl());
auto ToSubStmt = importChecked(Err, S->getSubStmt());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) LabelStmt(
    ToIdentLoc, ToLabelDecl, ToSubStmt);
6311}

6313ExpectedStmt ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc());
if (!ToAttrLocOrErr)
  return ToAttrLocOrErr.takeError();
ArrayRef<const Attr*> FromAttrs(S->getAttrs());
SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
if (Error Err = ImportContainerChecked(FromAttrs, ToAttrs))
  return std::move(Err);
ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
if (!ToSubStmtOrErr)
  return ToSubStmtOrErr.takeError();

return AttributedStmt::Create(
    Importer.getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
6327}

6329ExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) {

Error Err = Error::success();
auto ToIfLoc = importChecked(Err, S->getIfLoc());
auto ToInit = importChecked(Err, S->getInit());
auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
auto ToCond = importChecked(Err, S->getCond());
auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
auto ToThen = importChecked(Err, S->getThen());
auto ToElseLoc = importChecked(Err, S->getElseLoc());
auto ToElse = importChecked(Err, S->getElse());
if (Err)
  return std::move(Err);

return IfStmt::Create(Importer.getToContext(), ToIfLoc, S->isConstexpr(),
                      ToInit, ToConditionVariable, ToCond, ToLParenLoc,
                      ToRParenLoc, ToThen, ToElseLoc, ToElse);
6347}

6349ExpectedStmt ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {

Error Err = Error::success();
auto ToInit = importChecked(Err, S->getInit());
auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
auto ToCond = importChecked(Err, S->getCond());
auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
auto ToBody = importChecked(Err, S->getBody());
auto ToSwitchLoc = importChecked(Err, S->getSwitchLoc());
if (Err)
  return std::move(Err);

auto *ToStmt =
    SwitchStmt::Create(Importer.getToContext(), ToInit, ToConditionVariable,
                       ToCond, ToLParenLoc, ToRParenLoc);
ToStmt->setBody(ToBody);
ToStmt->setSwitchLoc(ToSwitchLoc);

// Now we have to re-chain the cases.
SwitchCase *LastChainedSwitchCase = nullptr;
for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
     SC = SC->getNextSwitchCase()) {
  Expected<SwitchCase *> ToSCOrErr = import(SC);
  if (!ToSCOrErr)
    return ToSCOrErr.takeError();
  if (LastChainedSwitchCase)
    LastChainedSwitchCase->setNextSwitchCase(*ToSCOrErr);
  else
    ToStmt->setSwitchCaseList(*ToSCOrErr);
  LastChainedSwitchCase = *ToSCOrErr;
}

return ToStmt;
6383}

6385ExpectedStmt ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {

Error Err = Error::success();
auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
auto ToCond = importChecked(Err, S->getCond());
auto ToBody = importChecked(Err, S->getBody());
auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
if (Err)
  return std::move(Err);

return WhileStmt::Create(Importer.getToContext(), ToConditionVariable, ToCond,
                         ToBody, ToWhileLoc, ToLParenLoc, ToRParenLoc);
6399}

6401ExpectedStmt ASTNodeImporter::VisitDoStmt(DoStmt *S) {

Error Err = Error::success();
auto ToBody = importChecked(Err, S->getBody());
auto ToCond = importChecked(Err, S->getCond());
auto ToDoLoc = importChecked(Err, S->getDoLoc());
auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) DoStmt(
    ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
6414}

6416ExpectedStmt ASTNodeImporter::VisitForStmt(ForStmt *S) {

Error Err = Error::success();
auto ToInit = importChecked(Err, S->getInit());
auto ToCond = importChecked(Err, S->getCond());
auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
auto ToInc = importChecked(Err, S->getInc());
auto ToBody = importChecked(Err, S->getBody());
auto ToForLoc = importChecked(Err, S->getForLoc());
auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) ForStmt(
    Importer.getToContext(),
    ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
    ToRParenLoc);
6434}

6436ExpectedStmt ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {

Error Err = Error::success();
auto ToLabel = importChecked(Err, S->getLabel());
auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
auto ToLabelLoc = importChecked(Err, S->getLabelLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) GotoStmt(
    ToLabel, ToGotoLoc, ToLabelLoc);
6447}

6449ExpectedStmt ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {

Error Err = Error::success();
auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
auto ToStarLoc = importChecked(Err, S->getStarLoc());
auto ToTarget = importChecked(Err, S->getTarget());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) IndirectGotoStmt(
    ToGotoLoc, ToStarLoc, ToTarget);
6460}

6462ExpectedStmt ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
ExpectedSLoc ToContinueLocOrErr = import(S->getContinueLoc());
if (!ToContinueLocOrErr)
  return ToContinueLocOrErr.takeError();
return new (Importer.getToContext()) ContinueStmt(*ToContinueLocOrErr);
6467}

6469ExpectedStmt ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
auto ToBreakLocOrErr = import(S->getBreakLoc());
if (!ToBreakLocOrErr)
  return ToBreakLocOrErr.takeError();
return new (Importer.getToContext()) BreakStmt(*ToBreakLocOrErr);
6474}

6476ExpectedStmt ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {

Error Err = Error::success();
auto ToReturnLoc = importChecked(Err, S->getReturnLoc());
auto ToRetValue = importChecked(Err, S->getRetValue());
auto ToNRVOCandidate = importChecked(Err, S->getNRVOCandidate());
if (Err)
  return std::move(Err);

return ReturnStmt::Create(Importer.getToContext(), ToReturnLoc, ToRetValue,
                          ToNRVOCandidate);
6487}

6489ExpectedStmt ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {

Error Err = Error::success();
auto ToCatchLoc = importChecked(Err, S->getCatchLoc());
auto ToExceptionDecl = importChecked(Err, S->getExceptionDecl());
auto ToHandlerBlock = importChecked(Err, S->getHandlerBlock());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) CXXCatchStmt (
    ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
6500}

6502ExpectedStmt ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
ExpectedSLoc ToTryLocOrErr = import(S->getTryLoc());
if (!ToTryLocOrErr)
  return ToTryLocOrErr.takeError();

ExpectedStmt ToTryBlockOrErr = import(S->getTryBlock());
if (!ToTryBlockOrErr)
  return ToTryBlockOrErr.takeError();

SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
  CXXCatchStmt *FromHandler = S->getHandler(HI);
  if (auto ToHandlerOrErr = import(FromHandler))
    ToHandlers[HI] = *ToHandlerOrErr;
  else
    return ToHandlerOrErr.takeError();
}

return CXXTryStmt::Create(
    Importer.getToContext(), *ToTryLocOrErr,*ToTryBlockOrErr, ToHandlers);
6522}

6524ExpectedStmt ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {

Error Err = Error::success();
auto ToInit = importChecked(Err, S->getInit());
auto ToRangeStmt = importChecked(Err, S->getRangeStmt());
auto ToBeginStmt = importChecked(Err, S->getBeginStmt());
auto ToEndStmt = importChecked(Err, S->getEndStmt());
auto ToCond = importChecked(Err, S->getCond());
auto ToInc = importChecked(Err, S->getInc());
auto ToLoopVarStmt = importChecked(Err, S->getLoopVarStmt());
auto ToBody = importChecked(Err, S->getBody());
auto ToForLoc = importChecked(Err, S->getForLoc());
auto ToCoawaitLoc = importChecked(Err, S->getCoawaitLoc());
auto ToColonLoc = importChecked(Err, S->getColonLoc());
auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) CXXForRangeStmt(
    ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt,
    ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc);
6545}

6547ExpectedStmt
6548ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
Error Err = Error::success();
auto ToElement = importChecked(Err, S->getElement());
auto ToCollection = importChecked(Err, S->getCollection());
auto ToBody = importChecked(Err, S->getBody());
auto ToForLoc = importChecked(Err, S->getForLoc());
auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) ObjCForCollectionStmt(ToElement,
                                                           ToCollection,
                                                           ToBody,
                                                           ToForLoc,
                                                           ToRParenLoc);
6563}

6565ExpectedStmt ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {

Error Err = Error::success();
auto ToAtCatchLoc = importChecked(Err, S->getAtCatchLoc());
auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
auto ToCatchParamDecl = importChecked(Err, S->getCatchParamDecl());
auto ToCatchBody = importChecked(Err, S->getCatchBody());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) ObjCAtCatchStmt (
    ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
6577}

6579ExpectedStmt ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
ExpectedSLoc ToAtFinallyLocOrErr = import(S->getAtFinallyLoc());
if (!ToAtFinallyLocOrErr)
  return ToAtFinallyLocOrErr.takeError();
ExpectedStmt ToAtFinallyStmtOrErr = import(S->getFinallyBody());
if (!ToAtFinallyStmtOrErr)
  return ToAtFinallyStmtOrErr.takeError();
return new (Importer.getToContext()) ObjCAtFinallyStmt(*ToAtFinallyLocOrErr,
                                                       *ToAtFinallyStmtOrErr);
6588}

6590ExpectedStmt ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {

Error Err = Error::success();
auto ToAtTryLoc = importChecked(Err, S->getAtTryLoc());
auto ToTryBody = importChecked(Err, S->getTryBody());
auto ToFinallyStmt = importChecked(Err, S->getFinallyStmt());
if (Err)
  return std::move(Err);

SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
  ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
  if (ExpectedStmt ToCatchStmtOrErr = import(FromCatchStmt))
    ToCatchStmts[CI] = *ToCatchStmtOrErr;
  else
    return ToCatchStmtOrErr.takeError();
}

return ObjCAtTryStmt::Create(Importer.getToContext(),
                             ToAtTryLoc, ToTryBody,
                             ToCatchStmts.begin(), ToCatchStmts.size(),
                             ToFinallyStmt);
6612}

6614ExpectedStmt
6615ASTNodeImporter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {

Error Err = Error::success();
auto ToAtSynchronizedLoc = importChecked(Err, S->getAtSynchronizedLoc());
auto ToSynchExpr = importChecked(Err, S->getSynchExpr());
auto ToSynchBody = importChecked(Err, S->getSynchBody());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
  ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
6626}

6628ExpectedStmt ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
ExpectedSLoc ToThrowLocOrErr = import(S->getThrowLoc());
if (!ToThrowLocOrErr)
  return ToThrowLocOrErr.takeError();
ExpectedExpr ToThrowExprOrErr = import(S->getThrowExpr());
if (!ToThrowExprOrErr)
  return ToThrowExprOrErr.takeError();
return new (Importer.getToContext()) ObjCAtThrowStmt(
    *ToThrowLocOrErr, *ToThrowExprOrErr);
6637}

6639ExpectedStmt ASTNodeImporter::VisitObjCAutoreleasePoolStmt(
  ObjCAutoreleasePoolStmt *S) {
ExpectedSLoc ToAtLocOrErr = import(S->getAtLoc());
if (!ToAtLocOrErr)
  return ToAtLocOrErr.takeError();
ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
if (!ToSubStmtOrErr)
  return ToSubStmtOrErr.takeError();
return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(*ToAtLocOrErr,
                                                             *ToSubStmtOrErr);
6649}

6651//----------------------------------------------------------------------------
6652// Import Expressions
6653//----------------------------------------------------------------------------
6654ExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) {
Importer.FromDiag(E->getBeginLoc(), diag::err_unsupported_ast_node)
    << E->getStmtClassName();
return make_error<ImportError>(ImportError::UnsupportedConstruct);
6658}

6660ExpectedStmt ASTNodeImporter::VisitSourceLocExpr(SourceLocExpr *E) {
Error Err = Error::success();
auto BLoc = importChecked(Err, E->getBeginLoc());
auto RParenLoc = importChecked(Err, E->getEndLoc());
if (Err)
  return std::move(Err);
auto ParentContextOrErr = Importer.ImportContext(E->getParentContext());
if (!ParentContextOrErr)
  return ParentContextOrErr.takeError();

return new (Importer.getToContext())
    SourceLocExpr(Importer.getToContext(), E->getIdentKind(), BLoc, RParenLoc,
                  *ParentContextOrErr);
6673}

6675ExpectedStmt ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {

Error Err = Error::success();
auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
auto ToSubExpr = importChecked(Err, E->getSubExpr());
auto ToWrittenTypeInfo = importChecked(Err, E->getWrittenTypeInfo());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
auto ToType = importChecked(Err, E->getType());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) VAArgExpr(
    ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
    E->isMicrosoftABI());
6689}

6691ExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) {

Error Err = Error::success();
auto ToCond = importChecked(Err, E->getCond());
auto ToLHS = importChecked(Err, E->getLHS());
auto ToRHS = importChecked(Err, E->getRHS());
auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
auto ToType = importChecked(Err, E->getType());
if (Err)
  return std::move(Err);

ExprValueKind VK = E->getValueKind();
ExprObjectKind OK = E->getObjectKind();

// The value of CondIsTrue only matters if the value is not
// condition-dependent.
bool CondIsTrue = !E->isConditionDependent() && E->isConditionTrue();

return new (Importer.getToContext())
    ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK,
               ToRParenLoc, CondIsTrue);
6713}

6715ExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
ExpectedType TypeOrErr = import(E->getType());
if (!TypeOrErr)
  return TypeOrErr.takeError();

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

return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr);
6725}

6727ExpectedStmt
6728ASTNodeImporter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
Error Err = Error::success();
auto ToGenericLoc = importChecked(Err, E->getGenericLoc());
auto *ToControllingExpr = importChecked(Err, E->getControllingExpr());
auto ToDefaultLoc = importChecked(Err, E->getDefaultLoc());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
if (Err)
  return std::move(Err);

ArrayRef<const TypeSourceInfo *> FromAssocTypes(E->getAssocTypeSourceInfos());
SmallVector<TypeSourceInfo *, 1> ToAssocTypes(FromAssocTypes.size());
if (Error Err = ImportContainerChecked(FromAssocTypes, ToAssocTypes))
  return std::move(Err);

ArrayRef<const Expr *> FromAssocExprs(E->getAssocExprs());
SmallVector<Expr *, 1> ToAssocExprs(FromAssocExprs.size());
if (Error Err = ImportContainerChecked(FromAssocExprs, ToAssocExprs))
  return std::move(Err);

const ASTContext &ToCtx = Importer.getToContext();
if (E->isResultDependent()) {
  return GenericSelectionExpr::Create(
      ToCtx, ToGenericLoc, ToControllingExpr,
      llvm::makeArrayRef(ToAssocTypes), llvm::makeArrayRef(ToAssocExprs),
      ToDefaultLoc, ToRParenLoc, E->containsUnexpandedParameterPack());
}

return GenericSelectionExpr::Create(
    ToCtx, ToGenericLoc, ToControllingExpr, llvm::makeArrayRef(ToAssocTypes),
    llvm::makeArrayRef(ToAssocExprs), ToDefaultLoc, ToRParenLoc,
    E->containsUnexpandedParameterPack(), E->getResultIndex());
6759}

6761ExpectedStmt ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {

Error Err = Error::success();
auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
auto ToType = importChecked(Err, E->getType());
auto ToFunctionName = importChecked(Err, E->getFunctionName());
if (Err)
  return std::move(Err);

return PredefinedExpr::Create(Importer.getToContext(), ToBeginLoc, ToType,
                              E->getIdentKind(), ToFunctionName);
6772}

6774ExpectedStmt ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {

Error Err = Error::success();
auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
auto ToDecl = importChecked(Err, E->getDecl());
auto ToLocation = importChecked(Err, E->getLocation());
auto ToType = importChecked(Err, E->getType());
if (Err)
  return std::move(Err);

NamedDecl *ToFoundD = nullptr;
if (E->getDecl() != E->getFoundDecl()) {
  auto FoundDOrErr = import(E->getFoundDecl());
  if (!FoundDOrErr)
    return FoundDOrErr.takeError();
  ToFoundD = *FoundDOrErr;
}

TemplateArgumentListInfo ToTAInfo;
TemplateArgumentListInfo *ToResInfo = nullptr;
if (E->hasExplicitTemplateArgs()) {
  if (Error Err =
          ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
                                         E->template_arguments(), ToTAInfo))
    return std::move(Err);
  ToResInfo = &ToTAInfo;
}

auto *ToE = DeclRefExpr::Create(
    Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl,
    E->refersToEnclosingVariableOrCapture(), ToLocation, ToType,
    E->getValueKind(), ToFoundD, ToResInfo, E->isNonOdrUse());
if (E->hadMultipleCandidates())
  ToE->setHadMultipleCandidates(true);
return ToE;
6810}

6812ExpectedStmt ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
ExpectedType TypeOrErr = import(E->getType());
if (!TypeOrErr)
  return TypeOrErr.takeError();

return new (Importer.getToContext()) ImplicitValueInitExpr(*TypeOrErr);
6818}

6820ExpectedStmt ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
ExpectedExpr ToInitOrErr = import(E->getInit());
if (!ToInitOrErr)
  return ToInitOrErr.takeError();

ExpectedSLoc ToEqualOrColonLocOrErr = import(E->getEqualOrColonLoc());
if (!ToEqualOrColonLocOrErr)
  return ToEqualOrColonLocOrErr.takeError();

SmallVector<Expr *, 4> ToIndexExprs(E->getNumSubExprs() - 1);
// List elements from the second, the first is Init itself
for (unsigned I = 1, N = E->getNumSubExprs(); I < N; I++) {
  if (ExpectedExpr ToArgOrErr = import(E->getSubExpr(I)))
    ToIndexExprs[I - 1] = *ToArgOrErr;
  else
    return ToArgOrErr.takeError();
}

SmallVector<Designator, 4> ToDesignators(E->size());
if (Error Err = ImportContainerChecked(E->designators(), ToDesignators))
  return std::move(Err);

return DesignatedInitExpr::Create(
      Importer.getToContext(), ToDesignators,
      ToIndexExprs, *ToEqualOrColonLocOrErr,
      E->usesGNUSyntax(), *ToInitOrErr);
6846}

6848ExpectedStmt
6849ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedSLoc ToLocationOrErr = import(E->getLocation());
if (!ToLocationOrErr)
  return ToLocationOrErr.takeError();

return new (Importer.getToContext()) CXXNullPtrLiteralExpr(
    *ToTypeOrErr, *ToLocationOrErr);
6860}

6862ExpectedStmt ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedSLoc ToLocationOrErr = import(E->getLocation());
if (!ToLocationOrErr)
  return ToLocationOrErr.takeError();

return IntegerLiteral::Create(
    Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
6873}


6876ExpectedStmt ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedSLoc ToLocationOrErr = import(E->getLocation());
if (!ToLocationOrErr)
  return ToLocationOrErr.takeError();

return FloatingLiteral::Create(
    Importer.getToContext(), E->getValue(), E->isExact(),
    *ToTypeOrErr, *ToLocationOrErr);
6888}

6890ExpectedStmt ASTNodeImporter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
auto ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
if (!ToSubExprOrErr)
  return ToSubExprOrErr.takeError();

return new (Importer.getToContext()) ImaginaryLiteral(
    *ToSubExprOrErr, *ToTypeOrErr);
6901}

6903ExpectedStmt ASTNodeImporter::VisitFixedPointLiteral(FixedPointLiteral *E) {
auto ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedSLoc ToLocationOrErr = import(E->getLocation());
if (!ToLocationOrErr)
  return ToLocationOrErr.takeError();

return new (Importer.getToContext()) FixedPointLiteral(
    Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr,
    Importer.getToContext().getFixedPointScale(*ToTypeOrErr));
6915}

6917ExpectedStmt ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedSLoc ToLocationOrErr = import(E->getLocation());
if (!ToLocationOrErr)
  return ToLocationOrErr.takeError();

return new (Importer.getToContext()) CharacterLiteral(
    E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
6928}

6930ExpectedStmt ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated());
if (Error Err = ImportArrayChecked(
    E->tokloc_begin(), E->tokloc_end(), ToLocations.begin()))
  return std::move(Err);

return StringLiteral::Create(
    Importer.getToContext(), E->getBytes(), E->getKind(), E->isPascal(),
    *ToTypeOrErr, ToLocations.data(), ToLocations.size());
6943}

6945ExpectedStmt ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {

Error Err = Error::success();
auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
auto ToType = importChecked(Err, E->getType());
auto ToInitializer = importChecked(Err, E->getInitializer());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) CompoundLiteralExpr(
      ToLParenLoc, ToTypeSourceInfo, ToType, E->getValueKind(),
      ToInitializer, E->isFileScope());
6958}

6960ExpectedStmt ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {

Error Err = Error::success();
auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
auto ToType = importChecked(Err, E->getType());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
if (Err)
  return std::move(Err);

SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs());
if (Error Err = ImportArrayChecked(
    E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
    ToExprs.begin()))
  return std::move(Err);

return new (Importer.getToContext()) AtomicExpr(

    ToBuiltinLoc, ToExprs, ToType, E->getOp(), ToRParenLoc);
6978}

6980ExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
Error Err = Error::success();
auto ToAmpAmpLoc = importChecked(Err, E->getAmpAmpLoc());
auto ToLabelLoc = importChecked(Err, E->getLabelLoc());
auto ToLabel = importChecked(Err, E->getLabel());
auto ToType = importChecked(Err, E->getType());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) AddrLabelExpr(
    ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
6991}
6992ExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) {
Error Err = Error::success();
auto ToSubExpr = importChecked(Err, E->getSubExpr());
auto ToResult = importChecked(Err, E->getAPValueResult());
if (Err)
  return std::move(Err);

return ConstantExpr::Create(Importer.getToContext(), ToSubExpr, ToResult);
7000}
7001ExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
Error Err = Error::success();
auto ToLParen = importChecked(Err, E->getLParen());
auto ToRParen = importChecked(Err, E->getRParen());
auto ToSubExpr = importChecked(Err, E->getSubExpr());
if (Err)
  return std::move(Err);

return new (Importer.getToContext())
    ParenExpr(ToLParen, ToRParen, ToSubExpr);
7011}

7013ExpectedStmt ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
SmallVector<Expr *, 4> ToExprs(E->getNumExprs());
if (Error Err = ImportContainerChecked(E->exprs(), ToExprs))
  return std::move(Err);

ExpectedSLoc ToLParenLocOrErr = import(E->getLParenLoc());
if (!ToLParenLocOrErr)
  return ToLParenLocOrErr.takeError();

ExpectedSLoc ToRParenLocOrErr = import(E->getRParenLoc());
if (!ToRParenLocOrErr)
  return ToRParenLocOrErr.takeError();

return ParenListExpr::Create(Importer.getToContext(), *ToLParenLocOrErr,
                             ToExprs, *ToRParenLocOrErr);
7028}

7030ExpectedStmt ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
Error Err = Error::success();
auto ToSubStmt = importChecked(Err, E->getSubStmt());
auto ToType = importChecked(Err, E->getType());
auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext())
    StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
             E->getTemplateDepth());
7042}

7044ExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
Error Err = Error::success();
auto ToSubExpr = importChecked(Err, E->getSubExpr());
auto ToType = importChecked(Err, E->getType());
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
if (Err)
  return std::move(Err);

return UnaryOperator::Create(
    Importer.getToContext(), ToSubExpr, E->getOpcode(), ToType,
    E->getValueKind(), E->getObjectKind(), ToOperatorLoc, E->canOverflow(),
    E->getFPOptionsOverride());
7056}

7058ExpectedStmt

7060ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
if (Err)
  return std::move(Err);

if (E->isArgumentType()) {
  Expected<TypeSourceInfo *> ToArgumentTypeInfoOrErr =
      import(E->getArgumentTypeInfo());
  if (!ToArgumentTypeInfoOrErr)
    return ToArgumentTypeInfoOrErr.takeError();

  return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
      E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
      ToRParenLoc);
}

ExpectedExpr ToArgumentExprOrErr = import(E->getArgumentExpr());
if (!ToArgumentExprOrErr)
  return ToArgumentExprOrErr.takeError();

return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
    E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
7085}

7087ExpectedStmt ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
Error Err = Error::success();
auto ToLHS = importChecked(Err, E->getLHS());
auto ToRHS = importChecked(Err, E->getRHS());
auto ToType = importChecked(Err, E->getType());
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
if (Err)
  return std::move(Err);

return BinaryOperator::Create(
    Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
    E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
    E->getFPFeatures(Importer.getFromContext().getLangOpts()));
7100}

7102ExpectedStmt ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
Error Err = Error::success();
auto ToCond = importChecked(Err, E->getCond());
auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
auto ToLHS = importChecked(Err, E->getLHS());
auto ToColonLoc = importChecked(Err, E->getColonLoc());
auto ToRHS = importChecked(Err, E->getRHS());
auto ToType = importChecked(Err, E->getType());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) ConditionalOperator(
    ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
    E->getValueKind(), E->getObjectKind());
7116}

7118ExpectedStmt
7119ASTNodeImporter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
Error Err = Error::success();
auto ToCommon = importChecked(Err, E->getCommon());
auto ToOpaqueValue = importChecked(Err, E->getOpaqueValue());
auto ToCond = importChecked(Err, E->getCond());
auto ToTrueExpr = importChecked(Err, E->getTrueExpr());
auto ToFalseExpr = importChecked(Err, E->getFalseExpr());
auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
auto ToColonLoc = importChecked(Err, E->getColonLoc());
auto ToType = importChecked(Err, E->getType());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) BinaryConditionalOperator(
    ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
    ToQuestionLoc, ToColonLoc, ToType, E->getValueKind(),
    E->getObjectKind());
7136}

7138ExpectedStmt ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
Error Err = Error::success();
auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
auto ToQueriedTypeSourceInfo =
    importChecked(Err, E->getQueriedTypeSourceInfo());
auto ToDimensionExpression = importChecked(Err, E->getDimensionExpression());
auto ToEndLoc = importChecked(Err, E->getEndLoc());
auto ToType = importChecked(Err, E->getType());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) ArrayTypeTraitExpr(
    ToBeginLoc, E->getTrait(), ToQueriedTypeSourceInfo, E->getValue(),
    ToDimensionExpression, ToEndLoc, ToType);
7152}

7154ExpectedStmt ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
Error Err = Error::success();
auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
auto ToQueriedExpression = importChecked(Err, E->getQueriedExpression());
auto ToEndLoc = importChecked(Err, E->getEndLoc());
auto ToType = importChecked(Err, E->getType());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) ExpressionTraitExpr(
    ToBeginLoc, E->getTrait(), ToQueriedExpression, E->getValue(),
    ToEndLoc, ToType);
7166}

7168ExpectedStmt ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
Error Err = Error::success();
auto ToLocation = importChecked(Err, E->getLocation());
auto ToType = importChecked(Err, E->getType());
auto ToSourceExpr = importChecked(Err, E->getSourceExpr());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) OpaqueValueExpr(
    ToLocation, ToType, E->getValueKind(), E->getObjectKind(), ToSourceExpr);
7178}

7180ExpectedStmt ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
Error Err = Error::success();
auto ToLHS = importChecked(Err, E->getLHS());
auto ToRHS = importChecked(Err, E->getRHS());
auto ToType = importChecked(Err, E->getType());
auto ToRBracketLoc = importChecked(Err, E->getRBracketLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) ArraySubscriptExpr(
    ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(),
    ToRBracketLoc);
7192}

7194ExpectedStmt
7195ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
Error Err = Error::success();
auto ToLHS = importChecked(Err, E->getLHS());
auto ToRHS = importChecked(Err, E->getRHS());
auto ToType = importChecked(Err, E->getType());
auto ToComputationLHSType = importChecked(Err, E->getComputationLHSType());
auto ToComputationResultType =
    importChecked(Err, E->getComputationResultType());
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
if (Err)
  return std::move(Err);

return CompoundAssignOperator::Create(
    Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
    E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
    E->getFPFeatures(Importer.getFromContext().getLangOpts()),
    ToComputationLHSType, ToComputationResultType);
7212}

7214Expected<CXXCastPath>
7215ASTNodeImporter::ImportCastPath(CastExpr *CE) {
CXXCastPath Path;
for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
  if (auto SpecOrErr = import(*I))
    Path.push_back(*SpecOrErr);
  else
    return SpecOrErr.takeError();
}
return Path;
7224}

7226ExpectedStmt ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
if (!ToSubExprOrErr)
  return ToSubExprOrErr.takeError();

Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E);
if (!ToBasePathOrErr)
  return ToBasePathOrErr.takeError();

return ImplicitCastExpr::Create(
    Importer.getToContext(), *ToTypeOrErr, E->getCastKind(), *ToSubExprOrErr,
    &(*ToBasePathOrErr), E->getValueKind(), E->getFPFeatures());
7242}

7244ExpectedStmt ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToSubExpr = importChecked(Err, E->getSubExpr());
auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
if (Err)
  return std::move(Err);

Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E);
if (!ToBasePathOrErr)
  return ToBasePathOrErr.takeError();
CXXCastPath *ToBasePath = &(*ToBasePathOrErr);

switch (E->getStmtClass()) {
case Stmt::CStyleCastExprClass: {
  auto *CCE = cast<CStyleCastExpr>(E);
  ExpectedSLoc ToLParenLocOrErr = import(CCE->getLParenLoc());
  if (!ToLParenLocOrErr)
    return ToLParenLocOrErr.takeError();
  ExpectedSLoc ToRParenLocOrErr = import(CCE->getRParenLoc());
  if (!ToRParenLocOrErr)
    return ToRParenLocOrErr.takeError();
  return CStyleCastExpr::Create(
      Importer.getToContext(), ToType, E->getValueKind(), E->getCastKind(),
      ToSubExpr, ToBasePath, CCE->getFPFeatures(), ToTypeInfoAsWritten,
      *ToLParenLocOrErr, *ToRParenLocOrErr);
}

case Stmt::CXXFunctionalCastExprClass: {
  auto *FCE = cast<CXXFunctionalCastExpr>(E);
  ExpectedSLoc ToLParenLocOrErr = import(FCE->getLParenLoc());
  if (!ToLParenLocOrErr)
    return ToLParenLocOrErr.takeError();
  ExpectedSLoc ToRParenLocOrErr = import(FCE->getRParenLoc());
  if (!ToRParenLocOrErr)
    return ToRParenLocOrErr.takeError();
  return CXXFunctionalCastExpr::Create(
      Importer.getToContext(), ToType, E->getValueKind(), ToTypeInfoAsWritten,
      E->getCastKind(), ToSubExpr, ToBasePath, FCE->getFPFeatures(),
      *ToLParenLocOrErr, *ToRParenLocOrErr);
}

case Stmt::ObjCBridgedCastExprClass: {
  auto *OCE = cast<ObjCBridgedCastExpr>(E);
  ExpectedSLoc ToLParenLocOrErr = import(OCE->getLParenLoc());
  if (!ToLParenLocOrErr)
    return ToLParenLocOrErr.takeError();
  ExpectedSLoc ToBridgeKeywordLocOrErr = import(OCE->getBridgeKeywordLoc());
  if (!ToBridgeKeywordLocOrErr)
    return ToBridgeKeywordLocOrErr.takeError();
  return new (Importer.getToContext()) ObjCBridgedCastExpr(
      *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(),
      *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
}
default:
  llvm_unreachable("Cast expression of unsupported type!")::llvm::llvm_unreachable_internal("Cast expression of unsupported type!"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 7299);
  return make_error<ImportError>(ImportError::UnsupportedConstruct);
}
7302}

7304ExpectedStmt ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) {
SmallVector<OffsetOfNode, 4> ToNodes;
for (int I = 0, N = E->getNumComponents(); I < N; ++I) {
  const OffsetOfNode &FromNode = E->getComponent(I);

  SourceLocation ToBeginLoc, ToEndLoc;

  if (FromNode.getKind() != OffsetOfNode::Base) {
    Error Err = Error::success();
    ToBeginLoc = importChecked(Err, FromNode.getBeginLoc());
    ToEndLoc = importChecked(Err, FromNode.getEndLoc());
    if (Err)
      return std::move(Err);
  }

  switch (FromNode.getKind()) {
  case OffsetOfNode::Array:
    ToNodes.push_back(
        OffsetOfNode(ToBeginLoc, FromNode.getArrayExprIndex(), ToEndLoc));
    break;
  case OffsetOfNode::Base: {
    auto ToBSOrErr = import(FromNode.getBase());
    if (!ToBSOrErr)
      return ToBSOrErr.takeError();
    ToNodes.push_back(OffsetOfNode(*ToBSOrErr));
    break;
  }
  case OffsetOfNode::Field: {
    auto ToFieldOrErr = import(FromNode.getField());
    if (!ToFieldOrErr)
      return ToFieldOrErr.takeError();
    ToNodes.push_back(OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
    break;
  }
  case OffsetOfNode::Identifier: {
    IdentifierInfo *ToII = Importer.Import(FromNode.getFieldName());
    ToNodes.push_back(OffsetOfNode(ToBeginLoc, ToII, ToEndLoc));
    break;
  }
  }
}

SmallVector<Expr *, 4> ToExprs(E->getNumExpressions());
for (int I = 0, N = E->getNumExpressions(); I < N; ++I) {
  ExpectedExpr ToIndexExprOrErr = import(E->getIndexExpr(I));
  if (!ToIndexExprOrErr)
    return ToIndexExprOrErr.takeError();
  ToExprs[I] = *ToIndexExprOrErr;
}

Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
if (Err)
  return std::move(Err);

return OffsetOfExpr::Create(
    Importer.getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes,
    ToExprs, ToRParenLoc);
7365}

7367ExpectedStmt ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToOperand = importChecked(Err, E->getOperand());
auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
auto ToEndLoc = importChecked(Err, E->getEndLoc());
if (Err)
  return std::move(Err);

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

return new (Importer.getToContext()) CXXNoexceptExpr(
    ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
7384}

7386ExpectedStmt ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
Error Err = Error::success();
auto ToSubExpr = importChecked(Err, E->getSubExpr());
auto ToType = importChecked(Err, E->getType());
auto ToThrowLoc = importChecked(Err, E->getThrowLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) CXXThrowExpr(
    ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope());
7396}

7398ExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
ExpectedSLoc ToUsedLocOrErr = import(E->getUsedLocation());
if (!ToUsedLocOrErr)
  return ToUsedLocOrErr.takeError();

auto ToParamOrErr = import(E->getParam());
if (!ToParamOrErr)
  return ToParamOrErr.takeError();

auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext());
if (!UsedContextOrErr)
  return UsedContextOrErr.takeError();

// Import the default arg if it was not imported yet.
// This is needed because it can happen that during the import of the
// default expression (from VisitParmVarDecl) the same ParmVarDecl is
// encountered here. The default argument for a ParmVarDecl is set in the
// ParmVarDecl only after it is imported (set in VisitParmVarDecl if not here,
// see VisitParmVarDecl).
ParmVarDecl *ToParam = *ToParamOrErr;
if (!ToParam->getDefaultArg()) {
  Optional<ParmVarDecl *> FromParam = Importer.getImportedFromDecl(ToParam);
  assert(FromParam && "ParmVarDecl was not imported?")(static_cast <bool> (FromParam && "ParmVarDecl was not imported?"
) ? void (0) : __assert_fail ("FromParam && \"ParmVarDecl was not imported?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 7420, __extension__ __PRETTY_FUNCTION__));

  if (Error Err = ImportDefaultArgOfParmVarDecl(*FromParam, ToParam))
    return std::move(Err);
}

return CXXDefaultArgExpr::Create(Importer.getToContext(), *ToUsedLocOrErr,
                                 *ToParamOrErr, *UsedContextOrErr);
7428}

7430ExpectedStmt
7431ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) CXXScalarValueInitExpr(
    ToType, ToTypeSourceInfo, ToRParenLoc);
7441}

7443ExpectedStmt
7444ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
if (!ToSubExprOrErr)
  return ToSubExprOrErr.takeError();

auto ToDtorOrErr = import(E->getTemporary()->getDestructor());
if (!ToDtorOrErr)
  return ToDtorOrErr.takeError();

ASTContext &ToCtx = Importer.getToContext();
CXXTemporary *Temp = CXXTemporary::Create(ToCtx, *ToDtorOrErr);
return CXXBindTemporaryExpr::Create(ToCtx, Temp, *ToSubExprOrErr);
7456}

7458ExpectedStmt

7460ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
Error Err = Error::success();
auto ToConstructor = importChecked(Err, E->getConstructor());
auto ToType = importChecked(Err, E->getType());
auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
auto ToParenOrBraceRange = importChecked(Err, E->getParenOrBraceRange());
if (Err)
  return std::move(Err);

SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
  return std::move(Err);

return CXXTemporaryObjectExpr::Create(
    Importer.getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs,
    ToParenOrBraceRange, E->hadMultipleCandidates(),
    E->isListInitialization(), E->isStdInitListInitialization(),
    E->requiresZeroInitialization());
7478}

7480ExpectedDecl ASTNodeImporter::VisitLifetimeExtendedTemporaryDecl(
  LifetimeExtendedTemporaryDecl *D) {
DeclContext *DC, *LexicalDC;
if (Error Err = ImportDeclContext(D, DC, LexicalDC))
  return std::move(Err);

Error Err = Error::success();
auto Temporary = importChecked(Err, D->getTemporaryExpr());
auto ExtendingDecl = importChecked(Err, D->getExtendingDecl());
if (Err)
  return std::move(Err);
// FIXME: Should ManglingNumber get numbers associated with 'to' context?

LifetimeExtendedTemporaryDecl *To;
if (GetImportedOrCreateDecl(To, D, Temporary, ExtendingDecl,
                            D->getManglingNumber()))
  return To;

To->setLexicalDeclContext(LexicalDC);
LexicalDC->addDeclInternal(To);
return To;
7501}

7503ExpectedStmt
7504ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
Expr *ToTemporaryExpr = importChecked(
    Err, E->getLifetimeExtendedTemporaryDecl() ? nullptr : E->getSubExpr());
auto ToMaterializedDecl =
    importChecked(Err, E->getLifetimeExtendedTemporaryDecl());
if (Err)
  return std::move(Err);

if (!ToTemporaryExpr)
  ToTemporaryExpr = cast<Expr>(ToMaterializedDecl->getTemporaryExpr());

auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
    ToType, ToTemporaryExpr, E->isBoundToLvalueReference(),
    ToMaterializedDecl);

return ToMTE;
7522}

7524ExpectedStmt ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToPattern = importChecked(Err, E->getPattern());
auto ToEllipsisLoc = importChecked(Err, E->getEllipsisLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) PackExpansionExpr(
    ToType, ToPattern, ToEllipsisLoc, E->getNumExpansions());
7534}

7536ExpectedStmt ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
Error Err = Error::success();
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
auto ToPack = importChecked(Err, E->getPack());
auto ToPackLoc = importChecked(Err, E->getPackLoc());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
if (Err)
  return std::move(Err);

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

SmallVector<TemplateArgument, 8> ToPartialArguments;
if (E->isPartiallySubstituted()) {
  if (Error Err = ImportTemplateArguments(
      E->getPartialArguments().data(),
      E->getPartialArguments().size(),
      ToPartialArguments))
    return std::move(Err);
}

return SizeOfPackExpr::Create(
    Importer.getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
    Length, ToPartialArguments);
7561}


7564ExpectedStmt ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) {
Error Err = Error::success();
auto ToOperatorNew = importChecked(Err, E->getOperatorNew());
auto ToOperatorDelete = importChecked(Err, E->getOperatorDelete());
auto ToTypeIdParens = importChecked(Err, E->getTypeIdParens());
auto ToArraySize = importChecked(Err, E->getArraySize());
auto ToInitializer = importChecked(Err, E->getInitializer());
auto ToType = importChecked(Err, E->getType());
auto ToAllocatedTypeSourceInfo =
    importChecked(Err, E->getAllocatedTypeSourceInfo());
auto ToSourceRange = importChecked(Err, E->getSourceRange());
auto ToDirectInitRange = importChecked(Err, E->getDirectInitRange());
if (Err)
  return std::move(Err);

SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs());
if (Error Err =
    ImportContainerChecked(E->placement_arguments(), ToPlacementArgs))
  return std::move(Err);

return CXXNewExpr::Create(
    Importer.getToContext(), E->isGlobalNew(), ToOperatorNew,
    ToOperatorDelete, E->passAlignment(), E->doesUsualArrayDeleteWantSize(),
    ToPlacementArgs, ToTypeIdParens, ToArraySize, E->getInitializationStyle(),
    ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange,
    ToDirectInitRange);
7590}

7592ExpectedStmt ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToOperatorDelete = importChecked(Err, E->getOperatorDelete());
auto ToArgument = importChecked(Err, E->getArgument());
auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) CXXDeleteExpr(
    ToType, E->isGlobalDelete(), E->isArrayForm(), E->isArrayFormAsWritten(),
    E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument,
    ToBeginLoc);
7605}

7607ExpectedStmt ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToLocation = importChecked(Err, E->getLocation());
auto ToConstructor = importChecked(Err, E->getConstructor());
auto ToParenOrBraceRange = importChecked(Err, E->getParenOrBraceRange());
if (Err)
  return std::move(Err);

SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
  return std::move(Err);

return CXXConstructExpr::Create(
    Importer.getToContext(), ToType, ToLocation, ToConstructor,
    E->isElidable(), ToArgs, E->hadMultipleCandidates(),
    E->isListInitialization(), E->isStdInitListInitialization(),
    E->requiresZeroInitialization(), E->getConstructionKind(),
    ToParenOrBraceRange);
7626}

7628ExpectedStmt ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *E) {
ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
if (!ToSubExprOrErr)
  return ToSubExprOrErr.takeError();

SmallVector<ExprWithCleanups::CleanupObject, 8> ToObjects(E->getNumObjects());
if (Error Err = ImportContainerChecked(E->getObjects(), ToObjects))
  return std::move(Err);

return ExprWithCleanups::Create(
    Importer.getToContext(), *ToSubExprOrErr, E->cleanupsHaveSideEffects(),
    ToObjects);
7640}

7642ExpectedStmt ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
Error Err = Error::success();
auto ToCallee = importChecked(Err, E->getCallee());
auto ToType = importChecked(Err, E->getType());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
if (Err)
  return std::move(Err);

SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
  return std::move(Err);

return CXXMemberCallExpr::Create(Importer.getToContext(), ToCallee, ToArgs,
                                 ToType, E->getValueKind(), ToRParenLoc,
                                 E->getFPFeatures());
7657}

7659ExpectedStmt ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedSLoc ToLocationOrErr = import(E->getLocation());
if (!ToLocationOrErr)
  return ToLocationOrErr.takeError();

return new (Importer.getToContext()) CXXThisExpr(
    *ToLocationOrErr, *ToTypeOrErr, E->isImplicit());
7670}

7672ExpectedStmt ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedSLoc ToLocationOrErr = import(E->getLocation());
if (!ToLocationOrErr)
  return ToLocationOrErr.takeError();

return new (Importer.getToContext()) CXXBoolLiteralExpr(
    E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
7683}

7685ExpectedStmt ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
Error Err = Error::success();
auto ToBase = importChecked(Err, E->getBase());
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
auto ToMemberDecl = importChecked(Err, E->getMemberDecl());
auto ToType = importChecked(Err, E->getType());
auto ToDecl = importChecked(Err, E->getFoundDecl().getDecl());
auto ToName = importChecked(Err, E->getMemberNameInfo().getName());
auto ToLoc = importChecked(Err, E->getMemberNameInfo().getLoc());
if (Err)
  return std::move(Err);

DeclAccessPair ToFoundDecl =
    DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess());

DeclarationNameInfo ToMemberNameInfo(ToName, ToLoc);

TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
if (E->hasExplicitTemplateArgs()) {
  if (Error Err =
          ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
                                         E->template_arguments(), ToTAInfo))
    return std::move(Err);
  ResInfo = &ToTAInfo;
}

return MemberExpr::Create(Importer.getToContext(), ToBase, E->isArrow(),
                          ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
                          ToMemberDecl, ToFoundDecl, ToMemberNameInfo,
                          ResInfo, ToType, E->getValueKind(),
                          E->getObjectKind(), E->isNonOdrUse());
7718}

7720ExpectedStmt
7721ASTNodeImporter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
Error Err = Error::success();
auto ToBase = importChecked(Err, E->getBase());
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
auto ToScopeTypeInfo = importChecked(Err, E->getScopeTypeInfo());
auto ToColonColonLoc = importChecked(Err, E->getColonColonLoc());
auto ToTildeLoc = importChecked(Err, E->getTildeLoc());
if (Err)
  return std::move(Err);

PseudoDestructorTypeStorage Storage;
if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
  IdentifierInfo *ToII = Importer.Import(FromII);
  ExpectedSLoc ToDestroyedTypeLocOrErr = import(E->getDestroyedTypeLoc());
  if (!ToDestroyedTypeLocOrErr)
    return ToDestroyedTypeLocOrErr.takeError();
  Storage = PseudoDestructorTypeStorage(ToII, *ToDestroyedTypeLocOrErr);
} else {
  if (auto ToTIOrErr = import(E->getDestroyedTypeInfo()))
    Storage = PseudoDestructorTypeStorage(*ToTIOrErr);
  else
    return ToTIOrErr.takeError();
}

return new (Importer.getToContext()) CXXPseudoDestructorExpr(
    Importer.getToContext(), ToBase, E->isArrow(), ToOperatorLoc,
    ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage);
7749}

7751ExpectedStmt ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
  CXXDependentScopeMemberExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
auto ToFirstQualifierFoundInScope =
    importChecked(Err, E->getFirstQualifierFoundInScope());
if (Err)
  return std::move(Err);

Expr *ToBase = nullptr;
if (!E->isImplicitAccess()) {
  if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
    ToBase = *ToBaseOrErr;
  else
    return ToBaseOrErr.takeError();
}

TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;

if (E->hasExplicitTemplateArgs()) {
  if (Error Err =
          ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
                                         E->template_arguments(), ToTAInfo))
    return std::move(Err);
  ResInfo = &ToTAInfo;
}
auto ToMember = importChecked(Err, E->getMember());
auto ToMemberLoc = importChecked(Err, E->getMemberLoc());
if (Err)
  return std::move(Err);
DeclarationNameInfo ToMemberNameInfo(ToMember, ToMemberLoc);

// Import additional name location/type info.
if (Error Err =
        ImportDeclarationNameLoc(E->getMemberNameInfo(), ToMemberNameInfo))
  return std::move(Err);

return CXXDependentScopeMemberExpr::Create(
    Importer.getToContext(), ToBase, ToType, E->isArrow(), ToOperatorLoc,
    ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope,
    ToMemberNameInfo, ResInfo);
7795}

7797ExpectedStmt
7798ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
Error Err = Error::success();
auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
auto ToDeclName = importChecked(Err, E->getDeclName());
auto ToNameLoc = importChecked(Err, E->getNameInfo().getLoc());
auto ToLAngleLoc = importChecked(Err, E->getLAngleLoc());
auto ToRAngleLoc = importChecked(Err, E->getRAngleLoc());
if (Err)
  return std::move(Err);

DeclarationNameInfo ToNameInfo(ToDeclName, ToNameLoc);
if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
  return std::move(Err);

TemplateArgumentListInfo ToTAInfo(ToLAngleLoc, ToRAngleLoc);
TemplateArgumentListInfo *ResInfo = nullptr;
if (E->hasExplicitTemplateArgs()) {
  if (Error Err =
      ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
    return std::move(Err);
  ResInfo = &ToTAInfo;
}

return DependentScopeDeclRefExpr::Create(
    Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc,
    ToNameInfo, ResInfo);
7825}

7827ExpectedStmt ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
  CXXUnresolvedConstructExpr *E) {
Error Err = Error::success();
auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
auto ToType = importChecked(Err, E->getType());
auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
if (Err)
  return std::move(Err);

SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
if (Error Err =
    ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin()))
  return std::move(Err);

return CXXUnresolvedConstructExpr::Create(
    Importer.getToContext(), ToType, ToTypeSourceInfo, ToLParenLoc,
    llvm::makeArrayRef(ToArgs), ToRParenLoc);
7845}

7847ExpectedStmt
7848ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
Expected<CXXRecordDecl *> ToNamingClassOrErr = import(E->getNamingClass());
if (!ToNamingClassOrErr)
  return ToNamingClassOrErr.takeError();

auto ToQualifierLocOrErr = import(E->getQualifierLoc());
if (!ToQualifierLocOrErr)
  return ToQualifierLocOrErr.takeError();

Error Err = Error::success();
auto ToName = importChecked(Err, E->getName());
auto ToNameLoc = importChecked(Err, E->getNameLoc());
if (Err)
  return std::move(Err);
DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);

// Import additional name location/type info.
if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
  return std::move(Err);

UnresolvedSet<8> ToDecls;
for (auto *D : E->decls())
  if (auto ToDOrErr = import(D))
    ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
  else
    return ToDOrErr.takeError();

if (E->hasExplicitTemplateArgs()) {
  TemplateArgumentListInfo ToTAInfo;
  if (Error Err = ImportTemplateArgumentListInfo(
      E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(),
      ToTAInfo))
    return std::move(Err);

  ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc());
  if (!ToTemplateKeywordLocOrErr)
    return ToTemplateKeywordLocOrErr.takeError();

  return UnresolvedLookupExpr::Create(
      Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
      *ToTemplateKeywordLocOrErr, ToNameInfo, E->requiresADL(), &ToTAInfo,
      ToDecls.begin(), ToDecls.end());
}

return UnresolvedLookupExpr::Create(
    Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
    ToNameInfo, E->requiresADL(), E->isOverloaded(), ToDecls.begin(),
    ToDecls.end());
7896}

7898ExpectedStmt
7899ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
auto ToName = importChecked(Err, E->getName());
auto ToNameLoc = importChecked(Err, E->getNameLoc());
if (Err)
  return std::move(Err);

DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
// Import additional name location/type info.
if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
  return std::move(Err);

UnresolvedSet<8> ToDecls;
for (Decl *D : E->decls())
  if (auto ToDOrErr = import(D))
    ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
  else
    return ToDOrErr.takeError();

TemplateArgumentListInfo ToTAInfo;
TemplateArgumentListInfo *ResInfo = nullptr;
if (E->hasExplicitTemplateArgs()) {
  TemplateArgumentListInfo FromTAInfo;
  E->copyTemplateArgumentsInto(FromTAInfo);
  if (Error Err = ImportTemplateArgumentListInfo(FromTAInfo, ToTAInfo))
    return std::move(Err);
  ResInfo = &ToTAInfo;
}

Expr *ToBase = nullptr;
if (!E->isImplicitAccess()) {
  if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
    ToBase = *ToBaseOrErr;
  else
    return ToBaseOrErr.takeError();
}

return UnresolvedMemberExpr::Create(
    Importer.getToContext(), E->hasUnresolvedUsing(), ToBase, ToType,
    E->isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
    ToNameInfo, ResInfo, ToDecls.begin(), ToDecls.end());
7944}

7946ExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) {
Error Err = Error::success();
auto ToCallee = importChecked(Err, E->getCallee());
auto ToType = importChecked(Err, E->getType());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
if (Err)
  return std::move(Err);

unsigned NumArgs = E->getNumArgs();
llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
   return std::move(Err);

if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
  return CXXOperatorCallExpr::Create(
      Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
      OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
      OCE->getADLCallKind());
}

return CallExpr::Create(Importer.getToContext(), ToCallee, ToArgs, ToType,
                        E->getValueKind(), ToRParenLoc, E->getFPFeatures(),
                        /*MinNumArgs=*/0, E->getADLCallKind());
7969}

7971ExpectedStmt ASTNodeImporter::VisitLambdaExpr(LambdaExpr *E) {
CXXRecordDecl *FromClass = E->getLambdaClass();
auto ToClassOrErr = import(FromClass);
if (!ToClassOrErr)
  return ToClassOrErr.takeError();
CXXRecordDecl *ToClass = *ToClassOrErr;

auto ToCallOpOrErr = import(E->getCallOperator());
if (!ToCallOpOrErr)
  return ToCallOpOrErr.takeError();

SmallVector<Expr *, 8> ToCaptureInits(E->capture_size());
if (Error Err = ImportContainerChecked(E->capture_inits(), ToCaptureInits))
  return std::move(Err);

Error Err = Error::success();
auto ToIntroducerRange = importChecked(Err, E->getIntroducerRange());
auto ToCaptureDefaultLoc = importChecked(Err, E->getCaptureDefaultLoc());
auto ToEndLoc = importChecked(Err, E->getEndLoc());
if (Err)
  return std::move(Err);

return LambdaExpr::Create(Importer.getToContext(), ToClass, ToIntroducerRange,
                          E->getCaptureDefault(), ToCaptureDefaultLoc,
                          E->hasExplicitParameters(),
                          E->hasExplicitResultType(), ToCaptureInits,
                          ToEndLoc, E->containsUnexpandedParameterPack());
7998}


8001ExpectedStmt ASTNodeImporter::VisitInitListExpr(InitListExpr *E) {
Error Err = Error::success();
auto ToLBraceLoc = importChecked(Err, E->getLBraceLoc());
auto ToRBraceLoc = importChecked(Err, E->getRBraceLoc());
auto ToType = importChecked(Err, E->getType());
if (Err)
  return std::move(Err);

SmallVector<Expr *, 4> ToExprs(E->getNumInits());
if (Error Err = ImportContainerChecked(E->inits(), ToExprs))
  return std::move(Err);

ASTContext &ToCtx = Importer.getToContext();
InitListExpr *To = new (ToCtx) InitListExpr(
    ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
To->setType(ToType);

if (E->hasArrayFiller()) {
  if (ExpectedExpr ToFillerOrErr = import(E->getArrayFiller()))
    To->setArrayFiller(*ToFillerOrErr);
  else
    return ToFillerOrErr.takeError();
}

if (FieldDecl *FromFD = E->getInitializedFieldInUnion()) {
  if (auto ToFDOrErr = import(FromFD))
    To->setInitializedFieldInUnion(*ToFDOrErr);
  else
    return ToFDOrErr.takeError();
}

if (InitListExpr *SyntForm = E->getSyntacticForm()) {
  if (auto ToSyntFormOrErr = import(SyntForm))
    To->setSyntacticForm(*ToSyntFormOrErr);
  else
    return ToSyntFormOrErr.takeError();
}

// Copy InitListExprBitfields, which are not handled in the ctor of
// InitListExpr.
To->sawArrayRangeDesignator(E->hadArrayRangeDesignator());

return To;
8044}

8046ExpectedStmt ASTNodeImporter::VisitCXXStdInitializerListExpr(
  CXXStdInitializerListExpr *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
if (!ToSubExprOrErr)
  return ToSubExprOrErr.takeError();

return new (Importer.getToContext()) CXXStdInitializerListExpr(
    *ToTypeOrErr, *ToSubExprOrErr);
8058}

8060ExpectedStmt ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
  CXXInheritedCtorInitExpr *E) {
Error Err = Error::success();
auto ToLocation = importChecked(Err, E->getLocation());
auto ToType = importChecked(Err, E->getType());
auto ToConstructor = importChecked(Err, E->getConstructor());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
    ToLocation, ToType, ToConstructor, E->constructsVBase(),
    E->inheritedFromVBase());
8072}

8074ExpectedStmt ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToCommonExpr = importChecked(Err, E->getCommonExpr());
auto ToSubExpr = importChecked(Err, E->getSubExpr());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) ArrayInitLoopExpr(
    ToType, ToCommonExpr, ToSubExpr);
8084}

8086ExpectedStmt ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();
return new (Importer.getToContext()) ArrayInitIndexExpr(*ToTypeOrErr);
8091}

8093ExpectedStmt ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
ExpectedSLoc ToBeginLocOrErr = import(E->getBeginLoc());
if (!ToBeginLocOrErr)
  return ToBeginLocOrErr.takeError();

auto ToFieldOrErr = import(E->getField());
if (!ToFieldOrErr)
  return ToFieldOrErr.takeError();

auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext());
if (!UsedContextOrErr)
  return UsedContextOrErr.takeError();

return CXXDefaultInitExpr::Create(
    Importer.getToContext(), *ToBeginLocOrErr, *ToFieldOrErr, *UsedContextOrErr);
8108}

8110ExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToSubExpr = importChecked(Err, E->getSubExpr());
auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
auto ToAngleBrackets = importChecked(Err, E->getAngleBrackets());
if (Err)
  return std::move(Err);

ExprValueKind VK = E->getValueKind();
CastKind CK = E->getCastKind();
auto ToBasePathOrErr = ImportCastPath(E);
if (!ToBasePathOrErr)
  return ToBasePathOrErr.takeError();

if (auto CCE = dyn_cast<CXXStaticCastExpr>(E)) {
  return CXXStaticCastExpr::Create(
      Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
      ToTypeInfoAsWritten, CCE->getFPFeatures(), ToOperatorLoc, ToRParenLoc,
      ToAngleBrackets);
} else if (isa<CXXDynamicCastExpr>(E)) {
  return CXXDynamicCastExpr::Create(
      Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
      ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
} else if (isa<CXXReinterpretCastExpr>(E)) {
  return CXXReinterpretCastExpr::Create(
      Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
      ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
} else if (isa<CXXConstCastExpr>(E)) {
  return CXXConstCastExpr::Create(
      Importer.getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten,
      ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
} else {
  llvm_unreachable("Unknown cast type")::llvm::llvm_unreachable_internal("Unknown cast type", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 8145);
  return make_error<ImportError>();
}
8148}

8150ExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
  SubstNonTypeTemplateParmExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToExprLoc = importChecked(Err, E->getExprLoc());
auto ToParameter = importChecked(Err, E->getParameter());
auto ToReplacement = importChecked(Err, E->getReplacement());
if (Err)
  return std::move(Err);

return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
    ToType, E->getValueKind(), ToExprLoc, ToParameter,
    E->isReferenceParameter(), ToReplacement);
8163}

8165ExpectedStmt ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
Error Err = Error::success();
auto ToType = importChecked(Err, E->getType());
auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
auto ToEndLoc = importChecked(Err, E->getEndLoc());
if (Err)
  return std::move(Err);

SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
if (Error Err = ImportContainerChecked(E->getArgs(), ToArgs))
  return std::move(Err);

// According to Sema::BuildTypeTrait(), if E is value-dependent,
// Value is always false.
bool ToValue = (E->isValueDependent() ? false : E->getValue());

return TypeTraitExpr::Create(
    Importer.getToContext(), ToType, ToBeginLoc, E->getTrait(), ToArgs,
    ToEndLoc, ToValue);
8184}

8186ExpectedStmt ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
ExpectedType ToTypeOrErr = import(E->getType());
if (!ToTypeOrErr)
  return ToTypeOrErr.takeError();

auto ToSourceRangeOrErr = import(E->getSourceRange());
if (!ToSourceRangeOrErr)
  return ToSourceRangeOrErr.takeError();

if (E->isTypeOperand()) {
  if (auto ToTSIOrErr = import(E->getTypeOperandSourceInfo()))
    return new (Importer.getToContext()) CXXTypeidExpr(
        *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
  else
    return ToTSIOrErr.takeError();
}

ExpectedExpr ToExprOperandOrErr = import(E->getExprOperand());
if (!ToExprOperandOrErr)
  return ToExprOperandOrErr.takeError();

return new (Importer.getToContext()) CXXTypeidExpr(
    *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
8209}

8211ExpectedStmt ASTNodeImporter::VisitCXXFoldExpr(CXXFoldExpr *E) {
Error Err = Error::success();

QualType ToType = importChecked(Err, E->getType());
UnresolvedLookupExpr *ToCallee = importChecked(Err, E->getCallee());
SourceLocation ToLParenLoc = importChecked(Err, E->getLParenLoc());
Expr *ToLHS = importChecked(Err, E->getLHS());
SourceLocation ToEllipsisLoc = importChecked(Err, E->getEllipsisLoc());
Expr *ToRHS = importChecked(Err, E->getRHS());
SourceLocation ToRParenLoc = importChecked(Err, E->getRParenLoc());

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

return new (Importer.getToContext())
    CXXFoldExpr(ToType, ToCallee, ToLParenLoc, ToLHS, E->getOperator(),
                ToEllipsisLoc, ToRHS, ToRParenLoc, E->getNumExpansions());
8228}

8230Error ASTNodeImporter::ImportOverriddenMethods(CXXMethodDecl *ToMethod,
                                             CXXMethodDecl *FromMethod) {
Error ImportErrors = Error::success();
for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) {
  if (auto ImportedOrErr = import(FromOverriddenMethod))
    ToMethod->getCanonicalDecl()->addOverriddenMethod(cast<CXXMethodDecl>(
        (*ImportedOrErr)->getCanonicalDecl()));
  else
    ImportErrors =
        joinErrors(std::move(ImportErrors), ImportedOrErr.takeError());
}
return ImportErrors;
8242}

8244ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
                       ASTContext &FromContext, FileManager &FromFileManager,
                       bool MinimalImport,
                       std::shared_ptr<ASTImporterSharedState> SharedState)
  : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
    ToFileManager(ToFileManager), FromFileManager(FromFileManager),
    Minimal(MinimalImport), ODRHandling(ODRHandlingType::Conservative) {

// Create a default state without the lookup table: LLDB case.
if (!SharedState) {
  this->SharedState = std::make_shared<ASTImporterSharedState>();
}

ImportedDecls[FromContext.getTranslationUnitDecl()] =
    ToContext.getTranslationUnitDecl();
8259}

8261ASTImporter::~ASTImporter() = default;

8263Optional<unsigned> ASTImporter::getFieldIndex(Decl *F) {
assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&(static_cast <bool> (F && (isa<FieldDecl>
(*F) || isa<IndirectFieldDecl>(*F)) && "Try to get field index for non-field."
) ? void (0) : __assert_fail ("F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) && \"Try to get field index for non-field.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 8265, __extension__ __PRETTY_FUNCTION__))
    "Try to get field index for non-field.")(static_cast <bool> (F && (isa<FieldDecl>
(*F) || isa<IndirectFieldDecl>(*F)) && "Try to get field index for non-field."
) ? void (0) : __assert_fail ("F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) && \"Try to get field index for non-field.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 8265, __extension__ __PRETTY_FUNCTION__));

auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
if (!Owner)
  return None;

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

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

llvm_unreachable("Field was not found in its parent context.")::llvm::llvm_unreachable_internal("Field was not found in its parent context."
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 8280);

return None;
8283}

8285ASTImporter::FoundDeclsTy
8286ASTImporter::findDeclsInToCtx(DeclContext *DC, DeclarationName Name) {
// We search in the redecl context because of transparent contexts.
// E.g. a simple C language enum is a transparent context:
//   enum E { A, B };
// Now if we had a global variable in the TU
//   int A;
// then the enum constant 'A' and the variable 'A' violates ODR.
// We can diagnose this only if we search in the redecl context.
DeclContext *ReDC = DC->getRedeclContext();
if (SharedState->getLookupTable()) {
  ASTImporterLookupTable::LookupResult LookupResult =
      SharedState->getLookupTable()->lookup(ReDC, Name);
  return FoundDeclsTy(LookupResult.begin(), LookupResult.end());
} else {
  DeclContext::lookup_result NoloadLookupResult = ReDC->noload_lookup(Name);
  FoundDeclsTy Result(NoloadLookupResult.begin(), NoloadLookupResult.end());
  // We must search by the slow case of localUncachedLookup because that is
  // working even if there is no LookupPtr for the DC. We could use
  // DC::buildLookup() to create the LookupPtr, but that would load external
  // decls again, we must avoid that case.
  // Also, even if we had the LookupPtr, we must find Decls which are not
  // in the LookupPtr, so we need the slow case.
  // These cases are handled in ASTImporterLookupTable, but we cannot use
  // that with LLDB since that traverses through the AST which initiates the
  // load of external decls again via DC::decls().  And again, we must avoid
  // loading external decls during the import.
  if (Result.empty())
    ReDC->localUncachedLookup(Name, Result);
  return Result;
}
8316}

8318void ASTImporter::AddToLookupTable(Decl *ToD) {
SharedState->addDeclToLookup(ToD);
8320}

8322Expected<Decl *> ASTImporter::ImportImpl(Decl *FromD) {
// Import the decl using ASTNodeImporter.
ASTNodeImporter Importer(*this);
return Importer.Visit(FromD);
8
←
Calling 'Base::Visit'→
8326}

8328void ASTImporter::RegisterImportedDecl(Decl *FromD, Decl *ToD) {
MapImported(FromD, ToD);
8330}

8332llvm::Expected<ExprWithCleanups::CleanupObject>
8333ASTImporter::Import(ExprWithCleanups::CleanupObject From) {
if (auto *CLE = From.dyn_cast<CompoundLiteralExpr *>()) {
  if (Expected<Expr *> R = Import(CLE))
    return ExprWithCleanups::CleanupObject(cast<CompoundLiteralExpr>(*R));
}

// FIXME: Handle BlockDecl when we implement importing BlockExpr in
//        ASTNodeImporter.
return make_error<ImportError>(ImportError::UnsupportedConstruct);
8342}

8344Expected<const Type *> ASTImporter::Import(const Type *FromT) {
if (!FromT)
  return FromT;

// Check whether we've already imported this type.
llvm::DenseMap<const Type *, const Type *>::iterator Pos =
    ImportedTypes.find(FromT);
if (Pos != ImportedTypes.end())
  return Pos->second;

// Import the type
ASTNodeImporter Importer(*this);
ExpectedType ToTOrErr = Importer.Visit(FromT);
if (!ToTOrErr)
  return ToTOrErr.takeError();

// Record the imported type.
ImportedTypes[FromT] = ToTOrErr->getTypePtr();

return ToTOrErr->getTypePtr();
8364}

8366Expected<QualType> ASTImporter::Import(QualType FromT) {
if (FromT.isNull())
  return QualType{};

Expected<const Type *> ToTyOrErr = Import(FromT.getTypePtr());
if (!ToTyOrErr)
  return ToTyOrErr.takeError();

return ToContext.getQualifiedType(*ToTyOrErr, FromT.getLocalQualifiers());
8375}

8377Expected<TypeSourceInfo *> ASTImporter::Import(TypeSourceInfo *FromTSI) {
if (!FromTSI)
  return FromTSI;

// FIXME: For now we just create a "trivial" type source info based
// on the type and a single location. Implement a real version of this.
ExpectedType TOrErr = Import(FromTSI->getType());
if (!TOrErr)
  return TOrErr.takeError();
ExpectedSLoc BeginLocOrErr = Import(FromTSI->getTypeLoc().getBeginLoc());
if (!BeginLocOrErr)
  return BeginLocOrErr.takeError();

return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr);
8391}

8393Expected<Attr *> ASTImporter::Import(const Attr *FromAttr) {
Attr *ToAttr = nullptr;
SourceRange ToRange;
if (Error Err = importInto(ToRange, FromAttr->getRange()))
  return std::move(Err);

// FIXME: Is there some kind of AttrVisitor to use here?
switch (FromAttr->getKind()) {
case attr::Aligned: {
  auto *From = cast<AlignedAttr>(FromAttr);
  AlignedAttr *To;
  auto CreateAlign = [&](bool IsAlignmentExpr, void *Alignment) {
    return AlignedAttr::Create(ToContext, IsAlignmentExpr, Alignment, ToRange,
                               From->getSyntax(),
                               From->getSemanticSpelling());
  };
  if (From->isAlignmentExpr()) {
    if (auto ToEOrErr = Import(From->getAlignmentExpr()))
      To = CreateAlign(true, *ToEOrErr);
    else
      return ToEOrErr.takeError();
  } else {
    if (auto ToTOrErr = Import(From->getAlignmentType()))
      To = CreateAlign(false, *ToTOrErr);
    else
      return ToTOrErr.takeError();
  }
  To->setInherited(From->isInherited());
  To->setPackExpansion(From->isPackExpansion());
  To->setImplicit(From->isImplicit());
  ToAttr = To;
  break;
}
case attr::Format: {
  const auto *From = cast<FormatAttr>(FromAttr);
  FormatAttr *To;
  IdentifierInfo *ToAttrType = Import(From->getType());
  To = FormatAttr::Create(ToContext, ToAttrType, From->getFormatIdx(),
                          From->getFirstArg(), ToRange, From->getSyntax());
  To->setInherited(From->isInherited());
  ToAttr = To;
  break;
}
default:
  // FIXME: 'clone' copies every member but some of them should be imported.
  // Handle other Attrs that have parameters that should be imported.
  ToAttr = FromAttr->clone(ToContext);
  ToAttr->setRange(ToRange);
  break;
}
assert(ToAttr && "Attribute should be created.")(static_cast <bool> (ToAttr && "Attribute should be created."
) ? void (0) : __assert_fail ("ToAttr && \"Attribute should be created.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 8443, __extension__ __PRETTY_FUNCTION__));

return ToAttr;
8446}

8448Decl *ASTImporter::GetAlreadyImportedOrNull(const Decl *FromD) const {
auto Pos = ImportedDecls.find(FromD);
if (Pos != ImportedDecls.end())
  return Pos->second;
else
  return nullptr;
8454}

8456TranslationUnitDecl *ASTImporter::GetFromTU(Decl *ToD) {
auto FromDPos = ImportedFromDecls.find(ToD);
if (FromDPos == ImportedFromDecls.end())
  return nullptr;
return FromDPos->second->getTranslationUnitDecl();
8461}

8463Expected<Decl *> ASTImporter::Import(Decl *FromD) {
if (!FromD)
2
←
Assuming 'FromD' is non-null→
3
←
Taking false branch→
  return nullptr;

// Push FromD to the stack, and remove that when we return.
ImportPath.push(FromD);
auto ImportPathBuilder =
    llvm::make_scope_exit([this]() { ImportPath.pop(); });

// Check whether there was a previous failed import.
// If yes return the existing error.
if (auto Error = getImportDeclErrorIfAny(FromD))
4
←
Taking false branch→
  return make_error<ImportError>(*Error);

// Check whether we've already imported this declaration.
Decl *ToD = GetAlreadyImportedOrNull(FromD);
if (ToD) {
5
←
Assuming 'ToD' is null→
6
←
Taking false branch→
  // Already imported (possibly from another TU) and with an error.
  if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
    setImportDeclError(FromD, *Error);
    return make_error<ImportError>(*Error);
  }

  // If FromD has some updated flags after last import, apply it.
  updateFlags(FromD, ToD);
  // If we encounter a cycle during an import then we save the relevant part
  // of the import path associated to the Decl.
  if (ImportPath.hasCycleAtBack())
    SavedImportPaths[FromD].push_back(ImportPath.copyCycleAtBack());
  return ToD;
}

// Import the declaration.
ExpectedDecl ToDOrErr = ImportImpl(FromD);
7
←
Calling 'ASTImporter::ImportImpl'→
if (!ToDOrErr) {
  // Failed to import.

  auto Pos = ImportedDecls.find(FromD);
  if (Pos != ImportedDecls.end()) {
    // Import failed after the object was created.
    // Remove all references to it.
    auto *ToD = Pos->second;
    ImportedDecls.erase(Pos);

    // ImportedDecls and ImportedFromDecls are not symmetric.  It may happen
    // (e.g. with namespaces) that several decls from the 'from' context are
    // mapped to the same decl in the 'to' context.  If we removed entries
    // from the LookupTable here then we may end up removing them multiple
    // times.

    // The Lookuptable contains decls only which are in the 'to' context.
    // Remove from the Lookuptable only if it is *imported* into the 'to'
    // context (and do not remove it if it was added during the initial
    // traverse of the 'to' context).
    auto PosF = ImportedFromDecls.find(ToD);
    if (PosF != ImportedFromDecls.end()) {
      // In the case of TypedefNameDecl we create the Decl first and only
      // then we import and set its DeclContext. So, the DC might not be set
      // when we reach here.
      if (ToD->getDeclContext())
        SharedState->removeDeclFromLookup(ToD);
      ImportedFromDecls.erase(PosF);
    }

    // FIXME: AST may contain remaining references to the failed object.
    // However, the ImportDeclErrors in the shared state contains all the
    // failed objects together with their error.
  }

  // Error encountered for the first time.
  // After takeError the error is not usable any more in ToDOrErr.
  // Get a copy of the error object (any more simple solution for this?).
  ImportError ErrOut;
  handleAllErrors(ToDOrErr.takeError(),
                  [&ErrOut](const ImportError &E) { ErrOut = E; });
  setImportDeclError(FromD, ErrOut);
  // Set the error for the mapped to Decl, which is in the "to" context.
  if (Pos != ImportedDecls.end())
    SharedState->setImportDeclError(Pos->second, ErrOut);

  // Set the error for all nodes which have been created before we
  // recognized the error.
  for (const auto &Path : SavedImportPaths[FromD])
    for (Decl *FromDi : Path) {
      setImportDeclError(FromDi, ErrOut);
      //FIXME Should we remove these Decls from ImportedDecls?
      // Set the error for the mapped to Decl, which is in the "to" context.
      auto Ii = ImportedDecls.find(FromDi);
      if (Ii != ImportedDecls.end())
        SharedState->setImportDeclError(Ii->second, ErrOut);
        // FIXME Should we remove these Decls from the LookupTable,
        // and from ImportedFromDecls?
    }
  SavedImportPaths.erase(FromD);

  // Do not return ToDOrErr, error was taken out of it.
  return make_error<ImportError>(ErrOut);
}

ToD = *ToDOrErr;

// FIXME: Handle the "already imported with error" case. We can get here
// nullptr only if GetImportedOrCreateDecl returned nullptr (after a
// previously failed create was requested).
// Later GetImportedOrCreateDecl can be updated to return the error.
if (!ToD) {
  auto Err = getImportDeclErrorIfAny(FromD);
  assert(Err)(static_cast <bool> (Err) ? void (0) : __assert_fail ("Err"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 8570, __extension__ __PRETTY_FUNCTION__));
  return make_error<ImportError>(*Err);
}

// We could import from the current TU without error.  But previously we
// already had imported a Decl as `ToD` from another TU (with another
// ASTImporter object) and with an error.
if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
  setImportDeclError(FromD, *Error);
  return make_error<ImportError>(*Error);
}

// Make sure that ImportImpl registered the imported decl.
assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?")(static_cast <bool> (ImportedDecls.count(FromD) != 0 &&
 "Missing call to MapImported?") ? void (0) : __assert_fail (
"ImportedDecls.count(FromD) != 0 && \"Missing call to MapImported?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 8583, __extension__ __PRETTY_FUNCTION__));

if (FromD->hasAttrs())
  for (const Attr *FromAttr : FromD->getAttrs()) {
    auto ToAttrOrErr = Import(FromAttr);
    if (ToAttrOrErr)
      ToD->addAttr(*ToAttrOrErr);
    else
      return ToAttrOrErr.takeError();
  }

// Notify subclasses.
Imported(FromD, ToD);

updateFlags(FromD, ToD);
SavedImportPaths.erase(FromD);
return ToDOrErr;
8600}

8602Expected<DeclContext *> ASTImporter::ImportContext(DeclContext *FromDC) {
if (!FromDC)
  return FromDC;

ExpectedDecl ToDCOrErr = Import(cast<Decl>(FromDC));
if (!ToDCOrErr)
  return ToDCOrErr.takeError();
auto *ToDC = cast<DeclContext>(*ToDCOrErr);

// When we're using a record/enum/Objective-C class/protocol as a context, we
// need it to have a definition.
if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
  auto *FromRecord = cast<RecordDecl>(FromDC);
  if (ToRecord->isCompleteDefinition())
    return ToDC;

  // If FromRecord is not defined we need to force it to be.
  // Simply calling CompleteDecl(...) for a RecordDecl will break some cases
  // it will start the definition but we never finish it.
  // If there are base classes they won't be imported and we will
  // be missing anything that we inherit from those bases.
  if (FromRecord->getASTContext().getExternalSource() &&
      !FromRecord->isCompleteDefinition())
    FromRecord->getASTContext().getExternalSource()->CompleteType(FromRecord);

  if (FromRecord->isCompleteDefinition())
    if (Error Err = ASTNodeImporter(*this).ImportDefinition(
        FromRecord, ToRecord, ASTNodeImporter::IDK_Basic))
      return std::move(Err);
} else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
  auto *FromEnum = cast<EnumDecl>(FromDC);
  if (ToEnum->isCompleteDefinition()) {
    // Do nothing.
  } else if (FromEnum->isCompleteDefinition()) {
    if (Error Err = ASTNodeImporter(*this).ImportDefinition(
        FromEnum, ToEnum, ASTNodeImporter::IDK_Basic))
      return std::move(Err);
  } else {
    CompleteDecl(ToEnum);
  }
} else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
  auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
  if (ToClass->getDefinition()) {
    // Do nothing.
  } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
    if (Error Err = ASTNodeImporter(*this).ImportDefinition(
        FromDef, ToClass, ASTNodeImporter::IDK_Basic))
      return std::move(Err);
  } else {
    CompleteDecl(ToClass);
  }
} else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
  auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
  if (ToProto->getDefinition()) {
    // Do nothing.
  } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
    if (Error Err = ASTNodeImporter(*this).ImportDefinition(
        FromDef, ToProto, ASTNodeImporter::IDK_Basic))
      return std::move(Err);
  } else {
    CompleteDecl(ToProto);
  }
}

return ToDC;
8667}

8669Expected<Expr *> ASTImporter::Import(Expr *FromE) {
if (ExpectedStmt ToSOrErr = Import(cast_or_null<Stmt>(FromE)))
  return cast_or_null<Expr>(*ToSOrErr);
else
  return ToSOrErr.takeError();
8674}

8676Expected<Stmt *> ASTImporter::Import(Stmt *FromS) {
if (!FromS)
  return nullptr;

// Check whether we've already imported this statement.
llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
if (Pos != ImportedStmts.end())
  return Pos->second;

// Import the statement.
ASTNodeImporter Importer(*this);
ExpectedStmt ToSOrErr = Importer.Visit(FromS);
if (!ToSOrErr)
  return ToSOrErr;

if (auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
  auto *FromE = cast<Expr>(FromS);
  // Copy ExprBitfields, which may not be handled in Expr subclasses
  // constructors.
  ToE->setValueKind(FromE->getValueKind());
  ToE->setObjectKind(FromE->getObjectKind());
  ToE->setDependence(FromE->getDependence());
}

// Record the imported statement object.
ImportedStmts[FromS] = *ToSOrErr;
return ToSOrErr;
8703}

8705Expected<NestedNameSpecifier *>
8706ASTImporter::Import(NestedNameSpecifier *FromNNS) {
if (!FromNNS)
  return nullptr;

NestedNameSpecifier *Prefix = nullptr;
if (Error Err = importInto(Prefix, FromNNS->getPrefix()))
  return std::move(Err);

switch (FromNNS->getKind()) {
case NestedNameSpecifier::Identifier:
  assert(FromNNS->getAsIdentifier() && "NNS should contain identifier.")(static_cast <bool> (FromNNS->getAsIdentifier() &&
 "NNS should contain identifier.") ? void (0) : __assert_fail
 ("FromNNS->getAsIdentifier() && \"NNS should contain identifier.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 8716, __extension__ __PRETTY_FUNCTION__));
  return NestedNameSpecifier::Create(ToContext, Prefix,
                                     Import(FromNNS->getAsIdentifier()));

case NestedNameSpecifier::Namespace:
  if (ExpectedDecl NSOrErr = Import(FromNNS->getAsNamespace())) {
    return NestedNameSpecifier::Create(ToContext, Prefix,
                                       cast<NamespaceDecl>(*NSOrErr));
  } else
    return NSOrErr.takeError();

case NestedNameSpecifier::NamespaceAlias:
  if (ExpectedDecl NSADOrErr = Import(FromNNS->getAsNamespaceAlias()))
    return NestedNameSpecifier::Create(ToContext, Prefix,
                                       cast<NamespaceAliasDecl>(*NSADOrErr));
  else
    return NSADOrErr.takeError();

case NestedNameSpecifier::Global:
  return NestedNameSpecifier::GlobalSpecifier(ToContext);

case NestedNameSpecifier::Super:
  if (ExpectedDecl RDOrErr = Import(FromNNS->getAsRecordDecl()))
    return NestedNameSpecifier::SuperSpecifier(ToContext,
                                               cast<CXXRecordDecl>(*RDOrErr));
  else
    return RDOrErr.takeError();

case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
  if (Expected<QualType> TyOrErr =
          Import(QualType(FromNNS->getAsType(), 0u))) {
    bool TSTemplate =
        FromNNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate;
    return NestedNameSpecifier::Create(ToContext, Prefix, TSTemplate,
                                       TyOrErr->getTypePtr());
  } else {
    return TyOrErr.takeError();
  }
}

llvm_unreachable("Invalid nested name specifier kind")::llvm::llvm_unreachable_internal("Invalid nested name specifier kind"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 8757);
8758}

8760Expected<NestedNameSpecifierLoc>
8761ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
// Copied from NestedNameSpecifier mostly.
SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
NestedNameSpecifierLoc NNS = FromNNS;

// Push each of the nested-name-specifiers's onto a stack for
// serialization in reverse order.
while (NNS) {
  NestedNames.push_back(NNS);
  NNS = NNS.getPrefix();
}

NestedNameSpecifierLocBuilder Builder;

while (!NestedNames.empty()) {
  NNS = NestedNames.pop_back_val();
  NestedNameSpecifier *Spec = nullptr;
  if (Error Err = importInto(Spec, NNS.getNestedNameSpecifier()))
    return std::move(Err);

  NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();

  SourceLocation ToLocalBeginLoc, ToLocalEndLoc;
  if (Kind != NestedNameSpecifier::Super) {
    if (Error Err = importInto(ToLocalBeginLoc, NNS.getLocalBeginLoc()))
      return std::move(Err);

    if (Kind != NestedNameSpecifier::Global)
      if (Error Err = importInto(ToLocalEndLoc, NNS.getLocalEndLoc()))
        return std::move(Err);
  }

  switch (Kind) {
  case NestedNameSpecifier::Identifier:
    Builder.Extend(getToContext(), Spec->getAsIdentifier(), ToLocalBeginLoc,
                   ToLocalEndLoc);
    break;

  case NestedNameSpecifier::Namespace:
    Builder.Extend(getToContext(), Spec->getAsNamespace(), ToLocalBeginLoc,
                   ToLocalEndLoc);
    break;

  case NestedNameSpecifier::NamespaceAlias:
    Builder.Extend(getToContext(), Spec->getAsNamespaceAlias(),
                   ToLocalBeginLoc, ToLocalEndLoc);
    break;

  case NestedNameSpecifier::TypeSpec:
  case NestedNameSpecifier::TypeSpecWithTemplate: {
    SourceLocation ToTLoc;
    if (Error Err = importInto(ToTLoc, NNS.getTypeLoc().getBeginLoc()))
      return std::move(Err);
    TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
          QualType(Spec->getAsType(), 0), ToTLoc);
    if (Kind == NestedNameSpecifier::TypeSpecWithTemplate)
      // ToLocalBeginLoc is here the location of the 'template' keyword.
      Builder.Extend(getToContext(), ToLocalBeginLoc, TSI->getTypeLoc(),
                     ToLocalEndLoc);
    else
      // No location for 'template' keyword here.
      Builder.Extend(getToContext(), SourceLocation{}, TSI->getTypeLoc(),
                     ToLocalEndLoc);
    break;
  }

  case NestedNameSpecifier::Global:
    Builder.MakeGlobal(getToContext(), ToLocalBeginLoc);
    break;

  case NestedNameSpecifier::Super: {
    auto ToSourceRangeOrErr = Import(NNS.getSourceRange());
    if (!ToSourceRangeOrErr)
      return ToSourceRangeOrErr.takeError();

    Builder.MakeSuper(getToContext(), Spec->getAsRecordDecl(),
                      ToSourceRangeOrErr->getBegin(),
                      ToSourceRangeOrErr->getEnd());
  }
}
}

return Builder.getWithLocInContext(getToContext());
8844}

8846Expected<TemplateName> ASTImporter::Import(TemplateName From) {
switch (From.getKind()) {
case TemplateName::Template:
  if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl()))
    return TemplateName(cast<TemplateDecl>(*ToTemplateOrErr));
  else
    return ToTemplateOrErr.takeError();

case TemplateName::OverloadedTemplate: {
  OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
  UnresolvedSet<2> ToTemplates;
  for (auto *I : *FromStorage) {
    if (auto ToOrErr = Import(I))
      ToTemplates.addDecl(cast<NamedDecl>(*ToOrErr));
    else
      return ToOrErr.takeError();
  }
  return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
                                             ToTemplates.end());
}

case TemplateName::AssumedTemplate: {
  AssumedTemplateStorage *FromStorage = From.getAsAssumedTemplateName();
  auto DeclNameOrErr = Import(FromStorage->getDeclName());
  if (!DeclNameOrErr)
    return DeclNameOrErr.takeError();
  return ToContext.getAssumedTemplateName(*DeclNameOrErr);
}

case TemplateName::QualifiedTemplate: {
  QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
  auto QualifierOrErr = Import(QTN->getQualifier());
  if (!QualifierOrErr)
    return QualifierOrErr.takeError();

  if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl()))
    return ToContext.getQualifiedTemplateName(
        *QualifierOrErr, QTN->hasTemplateKeyword(),
        cast<TemplateDecl>(*ToTemplateOrErr));
  else
    return ToTemplateOrErr.takeError();
}

case TemplateName::DependentTemplate: {
  DependentTemplateName *DTN = From.getAsDependentTemplateName();
  auto QualifierOrErr = Import(DTN->getQualifier());
  if (!QualifierOrErr)
    return QualifierOrErr.takeError();

  if (DTN->isIdentifier()) {
    return ToContext.getDependentTemplateName(*QualifierOrErr,
                                              Import(DTN->getIdentifier()));
  }

  return ToContext.getDependentTemplateName(*QualifierOrErr,
                                            DTN->getOperator());
}

case TemplateName::SubstTemplateTemplateParm: {
  SubstTemplateTemplateParmStorage *Subst =
      From.getAsSubstTemplateTemplateParm();
  ExpectedDecl ParamOrErr = Import(Subst->getParameter());
  if (!ParamOrErr)
    return ParamOrErr.takeError();

  auto ReplacementOrErr = Import(Subst->getReplacement());
  if (!ReplacementOrErr)
    return ReplacementOrErr.takeError();

  return ToContext.getSubstTemplateTemplateParm(
      cast<TemplateTemplateParmDecl>(*ParamOrErr), *ReplacementOrErr);
}

case TemplateName::SubstTemplateTemplateParmPack: {
  SubstTemplateTemplateParmPackStorage *SubstPack
    = From.getAsSubstTemplateTemplateParmPack();
  ExpectedDecl ParamOrErr = Import(SubstPack->getParameterPack());
  if (!ParamOrErr)
    return ParamOrErr.takeError();

  ASTNodeImporter Importer(*this);
  auto ArgPackOrErr =
      Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
  if (!ArgPackOrErr)
    return ArgPackOrErr.takeError();

  return ToContext.getSubstTemplateTemplateParmPack(
      cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr);
}
}

llvm_unreachable("Invalid template name kind")::llvm::llvm_unreachable_internal("Invalid template name kind"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 8937);
8938}

8940Expected<SourceLocation> ASTImporter::Import(SourceLocation FromLoc) {
if (FromLoc.isInvalid())
  return SourceLocation{};

SourceManager &FromSM = FromContext.getSourceManager();
bool IsBuiltin = FromSM.isWrittenInBuiltinFile(FromLoc);

std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
Expected<FileID> ToFileIDOrErr = Import(Decomposed.first, IsBuiltin);
if (!ToFileIDOrErr)
  return ToFileIDOrErr.takeError();
SourceManager &ToSM = ToContext.getSourceManager();
return ToSM.getComposedLoc(*ToFileIDOrErr, Decomposed.second);
8953}

8955Expected<SourceRange> ASTImporter::Import(SourceRange FromRange) {
SourceLocation ToBegin, ToEnd;
if (Error Err = importInto(ToBegin, FromRange.getBegin()))
  return std::move(Err);
if (Error Err = importInto(ToEnd, FromRange.getEnd()))
  return std::move(Err);

return SourceRange(ToBegin, ToEnd);
8963}

8965Expected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) {
llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
if (Pos != ImportedFileIDs.end())
  return Pos->second;

SourceManager &FromSM = FromContext.getSourceManager();
SourceManager &ToSM = ToContext.getSourceManager();
const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);

// Map the FromID to the "to" source manager.
FileID ToID;
if (FromSLoc.isExpansion()) {
  const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
  ExpectedSLoc ToSpLoc = Import(FromEx.getSpellingLoc());
  if (!ToSpLoc)
    return ToSpLoc.takeError();
  ExpectedSLoc ToExLocS = Import(FromEx.getExpansionLocStart());
  if (!ToExLocS)
    return ToExLocS.takeError();
  unsigned TokenLen = FromSM.getFileIDSize(FromID);
  SourceLocation MLoc;
  if (FromEx.isMacroArgExpansion()) {
    MLoc = ToSM.createMacroArgExpansionLoc(*ToSpLoc, *ToExLocS, TokenLen);
  } else {
    if (ExpectedSLoc ToExLocE = Import(FromEx.getExpansionLocEnd()))
      MLoc = ToSM.createExpansionLoc(*ToSpLoc, *ToExLocS, *ToExLocE, TokenLen,
                                     FromEx.isExpansionTokenRange());
    else
      return ToExLocE.takeError();
  }
  ToID = ToSM.getFileID(MLoc);
} else {
  const SrcMgr::ContentCache *Cache = &FromSLoc.getFile().getContentCache();

  if (!IsBuiltin && !Cache->BufferOverridden) {
    // Include location of this file.
    ExpectedSLoc ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
    if (!ToIncludeLoc)
      return ToIncludeLoc.takeError();

    // Every FileID that is not the main FileID needs to have a valid include
    // location so that the include chain points to the main FileID. When
    // importing the main FileID (which has no include location), we need to
    // create a fake include location in the main file to keep this property
    // intact.
    SourceLocation ToIncludeLocOrFakeLoc = *ToIncludeLoc;
    if (FromID == FromSM.getMainFileID())
      ToIncludeLocOrFakeLoc = ToSM.getLocForStartOfFile(ToSM.getMainFileID());

    if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
      // FIXME: We probably want to use getVirtualFile(), so we don't hit the
      // disk again
      // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
      // than mmap the files several times.
      auto Entry =
          ToFileManager.getOptionalFileRef(Cache->OrigEntry->getName());
      // FIXME: The filename may be a virtual name that does probably not
      // point to a valid file and we get no Entry here. In this case try with
      // the memory buffer below.
      if (Entry)
        ToID = ToSM.createFileID(*Entry, ToIncludeLocOrFakeLoc,
                                 FromSLoc.getFile().getFileCharacteristic());
    }
  }

  if (ToID.isInvalid() || IsBuiltin) {
    // FIXME: We want to re-use the existing MemoryBuffer!
    llvm::Optional<llvm::MemoryBufferRef> FromBuf =
        Cache->getBufferOrNone(FromContext.getDiagnostics(),
                               FromSM.getFileManager(), SourceLocation{});
    if (!FromBuf)
      return llvm::make_error<ImportError>(ImportError::Unknown);

    std::unique_ptr<llvm::MemoryBuffer> ToBuf =
        llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
                                             FromBuf->getBufferIdentifier());
    ToID = ToSM.createFileID(std::move(ToBuf),
                             FromSLoc.getFile().getFileCharacteristic());
  }
}

assert(ToID.isValid() && "Unexpected invalid fileID was created.")(static_cast <bool> (ToID.isValid() && "Unexpected invalid fileID was created."
) ? void (0) : __assert_fail ("ToID.isValid() && \"Unexpected invalid fileID was created.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 9046, __extension__ __PRETTY_FUNCTION__));

ImportedFileIDs[FromID] = ToID;
return ToID;
9050}

9052Expected<CXXCtorInitializer *> ASTImporter::Import(CXXCtorInitializer *From) {
ExpectedExpr ToExprOrErr = Import(From->getInit());
if (!ToExprOrErr)
  return ToExprOrErr.takeError();

auto LParenLocOrErr = Import(From->getLParenLoc());
if (!LParenLocOrErr)
  return LParenLocOrErr.takeError();

auto RParenLocOrErr = Import(From->getRParenLoc());
if (!RParenLocOrErr)
  return RParenLocOrErr.takeError();

if (From->isBaseInitializer()) {
  auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
  if (!ToTInfoOrErr)
    return ToTInfoOrErr.takeError();

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

  return new (ToContext) CXXCtorInitializer(
      ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr,
      *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
} else if (From->isMemberInitializer()) {
  ExpectedDecl ToFieldOrErr = Import(From->getMember());
  if (!ToFieldOrErr)
    return ToFieldOrErr.takeError();

  auto MemberLocOrErr = Import(From->getMemberLocation());
  if (!MemberLocOrErr)
    return MemberLocOrErr.takeError();

  return new (ToContext) CXXCtorInitializer(
      ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr,
      *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
} else if (From->isIndirectMemberInitializer()) {
  ExpectedDecl ToIFieldOrErr = Import(From->getIndirectMember());
  if (!ToIFieldOrErr)
    return ToIFieldOrErr.takeError();

  auto MemberLocOrErr = Import(From->getMemberLocation());
  if (!MemberLocOrErr)
    return MemberLocOrErr.takeError();

  return new (ToContext) CXXCtorInitializer(
      ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr),
      *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
} else if (From->isDelegatingInitializer()) {
  auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
  if (!ToTInfoOrErr)
    return ToTInfoOrErr.takeError();

  return new (ToContext)
      CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr,
                         *ToExprOrErr, *RParenLocOrErr);
} else {
  // FIXME: assert?
  return make_error<ImportError>();
}
9114}

9116Expected<CXXBaseSpecifier *>
9117ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
if (Pos != ImportedCXXBaseSpecifiers.end())
  return Pos->second;

Expected<SourceRange> ToSourceRange = Import(BaseSpec->getSourceRange());
if (!ToSourceRange)
  return ToSourceRange.takeError();
Expected<TypeSourceInfo *> ToTSI = Import(BaseSpec->getTypeSourceInfo());
if (!ToTSI)
  return ToTSI.takeError();
ExpectedSLoc ToEllipsisLoc = Import(BaseSpec->getEllipsisLoc());
if (!ToEllipsisLoc)
  return ToEllipsisLoc.takeError();
CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
    *ToSourceRange, BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
    BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc);
ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
return Imported;
9136}

9138llvm::Expected<APValue> ASTImporter::Import(const APValue &FromValue) {
ASTNodeImporter Importer(*this);
return Importer.ImportAPValue(FromValue);
9141}

9143Error ASTImporter::ImportDefinition(Decl *From) {
ExpectedDecl ToOrErr = Import(From);
if (!ToOrErr)
  return ToOrErr.takeError();
Decl *To = *ToOrErr;

auto *FromDC = cast<DeclContext>(From);
ASTNodeImporter Importer(*this);

if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
  if (!ToRecord->getDefinition()) {
    return Importer.ImportDefinition(
        cast<RecordDecl>(FromDC), ToRecord,
        ASTNodeImporter::IDK_Everything);
  }
}

if (auto *ToEnum = dyn_cast<EnumDecl>(To)) {
  if (!ToEnum->getDefinition()) {
    return Importer.ImportDefinition(
        cast<EnumDecl>(FromDC), ToEnum, ASTNodeImporter::IDK_Everything);
  }
}

if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
  if (!ToIFace->getDefinition()) {
    return Importer.ImportDefinition(
        cast<ObjCInterfaceDecl>(FromDC), ToIFace,
        ASTNodeImporter::IDK_Everything);
  }
}

if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
  if (!ToProto->getDefinition()) {
    return Importer.ImportDefinition(
        cast<ObjCProtocolDecl>(FromDC), ToProto,
        ASTNodeImporter::IDK_Everything);
  }
}

return Importer.ImportDeclContext(FromDC, true);
9184}

9186Expected<DeclarationName> ASTImporter::Import(DeclarationName FromName) {
if (!FromName)
  return DeclarationName{};

switch (FromName.getNameKind()) {
case DeclarationName::Identifier:
  return DeclarationName(Import(FromName.getAsIdentifierInfo()));

case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
  if (auto ToSelOrErr = Import(FromName.getObjCSelector()))
    return DeclarationName(*ToSelOrErr);
  else
    return ToSelOrErr.takeError();

case DeclarationName::CXXConstructorName: {
  if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
    return ToContext.DeclarationNames.getCXXConstructorName(
        ToContext.getCanonicalType(*ToTyOrErr));
  else
    return ToTyOrErr.takeError();
}

case DeclarationName::CXXDestructorName: {
  if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
    return ToContext.DeclarationNames.getCXXDestructorName(
        ToContext.getCanonicalType(*ToTyOrErr));
  else
    return ToTyOrErr.takeError();
}

case DeclarationName::CXXDeductionGuideName: {
  if (auto ToTemplateOrErr = Import(FromName.getCXXDeductionGuideTemplate()))
    return ToContext.DeclarationNames.getCXXDeductionGuideName(
        cast<TemplateDecl>(*ToTemplateOrErr));
  else
    return ToTemplateOrErr.takeError();
}

case DeclarationName::CXXConversionFunctionName: {
  if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
    return ToContext.DeclarationNames.getCXXConversionFunctionName(
        ToContext.getCanonicalType(*ToTyOrErr));
  else
    return ToTyOrErr.takeError();
}

case DeclarationName::CXXOperatorName:
  return ToContext.DeclarationNames.getCXXOperatorName(
                                        FromName.getCXXOverloadedOperator());

case DeclarationName::CXXLiteralOperatorName:
  return ToContext.DeclarationNames.getCXXLiteralOperatorName(
      Import(FromName.getCXXLiteralIdentifier()));

case DeclarationName::CXXUsingDirective:
  // FIXME: STATICS!
  return DeclarationName::getUsingDirectiveName();
}

llvm_unreachable("Invalid DeclarationName Kind!")::llvm::llvm_unreachable_internal("Invalid DeclarationName Kind!"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 9247);
9248}

9250IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
if (!FromId)
  return nullptr;

IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());

if (!ToId->getBuiltinID() && FromId->getBuiltinID())
  ToId->setBuiltinID(FromId->getBuiltinID());

return ToId;
9260}

9262Expected<Selector> ASTImporter::Import(Selector FromSel) {
if (FromSel.isNull())
  return Selector{};

SmallVector<IdentifierInfo *, 4> Idents;
Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
  Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
9271}

9273llvm::Expected<APValue>
9274ASTNodeImporter::ImportAPValue(const APValue &FromValue) {
APValue Result;
llvm::Error Err = llvm::Error::success();
auto ImportLoop = [&](const APValue *From, APValue *To, unsigned Size) {
  for (unsigned Idx = 0; Idx < Size; Idx++) {
    APValue Tmp = importChecked(Err, From[Idx]);
    To[Idx] = Tmp;
  }
};
switch (FromValue.getKind()) {
case APValue::None:
case APValue::Indeterminate:
case APValue::Int:
case APValue::Float:
case APValue::FixedPoint:
case APValue::ComplexInt:
case APValue::ComplexFloat:
  Result = FromValue;
  break;
case APValue::Vector: {
  Result.MakeVector();
  MutableArrayRef<APValue> Elts =
      Result.setVectorUninit(FromValue.getVectorLength());
  ImportLoop(((const APValue::Vec *)(const char *)&FromValue.Data)->Elts,
             Elts.data(), FromValue.getVectorLength());
  break;
}
case APValue::Array:
  Result.MakeArray(FromValue.getArrayInitializedElts(),
                   FromValue.getArraySize());
  ImportLoop(((const APValue::Arr *)(const char *)&FromValue.Data)->Elts,
             ((const APValue::Arr *)(const char *)&Result.Data)->Elts,
             FromValue.getArrayInitializedElts());
  break;
case APValue::Struct:
  Result.MakeStruct(FromValue.getStructNumBases(),
                    FromValue.getStructNumFields());
  ImportLoop(
      ((const APValue::StructData *)(const char *)&FromValue.Data)->Elts,
      ((const APValue::StructData *)(const char *)&Result.Data)->Elts,
      FromValue.getStructNumBases() + FromValue.getStructNumFields());
  break;
case APValue::Union: {
  Result.MakeUnion();
  const Decl *ImpFDecl = importChecked(Err, FromValue.getUnionField());
  APValue ImpValue = importChecked(Err, FromValue.getUnionValue());
  if (Err)
    return std::move(Err);
  Result.setUnion(cast<FieldDecl>(ImpFDecl), ImpValue);
  break;
}
case APValue::AddrLabelDiff: {
  Result.MakeAddrLabelDiff();
  const Expr *ImpLHS = importChecked(Err, FromValue.getAddrLabelDiffLHS());
  const Expr *ImpRHS = importChecked(Err, FromValue.getAddrLabelDiffRHS());
  if (Err)
    return std::move(Err);
  Result.setAddrLabelDiff(cast<AddrLabelExpr>(ImpLHS),
                          cast<AddrLabelExpr>(ImpRHS));
  break;
}
case APValue::MemberPointer: {
  const Decl *ImpMemPtrDecl =
      importChecked(Err, FromValue.getMemberPointerDecl());
  if (Err)
    return std::move(Err);
  MutableArrayRef<const CXXRecordDecl *> ToPath =
      Result.setMemberPointerUninit(
          cast<const ValueDecl>(ImpMemPtrDecl),
          FromValue.isMemberPointerToDerivedMember(),
          FromValue.getMemberPointerPath().size());
  llvm::ArrayRef<const CXXRecordDecl *> FromPath =
      Result.getMemberPointerPath();
  for (unsigned Idx = 0; Idx < FromValue.getMemberPointerPath().size();
       Idx++) {
    const Decl *ImpDecl = importChecked(Err, FromPath[Idx]);
    if (Err)
      return std::move(Err);
    ToPath[Idx] = cast<const CXXRecordDecl>(ImpDecl->getCanonicalDecl());
  }
  break;
}
case APValue::LValue:
  APValue::LValueBase Base;
  QualType FromElemTy;
  if (FromValue.getLValueBase()) {
    assert(!FromValue.getLValueBase().is<DynamicAllocLValue>() &&(static_cast <bool> (!FromValue.getLValueBase().is<DynamicAllocLValue
>() && "in C++20 dynamic allocation are transient so they shouldn't "
 "appear in the AST") ? void (0) : __assert_fail ("!FromValue.getLValueBase().is<DynamicAllocLValue>() && \"in C++20 dynamic allocation are transient so they shouldn't \" \"appear in the AST\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 9362, __extension__ __PRETTY_FUNCTION__))
           "in C++20 dynamic allocation are transient so they shouldn't "(static_cast <bool> (!FromValue.getLValueBase().is<DynamicAllocLValue
>() && "in C++20 dynamic allocation are transient so they shouldn't "
 "appear in the AST") ? void (0) : __assert_fail ("!FromValue.getLValueBase().is<DynamicAllocLValue>() && \"in C++20 dynamic allocation are transient so they shouldn't \" \"appear in the AST\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 9362, __extension__ __PRETTY_FUNCTION__))
           "appear in the AST")(static_cast <bool> (!FromValue.getLValueBase().is<DynamicAllocLValue
>() && "in C++20 dynamic allocation are transient so they shouldn't "
 "appear in the AST") ? void (0) : __assert_fail ("!FromValue.getLValueBase().is<DynamicAllocLValue>() && \"in C++20 dynamic allocation are transient so they shouldn't \" \"appear in the AST\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 9362, __extension__ __PRETTY_FUNCTION__));
    if (!FromValue.getLValueBase().is<TypeInfoLValue>()) {
      if (const auto *E =
              FromValue.getLValueBase().dyn_cast<const Expr *>()) {
        FromElemTy = E->getType();
        const Expr *ImpExpr = importChecked(Err, E);
        if (Err)
          return std::move(Err);
        Base = APValue::LValueBase(ImpExpr,
                                   FromValue.getLValueBase().getCallIndex(),
                                   FromValue.getLValueBase().getVersion());
      } else {
        FromElemTy =
            FromValue.getLValueBase().get<const ValueDecl *>()->getType();
        const Decl *ImpDecl = importChecked(
            Err, FromValue.getLValueBase().get<const ValueDecl *>());
        if (Err)
          return std::move(Err);
        Base = APValue::LValueBase(cast<ValueDecl>(ImpDecl),
                                   FromValue.getLValueBase().getCallIndex(),
                                   FromValue.getLValueBase().getVersion());
      }
    } else {
      FromElemTy = FromValue.getLValueBase().getTypeInfoType();
      QualType ImpTypeInfo = importChecked(
          Err,
          QualType(FromValue.getLValueBase().get<TypeInfoLValue>().getType(),
                   0));
      QualType ImpType =
          importChecked(Err, FromValue.getLValueBase().getTypeInfoType());
      if (Err)
        return std::move(Err);
      Base = APValue::LValueBase::getTypeInfo(
          TypeInfoLValue(ImpTypeInfo.getTypePtr()), ImpType);
    }
  }
  CharUnits Offset = FromValue.getLValueOffset();
  unsigned PathLength = FromValue.getLValuePath().size();
  Result.MakeLValue();
  if (FromValue.hasLValuePath()) {
    MutableArrayRef<APValue::LValuePathEntry> ToPath = Result.setLValueUninit(
        Base, Offset, PathLength, FromValue.isLValueOnePastTheEnd(),
        FromValue.isNullPointer());
    llvm::ArrayRef<APValue::LValuePathEntry> FromPath =
        FromValue.getLValuePath();
    for (unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
      if (FromElemTy->isRecordType()) {
        const Decl *FromDecl =
            FromPath[LoopIdx].getAsBaseOrMember().getPointer();
        const Decl *ImpDecl = importChecked(Err, FromDecl);
        if (Err)
          return std::move(Err);
        if (auto *RD = dyn_cast<CXXRecordDecl>(FromDecl))
          FromElemTy = Importer.FromContext.getRecordType(RD);
        else
          FromElemTy = cast<ValueDecl>(FromDecl)->getType();
        ToPath[LoopIdx] = APValue::LValuePathEntry(APValue::BaseOrMemberType(
            ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
      } else {
        FromElemTy =
            Importer.FromContext.getAsArrayType(FromElemTy)->getElementType();
        ToPath[LoopIdx] = APValue::LValuePathEntry::ArrayIndex(
            FromPath[LoopIdx].getAsArrayIndex());
      }
    }
  } else
    Result.setLValue(Base, Offset, APValue::NoLValuePath{},
                     FromValue.isNullPointer());
}
if (Err)
  return std::move(Err);
return Result;
9434}

9436Expected<DeclarationName> ASTImporter::HandleNameConflict(DeclarationName Name,
                                                        DeclContext *DC,
                                                        unsigned IDNS,
                                                        NamedDecl **Decls,
                                                        unsigned NumDecls) {
if (ODRHandling == ODRHandlingType::Conservative)
  // Report error at any name conflict.
  return make_error<ImportError>(ImportError::NameConflict);
else
  // Allow to create the new Decl with the same name.
  return Name;
9447}

9449DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
if (LastDiagFromFrom)
  ToContext.getDiagnostics().notePriorDiagnosticFrom(
    FromContext.getDiagnostics());
LastDiagFromFrom = false;
return ToContext.getDiagnostics().Report(Loc, DiagID);
9455}

9457DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
if (!LastDiagFromFrom)
  FromContext.getDiagnostics().notePriorDiagnosticFrom(
    ToContext.getDiagnostics());
LastDiagFromFrom = true;
return FromContext.getDiagnostics().Report(Loc, DiagID);
9463}

9465void ASTImporter::CompleteDecl (Decl *D) {
if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
  if (!ID->getDefinition())
    ID->startDefinition();
}
else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
  if (!PD->getDefinition())
    PD->startDefinition();
}
else if (auto *TD = dyn_cast<TagDecl>(D)) {
  if (!TD->getDefinition() && !TD->isBeingDefined()) {
    TD->startDefinition();
    TD->setCompleteDefinition(true);
  }
}
else {
  assert(0 && "CompleteDecl called on a Decl that can't be completed")(static_cast <bool> (0 && "CompleteDecl called on a Decl that can't be completed"
) ? void (0) : __assert_fail ("0 && \"CompleteDecl called on a Decl that can't be completed\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 9481, __extension__ __PRETTY_FUNCTION__));
}
9483}

9485Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
assert((Pos == ImportedDecls.end() || Pos->second == To) &&(static_cast <bool> ((Pos == ImportedDecls.end() || Pos
->second == To) && "Try to import an already imported Decl"
) ? void (0) : __assert_fail ("(Pos == ImportedDecls.end() || Pos->second == To) && \"Try to import an already imported Decl\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 9488, __extension__ __PRETTY_FUNCTION__))
    "Try to import an already imported Decl")(static_cast <bool> ((Pos == ImportedDecls.end() || Pos
->second == To) && "Try to import an already imported Decl"
) ? void (0) : __assert_fail ("(Pos == ImportedDecls.end() || Pos->second == To) && \"Try to import an already imported Decl\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 9488, __extension__ __PRETTY_FUNCTION__));
if (Pos != ImportedDecls.end())
  return Pos->second;
ImportedDecls[From] = To;
// This mapping should be maintained only in this function. Therefore do not
// check for additional consistency.
ImportedFromDecls[To] = From;
// In the case of TypedefNameDecl we create the Decl first and only then we
// import and set its DeclContext. So, the DC is still not set when we reach
// here from GetImportedOrCreateDecl.
if (To->getDeclContext())
  AddToLookupTable(To);
return To;
9501}

9503llvm::Optional<ImportError>
9504ASTImporter::getImportDeclErrorIfAny(Decl *FromD) const {
auto Pos = ImportDeclErrors.find(FromD);
if (Pos != ImportDeclErrors.end())
  return Pos->second;
else
  return Optional<ImportError>();
9510}

9512void ASTImporter::setImportDeclError(Decl *From, ImportError Error) {
auto InsertRes = ImportDeclErrors.insert({From, Error});
(void)InsertRes;
// Either we set the error for the first time, or we already had set one and
// now we want to set the same error.
assert(InsertRes.second || InsertRes.first->second.Error == Error.Error)(static_cast <bool> (InsertRes.second || InsertRes.first
->second.Error == Error.Error) ? void (0) : __assert_fail (
"InsertRes.second || InsertRes.first->second.Error == Error.Error"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/AST/ASTImporter.cpp"
, 9517, __extension__ __PRETTY_FUNCTION__));
9518}

9520bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
                                         bool Complain) {
llvm::DenseMap<const Type *, const Type *>::iterator Pos =
    ImportedTypes.find(From.getTypePtr());
if (Pos != ImportedTypes.end()) {
  if (ExpectedType ToFromOrErr = Import(From)) {
    if (ToContext.hasSameType(*ToFromOrErr, To))
      return true;
  } else {
    llvm::consumeError(ToFromOrErr.takeError());
  }
}

StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
                                 getStructuralEquivalenceKind(*this), false,
                                 Complain);
return Ctx.IsEquivalent(From, To);
9537}

←

/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclVisitor.h

→

1//===- DeclVisitor.h - Visitor for Decl subclasses --------------*- C++ -*-===//
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 DeclVisitor interface.
10//
11//===----------------------------------------------------------------------===//
12 
13#ifndef LLVM_CLANG_AST_DECLVISITOR_H
14#define LLVM_CLANG_AST_DECLVISITOR_H
15 
16#include "clang/AST/Decl.h"
17#include "clang/AST/DeclBase.h"
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclFriend.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/DeclOpenMP.h"
22#include "clang/AST/DeclTemplate.h"
23#include "llvm/ADT/STLExtras.h"
24#include "llvm/Support/ErrorHandling.h"
25 
26namespace clang {
27 
28namespace declvisitor {
29/// A simple visitor class that helps create declaration visitors.
30template<template <typename> class Ptr, typename ImplClass, typename RetTy=void>
31class Base {
32public:
33#define PTR(CLASS) typename Ptr<CLASS>::type
34#define DISPATCH(NAME, CLASS) \
35  return static_cast<ImplClass*>(this)->Visit##NAME(static_cast<PTR(CLASS)>(D))
36 
37  RetTy Visit(PTR(Decl) D) {
38    switch (D->getKind()) {
9
←
Control jumps to 'case FunctionTemplate:'  at line 233→
39#define DECL(DERIVED, BASE) \
40      case Decl::DERIVED: DISPATCH(DERIVED##Decl, DERIVED##Decl);
41#define ABSTRACT_DECL(DECL)
42#include "clang/AST/DeclNodes.inc"
43    }
44    llvm_unreachable("Decl that isn't part of DeclNodes.inc!")::llvm::llvm_unreachable_internal("Decl that isn't part of DeclNodes.inc!"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclVisitor.h"
, 44);
45  }
46 
47  // If the implementation chooses not to implement a certain visit
48  // method, fall back to the parent.
49#define DECL(DERIVED, BASE) \
50  RetTy Visit##DERIVED##Decl(PTR(DERIVED##Decl) D) { DISPATCH(BASE, BASE); }
51#include "clang/AST/DeclNodes.inc"
52 
53  RetTy VisitDecl(PTR(Decl) D) { return RetTy(); }
54 
55#undef PTR
56#undef DISPATCH
57};
58 
59} // namespace declvisitor
60 
61/// A simple visitor class that helps create declaration visitors.
62///
63/// This class does not preserve constness of Decl pointers (see also
64/// ConstDeclVisitor).
65template <typename ImplClass, typename RetTy = void>
66class DeclVisitor
67    : public declvisitor::Base<std::add_pointer, ImplClass, RetTy> {};
68 
69/// A simple visitor class that helps create declaration visitors.
70///
71/// This class preserves constness of Decl pointers (see also DeclVisitor).
72template <typename ImplClass, typename RetTy = void>
73class ConstDeclVisitor
74    : public declvisitor::Base<llvm::make_const_ptr, ImplClass, RetTy> {};
75 
76} // namespace clang
77 
78#endif // LLVM_CLANG_AST_DECLVISITOR_H

←

/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/include/clang/AST/DeclNodes.inc

→

1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|*                                                                            *|
3|* List of AST nodes of a particular kind                                     *|
4|*                                                                            *|
5|* Automatically generated file, do not edit!                                 *|
6|*                                                                            *|
7\*===----------------------------------------------------------------------===*/
8 
9#ifndef ABSTRACT_DECL
10#  define ABSTRACT_DECL(Type) Type
11#endif
12#ifndef DECL_RANGE
13#  define DECL_RANGE(Base, First, Last)
14#endif
15 
16#ifndef LAST_DECL_RANGE
17#  define LAST_DECL_RANGE(Base, First, Last) DECL_RANGE(Base, First, Last)
18#endif
19 
20#ifndef ACCESSSPEC
21#  define ACCESSSPEC(Type, Base) DECL(Type, Base)
22#endif
23ACCESSSPEC(AccessSpec, Decl)
24#undef ACCESSSPEC
25 
26#ifndef BLOCK
27#  define BLOCK(Type, Base) DECL(Type, Base)
28#endif
29BLOCK(Block, Decl)
30#undef BLOCK
31 
32#ifndef CAPTURED
33#  define CAPTURED(Type, Base) DECL(Type, Base)
34#endif
35CAPTURED(Captured, Decl)
36#undef CAPTURED
37 
38#ifndef CLASSSCOPEFUNCTIONSPECIALIZATION
39#  define CLASSSCOPEFUNCTIONSPECIALIZATION(Type, Base) DECL(Type, Base)
40#endif
41CLASSSCOPEFUNCTIONSPECIALIZATION(ClassScopeFunctionSpecialization, Decl)
42#undef CLASSSCOPEFUNCTIONSPECIALIZATION
43 
44#ifndef EMPTY
45#  define EMPTY(Type, Base) DECL(Type, Base)
46#endif
47EMPTY(Empty, Decl)
48#undef EMPTY
49 
50#ifndef EXPORT
51#  define EXPORT(Type, Base) DECL(Type, Base)
52#endif
53EXPORT(Export, Decl)
54#undef EXPORT
55 
56#ifndef EXTERNCCONTEXT
57#  define EXTERNCCONTEXT(Type, Base) DECL(Type, Base)
58#endif
59EXTERNCCONTEXT(ExternCContext, Decl)
60#undef EXTERNCCONTEXT
61 
62#ifndef FILESCOPEASM
63#  define FILESCOPEASM(Type, Base) DECL(Type, Base)
64#endif
65FILESCOPEASM(FileScopeAsm, Decl)
66#undef FILESCOPEASM
67 
68#ifndef FRIEND
69#  define FRIEND(Type, Base) DECL(Type, Base)
70#endif
71FRIEND(Friend, Decl)
72#undef FRIEND
73 
74#ifndef FRIENDTEMPLATE
75#  define FRIENDTEMPLATE(Type, Base) DECL(Type, Base)
76#endif
77FRIENDTEMPLATE(FriendTemplate, Decl)
78#undef FRIENDTEMPLATE
79 
80#ifndef IMPORT
81#  define IMPORT(Type, Base) DECL(Type, Base)
82#endif
83IMPORT(Import, Decl)
84#undef IMPORT
85 
86#ifndef LIFETIMEEXTENDEDTEMPORARY
87#  define LIFETIMEEXTENDEDTEMPORARY(Type, Base) DECL(Type, Base)
88#endif
89LIFETIMEEXTENDEDTEMPORARY(LifetimeExtendedTemporary, Decl)
90#undef LIFETIMEEXTENDEDTEMPORARY
91 
92#ifndef LINKAGESPEC
93#  define LINKAGESPEC(Type, Base) DECL(Type, Base)
94#endif
95LINKAGESPEC(LinkageSpec, Decl)
96#undef LINKAGESPEC
97 
98#ifndef NAMED
99#  define NAMED(Type, Base) DECL(Type, Base)
100#endif
101ABSTRACT_DECL(NAMED(Named, Decl))
102#ifndef BASEUSING
103#  define BASEUSING(Type, Base) NAMED(Type, Base)
104#endif
105ABSTRACT_DECL(BASEUSING(BaseUsing, NamedDecl))
106#ifndef USING
107#  define USING(Type, Base) BASEUSING(Type, Base)
108#endif
109USING(Using, BaseUsingDecl)
110#undef USING
111 
112#ifndef USINGENUM
113#  define USINGENUM(Type, Base) BASEUSING(Type, Base)
114#endif
115USINGENUM(UsingEnum, BaseUsingDecl)
116#undef USINGENUM
117 
118DECL_RANGE(BaseUsing, Using, UsingEnum)
119 
120#undef BASEUSING
121 
122#ifndef LABEL
123#  define LABEL(Type, Base) NAMED(Type, Base)
124#endif
125LABEL(Label, NamedDecl)
126#undef LABEL
127 
128#ifndef NAMESPACE
129#  define NAMESPACE(Type, Base) NAMED(Type, Base)
130#endif
131NAMESPACE(Namespace, NamedDecl)
132#undef NAMESPACE
133 
134#ifndef NAMESPACEALIAS
135#  define NAMESPACEALIAS(Type, Base) NAMED(Type, Base)
136#endif
137NAMESPACEALIAS(NamespaceAlias, NamedDecl)
138#undef NAMESPACEALIAS
139 
140#ifndef OBJCCOMPATIBLEALIAS
141#  define OBJCCOMPATIBLEALIAS(Type, Base) NAMED(Type, Base)
142#endif
143OBJCCOMPATIBLEALIAS(ObjCCompatibleAlias, NamedDecl)
144#undef OBJCCOMPATIBLEALIAS
145 
146#ifndef OBJCCONTAINER
147#  define OBJCCONTAINER(Type, Base) NAMED(Type, Base)
148#endif
149ABSTRACT_DECL(OBJCCONTAINER(ObjCContainer, NamedDecl))
150#ifndef OBJCCATEGORY
151#  define OBJCCATEGORY(Type, Base) OBJCCONTAINER(Type, Base)
152#endif
153OBJCCATEGORY(ObjCCategory, ObjCContainerDecl)
154#undef OBJCCATEGORY
155 
156#ifndef OBJCIMPL
157#  define OBJCIMPL(Type, Base) OBJCCONTAINER(Type, Base)
158#endif
159ABSTRACT_DECL(OBJCIMPL(ObjCImpl, ObjCContainerDecl))
160#ifndef OBJCCATEGORYIMPL
161#  define OBJCCATEGORYIMPL(Type, Base) OBJCIMPL(Type, Base)
162#endif
163OBJCCATEGORYIMPL(ObjCCategoryImpl, ObjCImplDecl)
164#undef OBJCCATEGORYIMPL
165 
166#ifndef OBJCIMPLEMENTATION
167#  define OBJCIMPLEMENTATION(Type, Base) OBJCIMPL(Type, Base)
168#endif
169OBJCIMPLEMENTATION(ObjCImplementation, ObjCImplDecl)
170#undef OBJCIMPLEMENTATION
171 
172DECL_RANGE(ObjCImpl, ObjCCategoryImpl, ObjCImplementation)
173 
174#undef OBJCIMPL
175 
176#ifndef OBJCINTERFACE
177#  define OBJCINTERFACE(Type, Base) OBJCCONTAINER(Type, Base)
178#endif
179OBJCINTERFACE(ObjCInterface, ObjCContainerDecl)
180#undef OBJCINTERFACE
181 
182#ifndef OBJCPROTOCOL
183#  define OBJCPROTOCOL(Type, Base) OBJCCONTAINER(Type, Base)
184#endif
185OBJCPROTOCOL(ObjCProtocol, ObjCContainerDecl)
186#undef OBJCPROTOCOL
187 
188DECL_RANGE(ObjCContainer, ObjCCategory, ObjCProtocol)
189 
190#undef OBJCCONTAINER
191 
192#ifndef OBJCMETHOD
193#  define OBJCMETHOD(Type, Base) NAMED(Type, Base)
194#endif
195OBJCMETHOD(ObjCMethod, NamedDecl)
196#undef OBJCMETHOD
197 
198#ifndef OBJCPROPERTY
199#  define OBJCPROPERTY(Type, Base) NAMED(Type, Base)
200#endif
201OBJCPROPERTY(ObjCProperty, NamedDecl)
202#undef OBJCPROPERTY
203 
204#ifndef TEMPLATE
205#  define TEMPLATE(Type, Base) NAMED(Type, Base)
206#endif
207ABSTRACT_DECL(TEMPLATE(Template, NamedDecl))
208#ifndef BUILTINTEMPLATE
209#  define BUILTINTEMPLATE(Type, Base) TEMPLATE(Type, Base)
210#endif
211BUILTINTEMPLATE(BuiltinTemplate, TemplateDecl)
212#undef BUILTINTEMPLATE
213 
214#ifndef CONCEPT
215#  define CONCEPT(Type, Base) TEMPLATE(Type, Base)
216#endif
217CONCEPT(Concept, TemplateDecl)
218#undef CONCEPT
219 
220#ifndef REDECLARABLETEMPLATE
221#  define REDECLARABLETEMPLATE(Type, Base) TEMPLATE(Type, Base)
222#endif
223ABSTRACT_DECL(REDECLARABLETEMPLATE(RedeclarableTemplate, TemplateDecl))
224#ifndef CLASSTEMPLATE
225#  define CLASSTEMPLATE(Type, Base) REDECLARABLETEMPLATE(Type, Base)
226#endif
227CLASSTEMPLATE(ClassTemplate, RedeclarableTemplateDecl)
228#undef CLASSTEMPLATE
229 
230#ifndef FUNCTIONTEMPLATE
231#  define FUNCTIONTEMPLATE(Type, Base) REDECLARABLETEMPLATE(Type, Base)
232#endif
233FUNCTIONTEMPLATE(FunctionTemplate, RedeclarableTemplateDecl)
10
←
Calling 'ASTNodeImporter::VisitFunctionTemplateDecl'→
234#undef FUNCTIONTEMPLATE
235 
236#ifndef TYPEALIASTEMPLATE
237#  define TYPEALIASTEMPLATE(Type, Base) REDECLARABLETEMPLATE(Type, Base)
238#endif
239TYPEALIASTEMPLATE(TypeAliasTemplate, RedeclarableTemplateDecl)
240#undef TYPEALIASTEMPLATE
241 
242#ifndef VARTEMPLATE
243#  define VARTEMPLATE(Type, Base) REDECLARABLETEMPLATE(Type, Base)
244#endif
245VARTEMPLATE(VarTemplate, RedeclarableTemplateDecl)
246#undef VARTEMPLATE
247 
248DECL_RANGE(RedeclarableTemplate, ClassTemplate, VarTemplate)
249 
250#undef REDECLARABLETEMPLATE
251 
252#ifndef TEMPLATETEMPLATEPARM
253#  define TEMPLATETEMPLATEPARM(Type, Base) TEMPLATE(Type, Base)
254#endif
255TEMPLATETEMPLATEPARM(TemplateTemplateParm, TemplateDecl)
256#undef TEMPLATETEMPLATEPARM
257 
258DECL_RANGE(Template, BuiltinTemplate, TemplateTemplateParm)
259 
260#undef TEMPLATE
261 
262#ifndef TYPE
263#  define TYPE(Type, Base) NAMED(Type, Base)
264#endif
265ABSTRACT_DECL(TYPE(Type, NamedDecl))
266#ifndef TAG
267#  define TAG(Type, Base) TYPE(Type, Base)
268#endif
269ABSTRACT_DECL(TAG(Tag, TypeDecl))
270#ifndef ENUM
271#  define ENUM(Type, Base) TAG(Type, Base)
272#endif
273ENUM(Enum, TagDecl)
274#undef ENUM
275 
276#ifndef RECORD
277#  define RECORD(Type, Base) TAG(Type, Base)
278#endif
279RECORD(Record, TagDecl)
280#ifndef CXXRECORD
281#  define CXXRECORD(Type, Base) RECORD(Type, Base)
282#endif
283CXXRECORD(CXXRecord, RecordDecl)
284#ifndef CLASSTEMPLATESPECIALIZATION
285#  define CLASSTEMPLATESPECIALIZATION(Type, Base) CXXRECORD(Type, Base)
286#endif
287CLASSTEMPLATESPECIALIZATION(ClassTemplateSpecialization, CXXRecordDecl)
288#ifndef CLASSTEMPLATEPARTIALSPECIALIZATION
289#  define CLASSTEMPLATEPARTIALSPECIALIZATION(Type, Base) CLASSTEMPLATESPECIALIZATION(Type, Base)
290#endif
291CLASSTEMPLATEPARTIALSPECIALIZATION(ClassTemplatePartialSpecialization, ClassTemplateSpecializationDecl)
292#undef CLASSTEMPLATEPARTIALSPECIALIZATION
293 
294DECL_RANGE(ClassTemplateSpecialization, ClassTemplateSpecialization, ClassTemplatePartialSpecialization)
295 
296#undef CLASSTEMPLATESPECIALIZATION
297 
298DECL_RANGE(CXXRecord, CXXRecord, ClassTemplatePartialSpecialization)
299 
300#undef CXXRECORD
301 
302DECL_RANGE(Record, Record, ClassTemplatePartialSpecialization)
303 
304#undef RECORD
305 
306DECL_RANGE(Tag, Enum, ClassTemplatePartialSpecialization)
307 
308#undef TAG
309 
310#ifndef TEMPLATETYPEPARM
311#  define TEMPLATETYPEPARM(Type, Base) TYPE(Type, Base)
312#endif
313TEMPLATETYPEPARM(TemplateTypeParm, TypeDecl)
314#undef TEMPLATETYPEPARM
315 
316#ifndef TYPEDEFNAME
317#  define TYPEDEFNAME(Type, Base) TYPE(Type, Base)
318#endif
319ABSTRACT_DECL(TYPEDEFNAME(TypedefName, TypeDecl))
320#ifndef OBJCTYPEPARAM
321#  define OBJCTYPEPARAM(Type, Base) TYPEDEFNAME(Type, Base)
322#endif
323OBJCTYPEPARAM(ObjCTypeParam, TypedefNameDecl)
324#undef OBJCTYPEPARAM
325 
326#ifndef TYPEALIAS
327#  define TYPEALIAS(Type, Base) TYPEDEFNAME(Type, Base)
328#endif
329TYPEALIAS(TypeAlias, TypedefNameDecl)
330#undef TYPEALIAS
331 
332#ifndef TYPEDEF
333#  define TYPEDEF(Type, Base) TYPEDEFNAME(Type, Base)
334#endif
335TYPEDEF(Typedef, TypedefNameDecl)
336#undef TYPEDEF
337 
338DECL_RANGE(TypedefName, ObjCTypeParam, Typedef)
339 
340#undef TYPEDEFNAME
341 
342#ifndef UNRESOLVEDUSINGTYPENAME
343#  define UNRESOLVEDUSINGTYPENAME(Type, Base) TYPE(Type, Base)
344#endif
345UNRESOLVEDUSINGTYPENAME(UnresolvedUsingTypename, TypeDecl)
346#undef UNRESOLVEDUSINGTYPENAME
347 
348DECL_RANGE(Type, Enum, UnresolvedUsingTypename)
349 
350#undef TYPE
351 
352#ifndef UNRESOLVEDUSINGIFEXISTS
353#  define UNRESOLVEDUSINGIFEXISTS(Type, Base) NAMED(Type, Base)
354#endif
355UNRESOLVEDUSINGIFEXISTS(UnresolvedUsingIfExists, NamedDecl)
356#undef UNRESOLVEDUSINGIFEXISTS
357 
358#ifndef USINGDIRECTIVE
359#  define USINGDIRECTIVE(Type, Base) NAMED(Type, Base)
360#endif
361USINGDIRECTIVE(UsingDirective, NamedDecl)
362#undef USINGDIRECTIVE
363 
364#ifndef USINGPACK
365#  define USINGPACK(Type, Base) NAMED(Type, Base)
366#endif
367USINGPACK(UsingPack, NamedDecl)
368#undef USINGPACK
369 
370#ifndef USINGSHADOW
371#  define USINGSHADOW(Type, Base) NAMED(Type, Base)
372#endif
373USINGSHADOW(UsingShadow, NamedDecl)
374#ifndef CONSTRUCTORUSINGSHADOW
375#  define CONSTRUCTORUSINGSHADOW(Type, Base) USINGSHADOW(Type, Base)
376#endif
377CONSTRUCTORUSINGSHADOW(ConstructorUsingShadow, UsingShadowDecl)
378#undef CONSTRUCTORUSINGSHADOW
379 
380DECL_RANGE(UsingShadow, UsingShadow, ConstructorUsingShadow)
381 
382#undef USINGSHADOW
383 
384#ifndef VALUE
385#  define VALUE(Type, Base) NAMED(Type, Base)
386#endif
387ABSTRACT_DECL(VALUE(Value, NamedDecl))
388#ifndef BINDING
389#  define BINDING(Type, Base) VALUE(Type, Base)
390#endif
391BINDING(Binding, ValueDecl)
392#undef BINDING
393 
394#ifndef DECLARATOR
395#  define DECLARATOR(Type, Base) VALUE(Type, Base)
396#endif
397ABSTRACT_DECL(DECLARATOR(Declarator, ValueDecl))
398#ifndef FIELD
399#  define FIELD(Type, Base) DECLARATOR(Type, Base)
400#endif
401FIELD(Field, DeclaratorDecl)
402#ifndef OBJCATDEFSFIELD
403#  define OBJCATDEFSFIELD(Type, Base) FIELD(Type, Base)
404#endif
405OBJCATDEFSFIELD(ObjCAtDefsField, FieldDecl)
406#undef OBJCATDEFSFIELD
407 
408#ifndef OBJCIVAR
409#  define OBJCIVAR(Type, Base) FIELD(Type, Base)
410#endif
411OBJCIVAR(ObjCIvar, FieldDecl)
412#undef OBJCIVAR
413 
414DECL_RANGE(Field, Field, ObjCIvar)
415 
416#undef FIELD
417 
418#ifndef FUNCTION
419#  define FUNCTION(Type, Base) DECLARATOR(Type, Base)
420#endif
421FUNCTION(Function, DeclaratorDecl)
422#ifndef CXXDEDUCTIONGUIDE
423#  define CXXDEDUCTIONGUIDE(Type, Base) FUNCTION(Type, Base)
424#endif
425CXXDEDUCTIONGUIDE(CXXDeductionGuide, FunctionDecl)
426#undef CXXDEDUCTIONGUIDE
427 
428#ifndef CXXMETHOD
429#  define CXXMETHOD(Type, Base) FUNCTION(Type, Base)
430#endif
431CXXMETHOD(CXXMethod, FunctionDecl)
432#ifndef CXXCONSTRUCTOR
433#  define CXXCONSTRUCTOR(Type, Base) CXXMETHOD(Type, Base)
434#endif
435CXXCONSTRUCTOR(CXXConstructor, CXXMethodDecl)
436#undef CXXCONSTRUCTOR
437 
438#ifndef CXXCONVERSION
439#  define CXXCONVERSION(Type, Base) CXXMETHOD(Type, Base)
440#endif
441CXXCONVERSION(CXXConversion, CXXMethodDecl)
442#undef CXXCONVERSION
443 
444#ifndef CXXDESTRUCTOR
445#  define CXXDESTRUCTOR(Type, Base) CXXMETHOD(Type, Base)
446#endif
447CXXDESTRUCTOR(CXXDestructor, CXXMethodDecl)
448#undef CXXDESTRUCTOR
449 
450DECL_RANGE(CXXMethod, CXXMethod, CXXDestructor)
451 
452#undef CXXMETHOD
453 
454DECL_RANGE(Function, Function, CXXDestructor)
455 
456#undef FUNCTION
457 
458#ifndef MSPROPERTY
459#  define MSPROPERTY(Type, Base) DECLARATOR(Type, Base)
460#endif
461MSPROPERTY(MSProperty, DeclaratorDecl)
462#undef MSPROPERTY
463 
464#ifndef NONTYPETEMPLATEPARM
465#  define NONTYPETEMPLATEPARM(Type, Base) DECLARATOR(Type, Base)
466#endif
467NONTYPETEMPLATEPARM(NonTypeTemplateParm, DeclaratorDecl)
468#undef NONTYPETEMPLATEPARM
469 
470#ifndef VAR
471#  define VAR(Type, Base) DECLARATOR(Type, Base)
472#endif
473VAR(Var, DeclaratorDecl)
474#ifndef DECOMPOSITION
475#  define DECOMPOSITION(Type, Base) VAR(Type, Base)
476#endif
477DECOMPOSITION(Decomposition, VarDecl)
478#undef DECOMPOSITION
479 
480#ifndef IMPLICITPARAM
481#  define IMPLICITPARAM(Type, Base) VAR(Type, Base)
482#endif
483IMPLICITPARAM(ImplicitParam, VarDecl)
484#undef IMPLICITPARAM
485 
486#ifndef OMPCAPTUREDEXPR
487#  define OMPCAPTUREDEXPR(Type, Base) VAR(Type, Base)
488#endif
489OMPCAPTUREDEXPR(OMPCapturedExpr, VarDecl)
490#undef OMPCAPTUREDEXPR
491 
492#ifndef PARMVAR
493#  define PARMVAR(Type, Base) VAR(Type, Base)
494#endif
495PARMVAR(ParmVar, VarDecl)
496#undef PARMVAR
497 
498#ifndef VARTEMPLATESPECIALIZATION
499#  define VARTEMPLATESPECIALIZATION(Type, Base) VAR(Type, Base)
500#endif
501VARTEMPLATESPECIALIZATION(VarTemplateSpecialization, VarDecl)
502#ifndef VARTEMPLATEPARTIALSPECIALIZATION
503#  define VARTEMPLATEPARTIALSPECIALIZATION(Type, Base) VARTEMPLATESPECIALIZATION(Type, Base)
504#endif
505VARTEMPLATEPARTIALSPECIALIZATION(VarTemplatePartialSpecialization, VarTemplateSpecializationDecl)
506#undef VARTEMPLATEPARTIALSPECIALIZATION
507 
508DECL_RANGE(VarTemplateSpecialization, VarTemplateSpecialization, VarTemplatePartialSpecialization)
509 
510#undef VARTEMPLATESPECIALIZATION
511 
512DECL_RANGE(Var, Var, VarTemplatePartialSpecialization)
513 
514#undef VAR
515 
516DECL_RANGE(Declarator, Field, VarTemplatePartialSpecialization)
517 
518#undef DECLARATOR
519 
520#ifndef ENUMCONSTANT
521#  define ENUMCONSTANT(Type, Base) VALUE(Type, Base)
522#endif
523ENUMCONSTANT(EnumConstant, ValueDecl)
524#undef ENUMCONSTANT
525 
526#ifndef INDIRECTFIELD
527#  define INDIRECTFIELD(Type, Base) VALUE(Type, Base)
528#endif
529INDIRECTFIELD(IndirectField, ValueDecl)
530#undef INDIRECTFIELD
531 
532#ifndef MSGUID
533#  define MSGUID(Type, Base) VALUE(Type, Base)
534#endif
535MSGUID(MSGuid, ValueDecl)
536#undef MSGUID
537 
538#ifndef OMPDECLAREMAPPER
539#  define OMPDECLAREMAPPER(Type, Base) VALUE(Type, Base)
540#endif
541OMPDECLAREMAPPER(OMPDeclareMapper, ValueDecl)
542#undef OMPDECLAREMAPPER
543 
544#ifndef OMPDECLAREREDUCTION
545#  define OMPDECLAREREDUCTION(Type, Base) VALUE(Type, Base)
546#endif
547OMPDECLAREREDUCTION(OMPDeclareReduction, ValueDecl)
548#undef OMPDECLAREREDUCTION
549 
550#ifndef TEMPLATEPARAMOBJECT
551#  define TEMPLATEPARAMOBJECT(Type, Base) VALUE(Type, Base)
552#endif
553TEMPLATEPARAMOBJECT(TemplateParamObject, ValueDecl)
554#undef TEMPLATEPARAMOBJECT
555 
556#ifndef UNRESOLVEDUSINGVALUE
557#  define UNRESOLVEDUSINGVALUE(Type, Base) VALUE(Type, Base)
558#endif
559UNRESOLVEDUSINGVALUE(UnresolvedUsingValue, ValueDecl)
560#undef UNRESOLVEDUSINGVALUE
561 
562DECL_RANGE(Value, Binding, UnresolvedUsingValue)
563 
564#undef VALUE
565 
566DECL_RANGE(Named, Using, UnresolvedUsingValue)
567 
568#undef NAMED
569 
570#ifndef OMPALLOCATE
571#  define OMPALLOCATE(Type, Base) DECL(Type, Base)
572#endif
573OMPALLOCATE(OMPAllocate, Decl)
574#undef OMPALLOCATE
575 
576#ifndef OMPREQUIRES
577#  define OMPREQUIRES(Type, Base) DECL(Type, Base)
578#endif
579OMPREQUIRES(OMPRequires, Decl)
580#undef OMPREQUIRES
581 
582#ifndef OMPTHREADPRIVATE
583#  define OMPTHREADPRIVATE(Type, Base) DECL(Type, Base)
584#endif
585OMPTHREADPRIVATE(OMPThreadPrivate, Decl)
586#undef OMPTHREADPRIVATE
587 
588#ifndef OBJCPROPERTYIMPL
589#  define OBJCPROPERTYIMPL(Type, Base) DECL(Type, Base)
590#endif
591OBJCPROPERTYIMPL(ObjCPropertyImpl, Decl)
592#undef OBJCPROPERTYIMPL
593 
594#ifndef PRAGMACOMMENT
595#  define PRAGMACOMMENT(Type, Base) DECL(Type, Base)
596#endif
597PRAGMACOMMENT(PragmaComment, Decl)
598#undef PRAGMACOMMENT
599 
600#ifndef PRAGMADETECTMISMATCH
601#  define PRAGMADETECTMISMATCH(Type, Base) DECL(Type, Base)
602#endif
603PRAGMADETECTMISMATCH(PragmaDetectMismatch, Decl)
604#undef PRAGMADETECTMISMATCH
605 
606#ifndef REQUIRESEXPRBODY
607#  define REQUIRESEXPRBODY(Type, Base) DECL(Type, Base)
608#endif
609REQUIRESEXPRBODY(RequiresExprBody, Decl)
610#undef REQUIRESEXPRBODY
611 
612#ifndef STATICASSERT
613#  define STATICASSERT(Type, Base) DECL(Type, Base)
614#endif
615STATICASSERT(StaticAssert, Decl)
616#undef STATICASSERT
617 
618#ifndef TRANSLATIONUNIT
619#  define TRANSLATIONUNIT(Type, Base) DECL(Type, Base)
620#endif
621TRANSLATIONUNIT(TranslationUnit, Decl)
622#undef TRANSLATIONUNIT
623 
624LAST_DECL_RANGE(Decl, AccessSpec, TranslationUnit)
625 
626#undef DECL
627#undef DECL_RANGE
628#undef LAST_DECL_RANGE
629#undef ABSTRACT_DECL
630/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
631|*                                                                            *|
632|* List of AST Decl nodes                                                     *|
633|*                                                                            *|
634|* Automatically generated file, do not edit!                                 *|
635|*                                                                            *|
636\*===----------------------------------------------------------------------===*/
637 
638#ifndef DECL_CONTEXT
639#  define DECL_CONTEXT(DECL)
640#endif
641#ifndef DECL_CONTEXT_BASE
642#  define DECL_CONTEXT_BASE(DECL) DECL_CONTEXT(DECL)
643#endif
644DECL_CONTEXT_BASE(Function)
645DECL_CONTEXT_BASE(Tag)
646DECL_CONTEXT_BASE(ObjCContainer)
647DECL_CONTEXT(Block)
648DECL_CONTEXT(Captured)
649DECL_CONTEXT(Export)
650DECL_CONTEXT(ExternCContext)
651DECL_CONTEXT(LinkageSpec)
652DECL_CONTEXT(Namespace)
653DECL_CONTEXT(OMPDeclareMapper)
654DECL_CONTEXT(OMPDeclareReduction)
655DECL_CONTEXT(ObjCMethod)
656DECL_CONTEXT(RequiresExprBody)
657DECL_CONTEXT(TranslationUnit)
658#undef DECL_CONTEXT
659#undef DECL_CONTEXT_BASE

←

/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h

→

1//===- DeclBase.h - Base Classes for representing declarations --*- C++ -*-===//
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 Decl and DeclContext interfaces.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_AST_DECLBASE_H
14#define LLVM_CLANG_AST_DECLBASE_H

16#include "clang/AST/ASTDumperUtils.h"
17#include "clang/AST/AttrIterator.h"
18#include "clang/AST/DeclarationName.h"
19#include "clang/Basic/IdentifierTable.h"
20#include "clang/Basic/LLVM.h"
21#include "clang/Basic/SourceLocation.h"
22#include "clang/Basic/Specifiers.h"
23#include "llvm/ADT/ArrayRef.h"
24#include "llvm/ADT/PointerIntPair.h"
25#include "llvm/ADT/PointerUnion.h"
26#include "llvm/ADT/iterator.h"
27#include "llvm/ADT/iterator_range.h"
28#include "llvm/Support/Casting.h"
29#include "llvm/Support/Compiler.h"
30#include "llvm/Support/PrettyStackTrace.h"
31#include "llvm/Support/VersionTuple.h"
32#include <algorithm>
33#include <cassert>
34#include <cstddef>
35#include <iterator>
36#include <string>
37#include <type_traits>
38#include <utility>

40namespace clang {

42class ASTContext;
43class ASTMutationListener;
44class Attr;
45class BlockDecl;
46class DeclContext;
47class ExternalSourceSymbolAttr;
48class FunctionDecl;
49class FunctionType;
50class IdentifierInfo;
51enum Linkage : unsigned char;
52class LinkageSpecDecl;
53class Module;
54class NamedDecl;
55class ObjCCategoryDecl;
56class ObjCCategoryImplDecl;
57class ObjCContainerDecl;
58class ObjCImplDecl;
59class ObjCImplementationDecl;
60class ObjCInterfaceDecl;
61class ObjCMethodDecl;
62class ObjCProtocolDecl;
63struct PrintingPolicy;
64class RecordDecl;
65class SourceManager;
66class Stmt;
67class StoredDeclsMap;
68class TemplateDecl;
69class TemplateParameterList;
70class TranslationUnitDecl;
71class UsingDirectiveDecl;

73/// Captures the result of checking the availability of a
74/// declaration.
75enum AvailabilityResult {
AR_Available = 0,
AR_NotYetIntroduced,
AR_Deprecated,
AR_Unavailable
80};

82/// Decl - This represents one declaration (or definition), e.g. a variable,
83/// typedef, function, struct, etc.
84///
85/// Note: There are objects tacked on before the *beginning* of Decl
86/// (and its subclasses) in its Decl::operator new(). Proper alignment
87/// of all subclasses (not requiring more than the alignment of Decl) is
88/// asserted in DeclBase.cpp.
89class alignas(8) Decl {
90public:
/// Lists the kind of concrete classes of Decl.
enum Kind {
93#define DECL(DERIVED, BASE) DERIVED,
94#define ABSTRACT_DECL(DECL)
95#define DECL_RANGE(BASE, START, END) \
      first##BASE = START, last##BASE = END,
97#define LAST_DECL_RANGE(BASE, START, END) \
      first##BASE = START, last##BASE = END
99#include "clang/AST/DeclNodes.inc"
};

/// A placeholder type used to construct an empty shell of a
/// decl-derived type that will be filled in later (e.g., by some
/// deserialization method).
struct EmptyShell {};

/// IdentifierNamespace - The different namespaces in which
/// declarations may appear.  According to C99 6.2.3, there are
/// four namespaces, labels, tags, members and ordinary
/// identifiers.  C++ describes lookup completely differently:
/// certain lookups merely "ignore" certain kinds of declarations,
/// usually based on whether the declaration is of a type, etc.
///
/// These are meant as bitmasks, so that searches in
/// C++ can look into the "tag" namespace during ordinary lookup.
///
/// Decl currently provides 15 bits of IDNS bits.
enum IdentifierNamespace {
  /// Labels, declared with 'x:' and referenced with 'goto x'.
  IDNS_Label               = 0x0001,

  /// Tags, declared with 'struct foo;' and referenced with
  /// 'struct foo'.  All tags are also types.  This is what
  /// elaborated-type-specifiers look for in C.
  /// This also contains names that conflict with tags in the
  /// same scope but that are otherwise ordinary names (non-type
  /// template parameters and indirect field declarations).
  IDNS_Tag                 = 0x0002,

  /// Types, declared with 'struct foo', typedefs, etc.
  /// This is what elaborated-type-specifiers look for in C++,
  /// but note that it's ill-formed to find a non-tag.
  IDNS_Type                = 0x0004,

  /// Members, declared with object declarations within tag
  /// definitions.  In C, these can only be found by "qualified"
  /// lookup in member expressions.  In C++, they're found by
  /// normal lookup.
  IDNS_Member              = 0x0008,

  /// Namespaces, declared with 'namespace foo {}'.
  /// Lookup for nested-name-specifiers find these.
  IDNS_Namespace           = 0x0010,

  /// Ordinary names.  In C, everything that's not a label, tag,
  /// member, or function-local extern ends up here.
  IDNS_Ordinary            = 0x0020,

  /// Objective C \@protocol.
  IDNS_ObjCProtocol        = 0x0040,

  /// This declaration is a friend function.  A friend function
  /// declaration is always in this namespace but may also be in
  /// IDNS_Ordinary if it was previously declared.
  IDNS_OrdinaryFriend      = 0x0080,

  /// This declaration is a friend class.  A friend class
  /// declaration is always in this namespace but may also be in
  /// IDNS_Tag|IDNS_Type if it was previously declared.
  IDNS_TagFriend           = 0x0100,

  /// This declaration is a using declaration.  A using declaration
  /// *introduces* a number of other declarations into the current
  /// scope, and those declarations use the IDNS of their targets,
  /// but the actual using declarations go in this namespace.
  IDNS_Using               = 0x0200,

  /// This declaration is a C++ operator declared in a non-class
  /// context.  All such operators are also in IDNS_Ordinary.
  /// C++ lexical operator lookup looks for these.
  IDNS_NonMemberOperator   = 0x0400,

  /// This declaration is a function-local extern declaration of a
  /// variable or function. This may also be IDNS_Ordinary if it
  /// has been declared outside any function. These act mostly like
  /// invisible friend declarations, but are also visible to unqualified
  /// lookup within the scope of the declaring function.
  IDNS_LocalExtern         = 0x0800,

  /// This declaration is an OpenMP user defined reduction construction.
  IDNS_OMPReduction        = 0x1000,

  /// This declaration is an OpenMP user defined mapper.
  IDNS_OMPMapper           = 0x2000,
};

/// ObjCDeclQualifier - 'Qualifiers' written next to the return and
/// parameter types in method declarations.  Other than remembering
/// them and mangling them into the method's signature string, these
/// are ignored by the compiler; they are consumed by certain
/// remote-messaging frameworks.
///
/// in, inout, and out are mutually exclusive and apply only to
/// method parameters.  bycopy and byref are mutually exclusive and
/// apply only to method parameters (?).  oneway applies only to
/// results.  All of these expect their corresponding parameter to
/// have a particular type.  None of this is currently enforced by
/// clang.
///
/// This should be kept in sync with ObjCDeclSpec::ObjCDeclQualifier.
enum ObjCDeclQualifier {
  OBJC_TQ_None = 0x0,
  OBJC_TQ_In = 0x1,
  OBJC_TQ_Inout = 0x2,
  OBJC_TQ_Out = 0x4,
  OBJC_TQ_Bycopy = 0x8,
  OBJC_TQ_Byref = 0x10,
  OBJC_TQ_Oneway = 0x20,

  /// The nullability qualifier is set when the nullability of the
  /// result or parameter was expressed via a context-sensitive
  /// keyword.
  OBJC_TQ_CSNullability = 0x40
};

/// The kind of ownership a declaration has, for visibility purposes.
/// This enumeration is designed such that higher values represent higher
/// levels of name hiding.
enum class ModuleOwnershipKind : unsigned {
  /// This declaration is not owned by a module.
  Unowned,

  /// This declaration has an owning module, but is globally visible
  /// (typically because its owning module is visible and we know that
  /// modules cannot later become hidden in this compilation).
  /// After serialization and deserialization, this will be converted
  /// to VisibleWhenImported.
  Visible,

  /// This declaration has an owning module, and is visible when that
  /// module is imported.
  VisibleWhenImported,

  /// This declaration has an owning module, but is only visible to
  /// lookups that occur within that module.
  ModulePrivate
};

239protected:
/// The next declaration within the same lexical
/// DeclContext. These pointers form the linked list that is
/// traversed via DeclContext's decls_begin()/decls_end().
///
/// The extra two bits are used for the ModuleOwnershipKind.
llvm::PointerIntPair<Decl *, 2, ModuleOwnershipKind> NextInContextAndBits;

247private:
friend class DeclContext;

struct MultipleDC {
  DeclContext *SemanticDC;
  DeclContext *LexicalDC;
};

/// DeclCtx - Holds either a DeclContext* or a MultipleDC*.
/// For declarations that don't contain C++ scope specifiers, it contains
/// the DeclContext where the Decl was declared.
/// For declarations with C++ scope specifiers, it contains a MultipleDC*
/// with the context where it semantically belongs (SemanticDC) and the
/// context where it was lexically declared (LexicalDC).
/// e.g.:
///
///   namespace A {
///      void f(); // SemanticDC == LexicalDC == 'namespace A'
///   }
///   void A::f(); // SemanticDC == namespace 'A'
///                // LexicalDC == global namespace
llvm::PointerUnion<DeclContext*, MultipleDC*> DeclCtx;

bool isInSemaDC() const { return DeclCtx.is<DeclContext*>(); }
bool isOutOfSemaDC() const { return DeclCtx.is<MultipleDC*>(); }

MultipleDC *getMultipleDC() const {
  return DeclCtx.get<MultipleDC*>();
}

DeclContext *getSemanticDC() const {
  return DeclCtx.get<DeclContext*>();
}

/// Loc - The location of this decl.
SourceLocation Loc;

/// DeclKind - This indicates which class this is.
unsigned DeclKind : 7;

/// InvalidDecl - This indicates a semantic error occurred.
unsigned InvalidDecl :  1;

/// HasAttrs - This indicates whether the decl has attributes or not.
unsigned HasAttrs : 1;

/// Implicit - Whether this declaration was implicitly generated by
/// the implementation rather than explicitly written by the user.
unsigned Implicit : 1;

/// Whether this declaration was "used", meaning that a definition is
/// required.
unsigned Used : 1;

/// Whether this declaration was "referenced".
/// The difference with 'Used' is whether the reference appears in a
/// evaluated context or not, e.g. functions used in uninstantiated templates
/// are regarded as "referenced" but not "used".
unsigned Referenced : 1;

/// Whether this declaration is a top-level declaration (function,
/// global variable, etc.) that is lexically inside an objc container
/// definition.
unsigned TopLevelDeclInObjCContainer : 1;

/// Whether statistic collection is enabled.
static bool StatisticsEnabled;

315protected:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend class ASTNodeImporter;
friend class ASTReader;
friend class CXXClassMemberWrapper;
friend class LinkageComputer;
template<typename decl_type> friend class Redeclarable;

/// Access - Used by C++ decls for the access specifier.
// NOTE: VC++ treats enums as signed, avoid using the AccessSpecifier enum
unsigned Access : 2;

/// Whether this declaration was loaded from an AST file.
unsigned FromASTFile : 1;

/// IdentifierNamespace - This specifies what IDNS_* namespace this lives in.
unsigned IdentifierNamespace : 14;

/// If 0, we have not computed the linkage of this declaration.
/// Otherwise, it is the linkage + 1.
mutable unsigned CacheValidAndLinkage : 3;

/// Allocate memory for a deserialized declaration.
///
/// This routine must be used to allocate memory for any declaration that is
/// deserialized from a module file.
///
/// \param Size The size of the allocated object.
/// \param Ctx The context in which we will allocate memory.
/// \param ID The global ID of the deserialized declaration.
/// \param Extra The amount of extra space to allocate after the object.
void *operator new(std::size_t Size, const ASTContext &Ctx, unsigned ID,
                   std::size_t Extra = 0);

/// Allocate memory for a non-deserialized declaration.
void *operator new(std::size_t Size, const ASTContext &Ctx,
                   DeclContext *Parent, std::size_t Extra = 0);

354private:
bool AccessDeclContextSanity() const;

/// Get the module ownership kind to use for a local lexical child of \p DC,
/// which may be either a local or (rarely) an imported declaration.
static ModuleOwnershipKind getModuleOwnershipKindForChildOf(DeclContext *DC) {
  if (DC) {
    auto *D = cast<Decl>(DC);
    auto MOK = D->getModuleOwnershipKind();
    if (MOK != ModuleOwnershipKind::Unowned &&
        (!D->isFromASTFile() || D->hasLocalOwningModuleStorage()))
      return MOK;
    // If D is not local and we have no local module storage, then we don't
    // need to track module ownership at all.
  }
  return ModuleOwnershipKind::Unowned;
}

372public:
Decl() = delete;
Decl(const Decl&) = delete;
Decl(Decl &&) = delete;
Decl &operator=(const Decl&) = delete;
Decl &operator=(Decl&&) = delete;

379protected:
Decl(Kind DK, DeclContext *DC, SourceLocation L)
    : NextInContextAndBits(nullptr, getModuleOwnershipKindForChildOf(DC)),
      DeclCtx(DC), Loc(L), DeclKind(DK), InvalidDecl(false), HasAttrs(false),
      Implicit(false), Used(false), Referenced(false),
      TopLevelDeclInObjCContainer(false), Access(AS_none), FromASTFile(0),
      IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
      CacheValidAndLinkage(0) {
  if (StatisticsEnabled) add(DK);
}

Decl(Kind DK, EmptyShell Empty)
    : DeclKind(DK), InvalidDecl(false), HasAttrs(false), Implicit(false),
      Used(false), Referenced(false), TopLevelDeclInObjCContainer(false),
      Access(AS_none), FromASTFile(0),
      IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
      CacheValidAndLinkage(0) {
  if (StatisticsEnabled) add(DK);
}

virtual ~Decl();

/// Update a potentially out-of-date declaration.
void updateOutOfDate(IdentifierInfo &II) const;

Linkage getCachedLinkage() const {
  return Linkage(CacheValidAndLinkage - 1);
}

void setCachedLinkage(Linkage L) const {
  CacheValidAndLinkage = L + 1;
}

bool hasCachedLinkage() const {
  return CacheValidAndLinkage;
}

416public:
/// Source range that this declaration covers.
virtual SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getLocation(), getLocation());
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSourceRange().getBegin();
}

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSourceRange().getEnd();
}

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

Kind getKind() const { return static_cast<Kind>(DeclKind); }
const char *getDeclKindName() const;

Decl *getNextDeclInContext() { return NextInContextAndBits.getPointer(); }
const Decl *getNextDeclInContext() const {return NextInContextAndBits.getPointer();}

DeclContext *getDeclContext() {
  if (isInSemaDC())
    return getSemanticDC();
  return getMultipleDC()->SemanticDC;
}
const DeclContext *getDeclContext() const {
  return const_cast<Decl*>(this)->getDeclContext();
}

/// Find the innermost non-closure ancestor of this declaration,
/// walking up through blocks, lambdas, etc.  If that ancestor is
/// not a code context (!isFunctionOrMethod()), returns null.
///
/// A declaration may be its own non-closure context.
Decl *getNonClosureContext();
const Decl *getNonClosureContext() const {
  return const_cast<Decl*>(this)->getNonClosureContext();
}

TranslationUnitDecl *getTranslationUnitDecl();
const TranslationUnitDecl *getTranslationUnitDecl() const {
  return const_cast<Decl*>(this)->getTranslationUnitDecl();
}

bool isInAnonymousNamespace() const;

bool isInStdNamespace() const;

ASTContext &getASTContext() const LLVM_READONLY__attribute__((__pure__));

/// Helper to get the language options from the ASTContext.
/// Defined out of line to avoid depending on ASTContext.h.
const LangOptions &getLangOpts() const LLVM_READONLY__attribute__((__pure__));

void setAccess(AccessSpecifier AS) {
  Access = AS;
  assert(AccessDeclContextSanity())(static_cast <bool> (AccessDeclContextSanity()) ? void (
0) : __assert_fail ("AccessDeclContextSanity()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 475, __extension__ __PRETTY_FUNCTION__));
}

AccessSpecifier getAccess() const {
  assert(AccessDeclContextSanity())(static_cast <bool> (AccessDeclContextSanity()) ? void (
0) : __assert_fail ("AccessDeclContextSanity()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 479, __extension__ __PRETTY_FUNCTION__));
  return AccessSpecifier(Access);
}

/// Retrieve the access specifier for this declaration, even though
/// it may not yet have been properly set.
AccessSpecifier getAccessUnsafe() const {
  return AccessSpecifier(Access);
}

bool hasAttrs() const { return HasAttrs; }

void setAttrs(const AttrVec& Attrs) {
  return setAttrsImpl(Attrs, getASTContext());
}

AttrVec &getAttrs() {
  return const_cast<AttrVec&>(const_cast<const Decl*>(this)->getAttrs());
}

const AttrVec &getAttrs() const;
void dropAttrs();
void addAttr(Attr *A);

using attr_iterator = AttrVec::const_iterator;
using attr_range = llvm::iterator_range<attr_iterator>;

attr_range attrs() const {
  return attr_range(attr_begin(), attr_end());
}

attr_iterator attr_begin() const {
  return hasAttrs() ? getAttrs().begin() : nullptr;
}
attr_iterator attr_end() const {
  return hasAttrs() ? getAttrs().end() : nullptr;
}

template <typename T>
void dropAttr() {
  if (!HasAttrs) return;

  AttrVec &Vec = getAttrs();
  llvm::erase_if(Vec, [](Attr *A) { return isa<T>(A); });

  if (Vec.empty())
    HasAttrs = false;
}

template <typename T>
llvm::iterator_range<specific_attr_iterator<T>> specific_attrs() const {
  return llvm::make_range(specific_attr_begin<T>(), specific_attr_end<T>());
}

template <typename T>
specific_attr_iterator<T> specific_attr_begin() const {
  return specific_attr_iterator<T>(attr_begin());
}

template <typename T>
specific_attr_iterator<T> specific_attr_end() const {
  return specific_attr_iterator<T>(attr_end());
}

template<typename T> T *getAttr() const {
  return hasAttrs() ? getSpecificAttr<T>(getAttrs()) : nullptr;
}

template<typename T> bool hasAttr() const {
  return hasAttrs() && hasSpecificAttr<T>(getAttrs());
}

/// getMaxAlignment - return the maximum alignment specified by attributes
/// on this decl, 0 if there are none.
unsigned getMaxAlignment() const;

/// setInvalidDecl - Indicates the Decl had a semantic error. This
/// allows for graceful error recovery.
void setInvalidDecl(bool Invalid = true);
bool isInvalidDecl() const { return (bool) InvalidDecl; }

/// isImplicit - Indicates whether the declaration was implicitly
/// generated by the implementation. If false, this declaration
/// was written explicitly in the source code.
bool isImplicit() const { return Implicit; }
void setImplicit(bool I = true) { Implicit = I; }

/// Whether *any* (re-)declaration of the entity was used, meaning that
/// a definition is required.
///
/// \param CheckUsedAttr When true, also consider the "used" attribute
/// (in addition to the "used" bit set by \c setUsed()) when determining
/// whether the function is used.
bool isUsed(bool CheckUsedAttr = true) const;

/// Set whether the declaration is used, in the sense of odr-use.
///
/// This should only be used immediately after creating a declaration.
/// It intentionally doesn't notify any listeners.
void setIsUsed() { getCanonicalDecl()->Used = true; }

/// Mark the declaration used, in the sense of odr-use.
///
/// This notifies any mutation listeners in addition to setting a bit
/// indicating the declaration is used.
void markUsed(ASTContext &C);

/// Whether any declaration of this entity was referenced.
bool isReferenced() const;

/// Whether this declaration was referenced. This should not be relied
/// upon for anything other than debugging.
bool isThisDeclarationReferenced() const { return Referenced; }

void setReferenced(bool R = true) { Referenced = R; }

/// Whether this declaration is a top-level declaration (function,
/// global variable, etc.) that is lexically inside an objc container
/// definition.
bool isTopLevelDeclInObjCContainer() const {
  return TopLevelDeclInObjCContainer;
}

void setTopLevelDeclInObjCContainer(bool V = true) {
  TopLevelDeclInObjCContainer = V;
}

/// Looks on this and related declarations for an applicable
/// external source symbol attribute.
ExternalSourceSymbolAttr *getExternalSourceSymbolAttr() const;

/// Whether this declaration was marked as being private to the
/// module in which it was defined.
bool isModulePrivate() const {
  return getModuleOwnershipKind() == ModuleOwnershipKind::ModulePrivate;
}

/// Return true if this declaration has an attribute which acts as
/// definition of the entity, such as 'alias' or 'ifunc'.
bool hasDefiningAttr() const;

/// Return this declaration's defining attribute if it has one.
const Attr *getDefiningAttr() const;

623protected:
/// Specify that this declaration was marked as being private
/// to the module in which it was defined.
void setModulePrivate() {
  // The module-private specifier has no effect on unowned declarations.
  // FIXME: We should track this in some way for source fidelity.
  if (getModuleOwnershipKind() == ModuleOwnershipKind::Unowned)
    return;
  setModuleOwnershipKind(ModuleOwnershipKind::ModulePrivate);
}

634public:
/// Set the FromASTFile flag. This indicates that this declaration
/// was deserialized and not parsed from source code and enables
/// features such as module ownership information.
void setFromASTFile() {
  FromASTFile = true;
}

/// Set the owning module ID.  This may only be called for
/// deserialized Decls.
void setOwningModuleID(unsigned ID) {
  assert(isFromASTFile() && "Only works on a deserialized declaration")(static_cast <bool> (isFromASTFile() && "Only works on a deserialized declaration"
) ? void (0) : __assert_fail ("isFromASTFile() && \"Only works on a deserialized declaration\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 645, __extension__ __PRETTY_FUNCTION__));
  *((unsigned*)this - 2) = ID;
}

649public:
/// Determine the availability of the given declaration.
///
/// This routine will determine the most restrictive availability of
/// the given declaration (e.g., preferring 'unavailable' to
/// 'deprecated').
///
/// \param Message If non-NULL and the result is not \c
/// AR_Available, will be set to a (possibly empty) message
/// describing why the declaration has not been introduced, is
/// deprecated, or is unavailable.
///
/// \param EnclosingVersion The version to compare with. If empty, assume the
/// deployment target version.
///
/// \param RealizedPlatform If non-NULL and the availability result is found
/// in an available attribute it will set to the platform which is written in
/// the available attribute.
AvailabilityResult
getAvailability(std::string *Message = nullptr,
                VersionTuple EnclosingVersion = VersionTuple(),
                StringRef *RealizedPlatform = nullptr) const;

/// Retrieve the version of the target platform in which this
/// declaration was introduced.
///
/// \returns An empty version tuple if this declaration has no 'introduced'
/// availability attributes, or the version tuple that's specified in the
/// attribute otherwise.
VersionTuple getVersionIntroduced() const;

/// Determine whether this declaration is marked 'deprecated'.
///
/// \param Message If non-NULL and the declaration is deprecated,
/// this will be set to the message describing why the declaration
/// was deprecated (which may be empty).
bool isDeprecated(std::string *Message = nullptr) const {
  return getAvailability(Message) == AR_Deprecated;
}

/// Determine whether this declaration is marked 'unavailable'.
///
/// \param Message If non-NULL and the declaration is unavailable,
/// this will be set to the message describing why the declaration
/// was made unavailable (which may be empty).
bool isUnavailable(std::string *Message = nullptr) const {
  return getAvailability(Message) == AR_Unavailable;
}

/// Determine whether this is a weak-imported symbol.
///
/// Weak-imported symbols are typically marked with the
/// 'weak_import' attribute, but may also be marked with an
/// 'availability' attribute where we're targing a platform prior to
/// the introduction of this feature.
bool isWeakImported() const;

/// Determines whether this symbol can be weak-imported,
/// e.g., whether it would be well-formed to add the weak_import
/// attribute.
///
/// \param IsDefinition Set to \c true to indicate that this
/// declaration cannot be weak-imported because it has a definition.
bool canBeWeakImported(bool &IsDefinition) const;

/// Determine whether this declaration came from an AST file (such as
/// a precompiled header or module) rather than having been parsed.
bool isFromASTFile() const { return FromASTFile; }

/// Retrieve the global declaration ID associated with this
/// declaration, which specifies where this Decl was loaded from.
unsigned getGlobalID() const {
  if (isFromASTFile())
    return *((const unsigned*)this - 1);
  return 0;
}

/// Retrieve the global ID of the module that owns this particular
/// declaration.
unsigned getOwningModuleID() const {
  if (isFromASTFile())
    return *((const unsigned*)this - 2);
  return 0;
}

734private:
Module *getOwningModuleSlow() const;

737protected:
bool hasLocalOwningModuleStorage() const;

740public:
/// Get the imported owning module, if this decl is from an imported
/// (non-local) module.
Module *getImportedOwningModule() const {
  if (!isFromASTFile() || !hasOwningModule())
    return nullptr;

  return getOwningModuleSlow();
}

/// Get the local owning module, if known. Returns nullptr if owner is
/// not yet known or declaration is not from a module.
Module *getLocalOwningModule() const {
  if (isFromASTFile() || !hasOwningModule())
    return nullptr;

  assert(hasLocalOwningModuleStorage() &&(static_cast <bool> (hasLocalOwningModuleStorage() &&
 "owned local decl but no local module storage") ? void (0) :
 __assert_fail ("hasLocalOwningModuleStorage() && \"owned local decl but no local module storage\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 757, __extension__ __PRETTY_FUNCTION__))
         "owned local decl but no local module storage")(static_cast <bool> (hasLocalOwningModuleStorage() &&
 "owned local decl but no local module storage") ? void (0) :
 __assert_fail ("hasLocalOwningModuleStorage() && \"owned local decl but no local module storage\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 757, __extension__ __PRETTY_FUNCTION__));
  return reinterpret_cast<Module *const *>(this)[-1];
}
void setLocalOwningModule(Module *M) {
  assert(!isFromASTFile() && hasOwningModule() &&(static_cast <bool> (!isFromASTFile() && hasOwningModule
() && hasLocalOwningModuleStorage() && "should not have a cached owning module"
) ? void (0) : __assert_fail ("!isFromASTFile() && hasOwningModule() && hasLocalOwningModuleStorage() && \"should not have a cached owning module\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 763, __extension__ __PRETTY_FUNCTION__))
         hasLocalOwningModuleStorage() &&(static_cast <bool> (!isFromASTFile() && hasOwningModule
() && hasLocalOwningModuleStorage() && "should not have a cached owning module"
) ? void (0) : __assert_fail ("!isFromASTFile() && hasOwningModule() && hasLocalOwningModuleStorage() && \"should not have a cached owning module\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 763, __extension__ __PRETTY_FUNCTION__))
         "should not have a cached owning module")(static_cast <bool> (!isFromASTFile() && hasOwningModule
() && hasLocalOwningModuleStorage() && "should not have a cached owning module"
) ? void (0) : __assert_fail ("!isFromASTFile() && hasOwningModule() && hasLocalOwningModuleStorage() && \"should not have a cached owning module\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 763, __extension__ __PRETTY_FUNCTION__));
  reinterpret_cast<Module **>(this)[-1] = M;
}

/// Is this declaration owned by some module?
bool hasOwningModule() const {
  return getModuleOwnershipKind() != ModuleOwnershipKind::Unowned;
}

/// Get the module that owns this declaration (for visibility purposes).
Module *getOwningModule() const {
  return isFromASTFile() ? getImportedOwningModule() : getLocalOwningModule();
}

/// Get the module that owns this declaration for linkage purposes.
/// There only ever is such a module under the C++ Modules TS.
///
/// \param IgnoreLinkage Ignore the linkage of the entity; assume that
/// all declarations in a global module fragment are unowned.
Module *getOwningModuleForLinkage(bool IgnoreLinkage = false) const;

/// Determine whether this declaration is definitely visible to name lookup,
/// independent of whether the owning module is visible.
/// Note: The declaration may be visible even if this returns \c false if the
/// owning module is visible within the query context. This is a low-level
/// helper function; most code should be calling Sema::isVisible() instead.
bool isUnconditionallyVisible() const {
  return (int)getModuleOwnershipKind() <= (int)ModuleOwnershipKind::Visible;
}

/// Set that this declaration is globally visible, even if it came from a
/// module that is not visible.
void setVisibleDespiteOwningModule() {
  if (!isUnconditionallyVisible())
    setModuleOwnershipKind(ModuleOwnershipKind::Visible);
}

/// Get the kind of module ownership for this declaration.
ModuleOwnershipKind getModuleOwnershipKind() const {
  return NextInContextAndBits.getInt();
}

/// Set whether this declaration is hidden from name lookup.
void setModuleOwnershipKind(ModuleOwnershipKind MOK) {
  assert(!(getModuleOwnershipKind() == ModuleOwnershipKind::Unowned &&(static_cast <bool> (!(getModuleOwnershipKind() == ModuleOwnershipKind
::Unowned && MOK != ModuleOwnershipKind::Unowned &&
 !isFromASTFile() && !hasLocalOwningModuleStorage()) &&
 "no storage available for owning module for this declaration"
) ? void (0) : __assert_fail ("!(getModuleOwnershipKind() == ModuleOwnershipKind::Unowned && MOK != ModuleOwnershipKind::Unowned && !isFromASTFile() && !hasLocalOwningModuleStorage()) && \"no storage available for owning module for this declaration\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 810, __extension__ __PRETTY_FUNCTION__))
           MOK != ModuleOwnershipKind::Unowned && !isFromASTFile() &&(static_cast <bool> (!(getModuleOwnershipKind() == ModuleOwnershipKind
::Unowned && MOK != ModuleOwnershipKind::Unowned &&
 !isFromASTFile() && !hasLocalOwningModuleStorage()) &&
 "no storage available for owning module for this declaration"
) ? void (0) : __assert_fail ("!(getModuleOwnershipKind() == ModuleOwnershipKind::Unowned && MOK != ModuleOwnershipKind::Unowned && !isFromASTFile() && !hasLocalOwningModuleStorage()) && \"no storage available for owning module for this declaration\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 810, __extension__ __PRETTY_FUNCTION__))
           !hasLocalOwningModuleStorage()) &&(static_cast <bool> (!(getModuleOwnershipKind() == ModuleOwnershipKind
::Unowned && MOK != ModuleOwnershipKind::Unowned &&
 !isFromASTFile() && !hasLocalOwningModuleStorage()) &&
 "no storage available for owning module for this declaration"
) ? void (0) : __assert_fail ("!(getModuleOwnershipKind() == ModuleOwnershipKind::Unowned && MOK != ModuleOwnershipKind::Unowned && !isFromASTFile() && !hasLocalOwningModuleStorage()) && \"no storage available for owning module for this declaration\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 810, __extension__ __PRETTY_FUNCTION__))
         "no storage available for owning module for this declaration")(static_cast <bool> (!(getModuleOwnershipKind() == ModuleOwnershipKind
::Unowned && MOK != ModuleOwnershipKind::Unowned &&
 !isFromASTFile() && !hasLocalOwningModuleStorage()) &&
 "no storage available for owning module for this declaration"
) ? void (0) : __assert_fail ("!(getModuleOwnershipKind() == ModuleOwnershipKind::Unowned && MOK != ModuleOwnershipKind::Unowned && !isFromASTFile() && !hasLocalOwningModuleStorage()) && \"no storage available for owning module for this declaration\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 810, __extension__ __PRETTY_FUNCTION__));
  NextInContextAndBits.setInt(MOK);
}

unsigned getIdentifierNamespace() const {
  return IdentifierNamespace;
}

bool isInIdentifierNamespace(unsigned NS) const {
  return getIdentifierNamespace() & NS;
}

static unsigned getIdentifierNamespaceForKind(Kind DK);

bool hasTagIdentifierNamespace() const {
  return isTagIdentifierNamespace(getIdentifierNamespace());
}

static bool isTagIdentifierNamespace(unsigned NS) {
  // TagDecls have Tag and Type set and may also have TagFriend.
  return (NS & ~IDNS_TagFriend) == (IDNS_Tag | IDNS_Type);
}

/// getLexicalDeclContext - The declaration context where this Decl was
/// lexically declared (LexicalDC). May be different from
/// getDeclContext() (SemanticDC).
/// e.g.:
///
///   namespace A {
///      void f(); // SemanticDC == LexicalDC == 'namespace A'
///   }
///   void A::f(); // SemanticDC == namespace 'A'
///                // LexicalDC == global namespace
DeclContext *getLexicalDeclContext() {
  if (isInSemaDC())
    return getSemanticDC();
  return getMultipleDC()->LexicalDC;
}
const DeclContext *getLexicalDeclContext() const {
  return const_cast<Decl*>(this)->getLexicalDeclContext();
}

/// Determine whether this declaration is declared out of line (outside its
/// semantic context).
virtual bool isOutOfLine() const;

/// setDeclContext - Set both the semantic and lexical DeclContext
/// to DC.
void setDeclContext(DeclContext *DC);

void setLexicalDeclContext(DeclContext *DC);

/// Determine whether this declaration is a templated entity (whether it is
// within the scope of a template parameter).
bool isTemplated() const;

/// Determine the number of levels of template parameter surrounding this
/// declaration.
unsigned getTemplateDepth() const;

/// isDefinedOutsideFunctionOrMethod - This predicate returns true if this
/// scoped decl is defined outside the current function or method.  This is
/// roughly global variables and functions, but also handles enums (which
/// could be defined inside or outside a function etc).
bool isDefinedOutsideFunctionOrMethod() const {
  return getParentFunctionOrMethod() == nullptr;
}

/// Determine whether a substitution into this declaration would occur as
/// part of a substitution into a dependent local scope. Such a substitution
/// transitively substitutes into all constructs nested within this
/// declaration.
///
/// This recognizes non-defining declarations as well as members of local
/// classes and lambdas:
/// \code
///     template<typename T> void foo() { void bar(); }
///     template<typename T> void foo2() { class ABC { void bar(); }; }
///     template<typename T> inline int x = [](){ return 0; }();
/// \endcode
bool isInLocalScopeForInstantiation() const;

/// If this decl is defined inside a function/method/block it returns
/// the corresponding DeclContext, otherwise it returns null.
const DeclContext *getParentFunctionOrMethod() const;
DeclContext *getParentFunctionOrMethod() {
  return const_cast<DeclContext*>(
                  const_cast<const Decl*>(this)->getParentFunctionOrMethod());
}

/// Retrieves the "canonical" declaration of the given declaration.
virtual Decl *getCanonicalDecl() { return this; }
const Decl *getCanonicalDecl() const {
  return const_cast<Decl*>(this)->getCanonicalDecl();
}

/// Whether this particular Decl is a canonical one.
bool isCanonicalDecl() const { return getCanonicalDecl() == this; }

909protected:
/// Returns the next redeclaration or itself if this is the only decl.
///
/// Decl subclasses that can be redeclared should override this method so that
/// Decl::redecl_iterator can iterate over them.
virtual Decl *getNextRedeclarationImpl() { return this; }

/// Implementation of getPreviousDecl(), to be overridden by any
/// subclass that has a redeclaration chain.
virtual Decl *getPreviousDeclImpl() { return nullptr; }

/// Implementation of getMostRecentDecl(), to be overridden by any
/// subclass that has a redeclaration chain.
virtual Decl *getMostRecentDeclImpl() { return this; }

924public:
/// Iterates through all the redeclarations of the same decl.
class redecl_iterator {
  /// Current - The current declaration.
  Decl *Current = nullptr;
  Decl *Starter;

public:
  using value_type = Decl *;
  using reference = const value_type &;
  using pointer = const value_type *;
  using iterator_category = std::forward_iterator_tag;
  using difference_type = std::ptrdiff_t;

  redecl_iterator() = default;
  explicit redecl_iterator(Decl *C) : Current(C), Starter(C) {}

  reference operator*() const { return Current; }
  value_type operator->() const { return Current; }

  redecl_iterator& operator++() {
    assert(Current && "Advancing while iterator has reached end")(static_cast <bool> (Current && "Advancing while iterator has reached end"
) ? void (0) : __assert_fail ("Current && \"Advancing while iterator has reached end\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 945, __extension__ __PRETTY_FUNCTION__));
    // Get either previous decl or latest decl.
    Decl *Next = Current->getNextRedeclarationImpl();
    assert(Next && "Should return next redeclaration or itself, never null!")(static_cast <bool> (Next && "Should return next redeclaration or itself, never null!"
) ? void (0) : __assert_fail ("Next && \"Should return next redeclaration or itself, never null!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 948, __extension__ __PRETTY_FUNCTION__));
    Current = (Next != Starter) ? Next : nullptr;
    return *this;
  }

  redecl_iterator operator++(int) {
    redecl_iterator tmp(*this);
    ++(*this);
    return tmp;
  }

  friend bool operator==(redecl_iterator x, redecl_iterator y) {
    return x.Current == y.Current;
  }

  friend bool operator!=(redecl_iterator x, redecl_iterator y) {
    return x.Current != y.Current;
  }
};

using redecl_range = llvm::iterator_range<redecl_iterator>;

/// Returns an iterator range for all the redeclarations of the same
/// decl. It will iterate at least once (when this decl is the only one).
redecl_range redecls() const {
  return redecl_range(redecls_begin(), redecls_end());
}

redecl_iterator redecls_begin() const {
  return redecl_iterator(const_cast<Decl *>(this));
}

redecl_iterator redecls_end() const { return redecl_iterator(); }

/// Retrieve the previous declaration that declares the same entity
/// as this declaration, or NULL if there is no previous declaration.
Decl *getPreviousDecl() { return getPreviousDeclImpl(); }

/// Retrieve the previous declaration that declares the same entity
/// as this declaration, or NULL if there is no previous declaration.
const Decl *getPreviousDecl() const {
  return const_cast<Decl *>(this)->getPreviousDeclImpl();
}

/// True if this is the first declaration in its redeclaration chain.
bool isFirstDecl() const {
  return getPreviousDecl() == nullptr;
}

/// Retrieve the most recent declaration that declares the same entity
/// as this declaration (which may be this declaration).
Decl *getMostRecentDecl() { return getMostRecentDeclImpl(); }

/// Retrieve the most recent declaration that declares the same entity
/// as this declaration (which may be this declaration).
const Decl *getMostRecentDecl() const {
  return const_cast<Decl *>(this)->getMostRecentDeclImpl();
}

/// getBody - If this Decl represents a declaration for a body of code,
///  such as a function or method definition, this method returns the
///  top-level Stmt* of that body.  Otherwise this method returns null.
virtual Stmt* getBody() const { return nullptr; }

/// Returns true if this \c Decl represents a declaration for a body of
/// code, such as a function or method definition.
/// Note that \c hasBody can also return true if any redeclaration of this
/// \c Decl represents a declaration for a body of code.
virtual bool hasBody() const { return getBody() != nullptr; }

/// getBodyRBrace - Gets the right brace of the body, if a body exists.
/// This works whether the body is a CompoundStmt or a CXXTryStmt.
SourceLocation getBodyRBrace() const;

// global temp stats (until we have a per-module visitor)
static void add(Kind k);
static void EnableStatistics();
static void PrintStats();

/// isTemplateParameter - Determines whether this declaration is a
/// template parameter.
bool isTemplateParameter() const;

/// isTemplateParameter - Determines whether this declaration is a
/// template parameter pack.
bool isTemplateParameterPack() const;

/// Whether this declaration is a parameter pack.
bool isParameterPack() const;

/// returns true if this declaration is a template
bool isTemplateDecl() const;

/// Whether this declaration is a function or function template.
bool isFunctionOrFunctionTemplate() const {
  return (DeclKind >= Decl::firstFunction &&
          DeclKind <= Decl::lastFunction) ||
         DeclKind == FunctionTemplate;
}

/// If this is a declaration that describes some template, this
/// method returns that template declaration.
///
/// Note that this returns nullptr for partial specializations, because they
/// are not modeled as TemplateDecls. Use getDescribedTemplateParams to handle
/// those cases.
TemplateDecl *getDescribedTemplate() const;

/// If this is a declaration that describes some template or partial
/// specialization, this returns the corresponding template parameter list.
const TemplateParameterList *getDescribedTemplateParams() const;

/// Returns the function itself, or the templated function if this is a
/// function template.
FunctionDecl *getAsFunction() LLVM_READONLY__attribute__((__pure__));

const FunctionDecl *getAsFunction() const {
  return const_cast<Decl *>(this)->getAsFunction();
}

/// Changes the namespace of this declaration to reflect that it's
/// a function-local extern declaration.
///
/// These declarations appear in the lexical context of the extern
/// declaration, but in the semantic context of the enclosing namespace
/// scope.
void setLocalExternDecl() {
  Decl *Prev = getPreviousDecl();
  IdentifierNamespace &= ~IDNS_Ordinary;

  // It's OK for the declaration to still have the "invisible friend" flag or
  // the "conflicts with tag declarations in this scope" flag for the outer
  // scope.
  assert((IdentifierNamespace & ~(IDNS_OrdinaryFriend | IDNS_Tag)) == 0 &&(static_cast <bool> ((IdentifierNamespace & ~(IDNS_OrdinaryFriend
 | IDNS_Tag)) == 0 && "namespace is not ordinary") ? void
 (0) : __assert_fail ("(IdentifierNamespace & ~(IDNS_OrdinaryFriend | IDNS_Tag)) == 0 && \"namespace is not ordinary\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1082, __extension__ __PRETTY_FUNCTION__))
         "namespace is not ordinary")(static_cast <bool> ((IdentifierNamespace & ~(IDNS_OrdinaryFriend
 | IDNS_Tag)) == 0 && "namespace is not ordinary") ? void
 (0) : __assert_fail ("(IdentifierNamespace & ~(IDNS_OrdinaryFriend | IDNS_Tag)) == 0 && \"namespace is not ordinary\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1082, __extension__ __PRETTY_FUNCTION__));

  IdentifierNamespace |= IDNS_LocalExtern;
  if (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary)
    IdentifierNamespace |= IDNS_Ordinary;
}

/// Determine whether this is a block-scope declaration with linkage.
/// This will either be a local variable declaration declared 'extern', or a
/// local function declaration.
bool isLocalExternDecl() {
  return IdentifierNamespace & IDNS_LocalExtern;
}

/// Changes the namespace of this declaration to reflect that it's
/// the object of a friend declaration.
///
/// These declarations appear in the lexical context of the friending
/// class, but in the semantic context of the actual entity.  This property
/// applies only to a specific decl object;  other redeclarations of the
/// same entity may not (and probably don't) share this property.
void setObjectOfFriendDecl(bool PerformFriendInjection = false) {
  unsigned OldNS = IdentifierNamespace;
  assert((OldNS & (IDNS_Tag | IDNS_Ordinary |(static_cast <bool> ((OldNS & (IDNS_Tag | IDNS_Ordinary
 | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator
)) && "namespace includes neither ordinary nor tag") ?
 void (0) : __assert_fail ("(OldNS & (IDNS_Tag | IDNS_Ordinary | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator)) && \"namespace includes neither ordinary nor tag\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1108, __extension__ __PRETTY_FUNCTION__))
                   IDNS_TagFriend | IDNS_OrdinaryFriend |(static_cast <bool> ((OldNS & (IDNS_Tag | IDNS_Ordinary
 | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator
)) && "namespace includes neither ordinary nor tag") ?
 void (0) : __assert_fail ("(OldNS & (IDNS_Tag | IDNS_Ordinary | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator)) && \"namespace includes neither ordinary nor tag\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1108, __extension__ __PRETTY_FUNCTION__))
                   IDNS_LocalExtern | IDNS_NonMemberOperator)) &&(static_cast <bool> ((OldNS & (IDNS_Tag | IDNS_Ordinary
 | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator
)) && "namespace includes neither ordinary nor tag") ?
 void (0) : __assert_fail ("(OldNS & (IDNS_Tag | IDNS_Ordinary | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator)) && \"namespace includes neither ordinary nor tag\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1108, __extension__ __PRETTY_FUNCTION__))
         "namespace includes neither ordinary nor tag")(static_cast <bool> ((OldNS & (IDNS_Tag | IDNS_Ordinary
 | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator
)) && "namespace includes neither ordinary nor tag") ?
 void (0) : __assert_fail ("(OldNS & (IDNS_Tag | IDNS_Ordinary | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator)) && \"namespace includes neither ordinary nor tag\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1108, __extension__ __PRETTY_FUNCTION__));
  assert(!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type |(static_cast <bool> (!(OldNS & ~(IDNS_Tag | IDNS_Ordinary
 | IDNS_Type | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern
 | IDNS_NonMemberOperator)) && "namespace includes other than ordinary or tag"
) ? void (0) : __assert_fail ("!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator)) && \"namespace includes other than ordinary or tag\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1112, __extension__ __PRETTY_FUNCTION__))
                     IDNS_TagFriend | IDNS_OrdinaryFriend |(static_cast <bool> (!(OldNS & ~(IDNS_Tag | IDNS_Ordinary
 | IDNS_Type | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern
 | IDNS_NonMemberOperator)) && "namespace includes other than ordinary or tag"
) ? void (0) : __assert_fail ("!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator)) && \"namespace includes other than ordinary or tag\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1112, __extension__ __PRETTY_FUNCTION__))
                     IDNS_LocalExtern | IDNS_NonMemberOperator)) &&(static_cast <bool> (!(OldNS & ~(IDNS_Tag | IDNS_Ordinary
 | IDNS_Type | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern
 | IDNS_NonMemberOperator)) && "namespace includes other than ordinary or tag"
) ? void (0) : __assert_fail ("!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator)) && \"namespace includes other than ordinary or tag\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1112, __extension__ __PRETTY_FUNCTION__))
         "namespace includes other than ordinary or tag")(static_cast <bool> (!(OldNS & ~(IDNS_Tag | IDNS_Ordinary
 | IDNS_Type | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern
 | IDNS_NonMemberOperator)) && "namespace includes other than ordinary or tag"
) ? void (0) : __assert_fail ("!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type | IDNS_TagFriend | IDNS_OrdinaryFriend | IDNS_LocalExtern | IDNS_NonMemberOperator)) && \"namespace includes other than ordinary or tag\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1112, __extension__ __PRETTY_FUNCTION__));

  Decl *Prev = getPreviousDecl();
  IdentifierNamespace &= ~(IDNS_Ordinary | IDNS_Tag | IDNS_Type);

  if (OldNS & (IDNS_Tag | IDNS_TagFriend)) {
    IdentifierNamespace |= IDNS_TagFriend;
    if (PerformFriendInjection ||
        (Prev && Prev->getIdentifierNamespace() & IDNS_Tag))
      IdentifierNamespace |= IDNS_Tag | IDNS_Type;
  }

  if (OldNS & (IDNS_Ordinary | IDNS_OrdinaryFriend |
               IDNS_LocalExtern | IDNS_NonMemberOperator)) {
    IdentifierNamespace |= IDNS_OrdinaryFriend;
    if (PerformFriendInjection ||
        (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary))
      IdentifierNamespace |= IDNS_Ordinary;
  }
}

enum FriendObjectKind {
  FOK_None,      ///< Not a friend object.
  FOK_Declared,  ///< A friend of a previously-declared entity.
  FOK_Undeclared ///< A friend of a previously-undeclared entity.
};

/// Determines whether this declaration is the object of a
/// friend declaration and, if so, what kind.
///
/// There is currently no direct way to find the associated FriendDecl.
FriendObjectKind getFriendObjectKind() const {
  unsigned mask =
      (IdentifierNamespace & (IDNS_TagFriend | IDNS_OrdinaryFriend));
  if (!mask) return FOK_None;
  return (IdentifierNamespace & (IDNS_Tag | IDNS_Ordinary) ? FOK_Declared
                                                           : FOK_Undeclared);
}

/// Specifies that this declaration is a C++ overloaded non-member.
void setNonMemberOperator() {
  assert(getKind() == Function || getKind() == FunctionTemplate)(static_cast <bool> (getKind() == Function || getKind()
 == FunctionTemplate) ? void (0) : __assert_fail ("getKind() == Function || getKind() == FunctionTemplate"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1153, __extension__ __PRETTY_FUNCTION__));
  assert((IdentifierNamespace & IDNS_Ordinary) &&(static_cast <bool> ((IdentifierNamespace & IDNS_Ordinary
) && "visible non-member operators should be in ordinary namespace"
) ? void (0) : __assert_fail ("(IdentifierNamespace & IDNS_Ordinary) && \"visible non-member operators should be in ordinary namespace\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1155, __extension__ __PRETTY_FUNCTION__))
         "visible non-member operators should be in ordinary namespace")(static_cast <bool> ((IdentifierNamespace & IDNS_Ordinary
) && "visible non-member operators should be in ordinary namespace"
) ? void (0) : __assert_fail ("(IdentifierNamespace & IDNS_Ordinary) && \"visible non-member operators should be in ordinary namespace\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1155, __extension__ __PRETTY_FUNCTION__));
  IdentifierNamespace |= IDNS_NonMemberOperator;
}

static bool classofKind(Kind K) { return true; }
static DeclContext *castToDeclContext(const Decl *);
static Decl *castFromDeclContext(const DeclContext *);

void print(raw_ostream &Out, unsigned Indentation = 0,
           bool PrintInstantiation = false) const;
void print(raw_ostream &Out, const PrintingPolicy &Policy,
           unsigned Indentation = 0, bool PrintInstantiation = false) const;
static void printGroup(Decl** Begin, unsigned NumDecls,
                       raw_ostream &Out, const PrintingPolicy &Policy,
                       unsigned Indentation = 0);

// Debuggers don't usually respect default arguments.
void dump() const;

// Same as dump(), but forces color printing.
void dumpColor() const;

void dump(raw_ostream &Out, bool Deserialize = false,
          ASTDumpOutputFormat OutputFormat = ADOF_Default) const;

/// \return Unique reproducible object identifier
int64_t getID() const;

/// Looks through the Decl's underlying type to extract a FunctionType
/// when possible. Will return null if the type underlying the Decl does not
/// have a FunctionType.
const FunctionType *getFunctionType(bool BlocksToo = true) const;

1188private:
void setAttrsImpl(const AttrVec& Attrs, ASTContext &Ctx);
void setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
                         ASTContext &Ctx);

1193protected:
ASTMutationListener *getASTMutationListener() const;
1195};

1197/// Determine whether two declarations declare the same entity.
1198inline bool declaresSameEntity(const Decl *D1, const Decl *D2) {
if (!D1 || !D2)
  return false;

if (D1 == D2)
  return true;

return D1->getCanonicalDecl() == D2->getCanonicalDecl();
1206}

1208/// PrettyStackTraceDecl - If a crash occurs, indicate that it happened when
1209/// doing something to a specific decl.
1210class PrettyStackTraceDecl : public llvm::PrettyStackTraceEntry {
const Decl *TheDecl;
SourceLocation Loc;
SourceManager &SM;
const char *Message;

1216public:
PrettyStackTraceDecl(const Decl *theDecl, SourceLocation L,
                     SourceManager &sm, const char *Msg)
    : TheDecl(theDecl), Loc(L), SM(sm), Message(Msg) {}

void print(raw_ostream &OS) const override;
1222};
1223} // namespace clang

1225// Required to determine the layout of the PointerUnion<NamedDecl*> before
1226// seeing the NamedDecl definition being first used in DeclListNode::operator*.
1227namespace llvm {
template <> struct PointerLikeTypeTraits<::clang::NamedDecl *> {
  static inline void *getAsVoidPointer(::clang::NamedDecl *P) { return P; }
  static inline ::clang::NamedDecl *getFromVoidPointer(void *P) {
    return static_cast<::clang::NamedDecl *>(P);
  }
  static constexpr int NumLowBitsAvailable = 3;
};
1235}

1237namespace clang {
1238/// A list storing NamedDecls in the lookup tables.
1239class DeclListNode {
friend class ASTContext; // allocate, deallocate nodes.
friend class StoredDeclsList;
1242public:
using Decls = llvm::PointerUnion<NamedDecl*, DeclListNode*>;
class iterator {
  friend class DeclContextLookupResult;
  friend class StoredDeclsList;

  Decls Ptr;
  iterator(Decls Node) : Ptr(Node) { }
public:
  using difference_type = ptrdiff_t;
  using value_type = NamedDecl*;
  using pointer = void;
  using reference = value_type;
  using iterator_category = std::forward_iterator_tag;

  iterator() = default;

  reference operator*() const {
    assert(Ptr && "dereferencing end() iterator")(static_cast <bool> (Ptr && "dereferencing end() iterator"
) ? void (0) : __assert_fail ("Ptr && \"dereferencing end() iterator\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1260, __extension__ __PRETTY_FUNCTION__));
    if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>())
      return CurNode->D;
    return Ptr.get<NamedDecl*>();
  }
  void operator->() const { } // Unsupported.
  bool operator==(const iterator &X) const { return Ptr == X.Ptr; }
  bool operator!=(const iterator &X) const { return Ptr != X.Ptr; }
  inline iterator &operator++() { // ++It
    assert(!Ptr.isNull() && "Advancing empty iterator")(static_cast <bool> (!Ptr.isNull() && "Advancing empty iterator"
) ? void (0) : __assert_fail ("!Ptr.isNull() && \"Advancing empty iterator\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 1269, __extension__ __PRETTY_FUNCTION__));

    if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>())
      Ptr = CurNode->Rest;
    else
      Ptr = nullptr;
    return *this;
  }
  iterator operator++(int) { // It++
    iterator temp = *this;
    ++(*this);
    return temp;
  }
  // Enables the pattern for (iterator I =..., E = I.end(); I != E; ++I)
  iterator end() { return iterator(); }
};
1285private:
NamedDecl *D = nullptr;
Decls Rest = nullptr;
DeclListNode(NamedDecl *ND) : D(ND) {}
1289};

1291/// The results of name lookup within a DeclContext.
1292class DeclContextLookupResult {
using Decls = DeclListNode::Decls;

/// When in collection form, this is what the Data pointer points to.
Decls Result;

1298public:
DeclContextLookupResult() = default;
DeclContextLookupResult(Decls Result) : Result(Result) {}

using iterator = DeclListNode::iterator;
using const_iterator = iterator;
using reference = iterator::reference;

iterator begin() { return iterator(Result); }
iterator end() { return iterator(); }
const_iterator begin() const {
  return const_cast<DeclContextLookupResult*>(this)->begin();
}
const_iterator end() const { return iterator(); }

bool empty() const { return Result.isNull();  }
bool isSingleResult() const { return Result.dyn_cast<NamedDecl*>(); }
reference front() const { return *begin(); }

// Find the first declaration of the given type in the list. Note that this
// is not in general the earliest-declared declaration, and should only be
// used when it's not possible for there to be more than one match or where
// it doesn't matter which one is found.
template<class T> T *find_first() const {
  for (auto *D : *this)
    if (T *Decl = dyn_cast<T>(D))
      return Decl;

  return nullptr;
}
1328};

1330/// DeclContext - This is used only as base class of specific decl types that
1331/// can act as declaration contexts. These decls are (only the top classes
1332/// that directly derive from DeclContext are mentioned, not their subclasses):
1333///
1334///   TranslationUnitDecl
1335///   ExternCContext
1336///   NamespaceDecl
1337///   TagDecl
1338///   OMPDeclareReductionDecl
1339///   OMPDeclareMapperDecl
1340///   FunctionDecl
1341///   ObjCMethodDecl
1342///   ObjCContainerDecl
1343///   LinkageSpecDecl
1344///   ExportDecl
1345///   BlockDecl
1346///   CapturedDecl
1347class DeclContext {
/// For makeDeclVisibleInContextImpl
friend class ASTDeclReader;
/// For reconcileExternalVisibleStorage, CreateStoredDeclsMap,
/// hasNeedToReconcileExternalVisibleStorage
friend class ExternalASTSource;
/// For CreateStoredDeclsMap
friend class DependentDiagnostic;
/// For hasNeedToReconcileExternalVisibleStorage,
/// hasLazyLocalLexicalLookups, hasLazyExternalLexicalLookups
friend class ASTWriter;

// We use uint64_t in the bit-fields below since some bit-fields
// cross the unsigned boundary and this breaks the packing.

/// Stores the bits used by DeclContext.
/// If modified NumDeclContextBit, the ctor of DeclContext and the accessor
/// methods in DeclContext should be updated appropriately.
class DeclContextBitfields {
  friend class DeclContext;
  /// DeclKind - This indicates which class this is.
  uint64_t DeclKind : 7;

  /// Whether this declaration context also has some external
  /// storage that contains additional declarations that are lexically
  /// part of this context.
  mutable uint64_t ExternalLexicalStorage : 1;

  /// Whether this declaration context also has some external
  /// storage that contains additional declarations that are visible
  /// in this context.
  mutable uint64_t ExternalVisibleStorage : 1;

  /// Whether this declaration context has had externally visible
  /// storage added since the last lookup. In this case, \c LookupPtr's
  /// invariant may not hold and needs to be fixed before we perform
  /// another lookup.
  mutable uint64_t NeedToReconcileExternalVisibleStorage : 1;

  /// If \c true, this context may have local lexical declarations
  /// that are missing from the lookup table.
  mutable uint64_t HasLazyLocalLexicalLookups : 1;

  /// If \c true, the external source may have lexical declarations
  /// that are missing from the lookup table.
  mutable uint64_t HasLazyExternalLexicalLookups : 1;

  /// If \c true, lookups should only return identifier from
  /// DeclContext scope (for example TranslationUnit). Used in
  /// LookupQualifiedName()
  mutable uint64_t UseQualifiedLookup : 1;
};

/// Number of bits in DeclContextBitfields.
enum { NumDeclContextBits = 13 };

/// Stores the bits used by TagDecl.
/// If modified NumTagDeclBits and the accessor
/// methods in TagDecl should be updated appropriately.
class TagDeclBitfields {
  friend class TagDecl;
  /// For the bits in DeclContextBitfields
  uint64_t : NumDeclContextBits;

  /// The TagKind enum.
  uint64_t TagDeclKind : 3;

  /// True if this is a definition ("struct foo {};"), false if it is a
  /// declaration ("struct foo;").  It is not considered a definition
  /// until the definition has been fully processed.
  uint64_t IsCompleteDefinition : 1;

  /// True if this is currently being defined.
  uint64_t IsBeingDefined : 1;

  /// True if this tag declaration is "embedded" (i.e., defined or declared
  /// for the very first time) in the syntax of a declarator.
  uint64_t IsEmbeddedInDeclarator : 1;

  /// True if this tag is free standing, e.g. "struct foo;".
  uint64_t IsFreeStanding : 1;

  /// Indicates whether it is possible for declarations of this kind
  /// to have an out-of-date definition.
  ///
  /// This option is only enabled when modules are enabled.
  uint64_t MayHaveOutOfDateDef : 1;

  /// Has the full definition of this type been required by a use somewhere in
  /// the TU.
  uint64_t IsCompleteDefinitionRequired : 1;
};

/// Number of non-inherited bits in TagDeclBitfields.
enum { NumTagDeclBits = 9 };

/// Stores the bits used by EnumDecl.
/// If modified NumEnumDeclBit and the accessor
/// methods in EnumDecl should be updated appropriately.
class EnumDeclBitfields {
  friend class EnumDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;
  /// For the bits in TagDeclBitfields.
  uint64_t : NumTagDeclBits;

  /// Width in bits required to store all the non-negative
  /// enumerators of this enum.
  uint64_t NumPositiveBits : 8;

  /// Width in bits required to store all the negative
  /// enumerators of this enum.
  uint64_t NumNegativeBits : 8;

  /// True if this tag declaration is a scoped enumeration. Only
  /// possible in C++11 mode.
  uint64_t IsScoped : 1;

  /// If this tag declaration is a scoped enum,
  /// then this is true if the scoped enum was declared using the class
  /// tag, false if it was declared with the struct tag. No meaning is
  /// associated if this tag declaration is not a scoped enum.
  uint64_t IsScopedUsingClassTag : 1;

  /// True if this is an enumeration with fixed underlying type. Only
  /// possible in C++11, Microsoft extensions, or Objective C mode.
  uint64_t IsFixed : 1;

  /// True if a valid hash is stored in ODRHash.
  uint64_t HasODRHash : 1;
};

/// Number of non-inherited bits in EnumDeclBitfields.
enum { NumEnumDeclBits = 20 };

/// Stores the bits used by RecordDecl.
/// If modified NumRecordDeclBits and the accessor
/// methods in RecordDecl should be updated appropriately.
class RecordDeclBitfields {
  friend class RecordDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;
  /// For the bits in TagDeclBitfields.
  uint64_t : NumTagDeclBits;

  /// This is true if this struct ends with a flexible
  /// array member (e.g. int X[]) or if this union contains a struct that does.
  /// If so, this cannot be contained in arrays or other structs as a member.
  uint64_t HasFlexibleArrayMember : 1;

  /// Whether this is the type of an anonymous struct or union.
  uint64_t AnonymousStructOrUnion : 1;

  /// This is true if this struct has at least one member
  /// containing an Objective-C object pointer type.
  uint64_t HasObjectMember : 1;

  /// This is true if struct has at least one member of
  /// 'volatile' type.
  uint64_t HasVolatileMember : 1;

  /// Whether the field declarations of this record have been loaded
  /// from external storage. To avoid unnecessary deserialization of
  /// methods/nested types we allow deserialization of just the fields
  /// when needed.
  mutable uint64_t LoadedFieldsFromExternalStorage : 1;

  /// Basic properties of non-trivial C structs.
  uint64_t NonTrivialToPrimitiveDefaultInitialize : 1;
  uint64_t NonTrivialToPrimitiveCopy : 1;
  uint64_t NonTrivialToPrimitiveDestroy : 1;

  /// The following bits indicate whether this is or contains a C union that
  /// is non-trivial to default-initialize, destruct, or copy. These bits
  /// imply the associated basic non-triviality predicates declared above.
  uint64_t HasNonTrivialToPrimitiveDefaultInitializeCUnion : 1;
  uint64_t HasNonTrivialToPrimitiveDestructCUnion : 1;
  uint64_t HasNonTrivialToPrimitiveCopyCUnion : 1;

  /// Indicates whether this struct is destroyed in the callee.
  uint64_t ParamDestroyedInCallee : 1;

  /// Represents the way this type is passed to a function.
  uint64_t ArgPassingRestrictions : 2;
};

/// Number of non-inherited bits in RecordDeclBitfields.
enum { NumRecordDeclBits = 14 };

/// Stores the bits used by OMPDeclareReductionDecl.
/// If modified NumOMPDeclareReductionDeclBits and the accessor
/// methods in OMPDeclareReductionDecl should be updated appropriately.
class OMPDeclareReductionDeclBitfields {
  friend class OMPDeclareReductionDecl;
  /// For the bits in DeclContextBitfields
  uint64_t : NumDeclContextBits;

  /// Kind of initializer,
  /// function call or omp_priv<init_expr> initializtion.
  uint64_t InitializerKind : 2;
};

/// Number of non-inherited bits in OMPDeclareReductionDeclBitfields.
enum { NumOMPDeclareReductionDeclBits = 2 };

/// Stores the bits used by FunctionDecl.
/// If modified NumFunctionDeclBits and the accessor
/// methods in FunctionDecl and CXXDeductionGuideDecl
/// (for IsCopyDeductionCandidate) should be updated appropriately.
class FunctionDeclBitfields {
  friend class FunctionDecl;
  /// For IsCopyDeductionCandidate
  friend class CXXDeductionGuideDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;

  uint64_t SClass : 3;
  uint64_t IsInline : 1;
  uint64_t IsInlineSpecified : 1;

  uint64_t IsVirtualAsWritten : 1;
  uint64_t IsPure : 1;
  uint64_t HasInheritedPrototype : 1;
  uint64_t HasWrittenPrototype : 1;
  uint64_t IsDeleted : 1;
  /// Used by CXXMethodDecl
  uint64_t IsTrivial : 1;

  /// This flag indicates whether this function is trivial for the purpose of
  /// calls. This is meaningful only when this function is a copy/move
  /// constructor or a destructor.
  uint64_t IsTrivialForCall : 1;

  uint64_t IsDefaulted : 1;
  uint64_t IsExplicitlyDefaulted : 1;
  uint64_t HasDefaultedFunctionInfo : 1;
  uint64_t HasImplicitReturnZero : 1;
  uint64_t IsLateTemplateParsed : 1;

  /// Kind of contexpr specifier as defined by ConstexprSpecKind.
  uint64_t ConstexprKind : 2;
  uint64_t InstantiationIsPending : 1;

  /// Indicates if the function uses __try.
  uint64_t UsesSEHTry : 1;

  /// Indicates if the function was a definition
  /// but its body was skipped.
  uint64_t HasSkippedBody : 1;

  /// Indicates if the function declaration will
  /// have a body, once we're done parsing it.
  uint64_t WillHaveBody : 1;

  /// Indicates that this function is a multiversioned
  /// function using attribute 'target'.
  uint64_t IsMultiVersion : 1;

  /// [C++17] Only used by CXXDeductionGuideDecl. Indicates that
  /// the Deduction Guide is the implicitly generated 'copy
  /// deduction candidate' (is used during overload resolution).
  uint64_t IsCopyDeductionCandidate : 1;

  /// Store the ODRHash after first calculation.
  uint64_t HasODRHash : 1;

  /// Indicates if the function uses Floating Point Constrained Intrinsics
  uint64_t UsesFPIntrin : 1;
};

/// Number of non-inherited bits in FunctionDeclBitfields.
enum { NumFunctionDeclBits = 27 };

/// Stores the bits used by CXXConstructorDecl. If modified
/// NumCXXConstructorDeclBits and the accessor
/// methods in CXXConstructorDecl should be updated appropriately.
class CXXConstructorDeclBitfields {
  friend class CXXConstructorDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;
  /// For the bits in FunctionDeclBitfields.
  uint64_t : NumFunctionDeclBits;

  /// 24 bits to fit in the remaining available space.
  /// Note that this makes CXXConstructorDeclBitfields take
  /// exactly 64 bits and thus the width of NumCtorInitializers
  /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
  /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
  uint64_t NumCtorInitializers : 21;
  uint64_t IsInheritingConstructor : 1;

  /// Whether this constructor has a trail-allocated explicit specifier.
  uint64_t HasTrailingExplicitSpecifier : 1;
  /// If this constructor does't have a trail-allocated explicit specifier.
  /// Whether this constructor is explicit specified.
  uint64_t IsSimpleExplicit : 1;
};

/// Number of non-inherited bits in CXXConstructorDeclBitfields.
enum {
  NumCXXConstructorDeclBits = 64 - NumDeclContextBits - NumFunctionDeclBits
};

/// Stores the bits used by ObjCMethodDecl.
/// If modified NumObjCMethodDeclBits and the accessor
/// methods in ObjCMethodDecl should be updated appropriately.
class ObjCMethodDeclBitfields {
  friend class ObjCMethodDecl;

  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;

  /// The conventional meaning of this method; an ObjCMethodFamily.
  /// This is not serialized; instead, it is computed on demand and
  /// cached.
  mutable uint64_t Family : ObjCMethodFamilyBitWidth;

  /// instance (true) or class (false) method.
  uint64_t IsInstance : 1;
  uint64_t IsVariadic : 1;

  /// True if this method is the getter or setter for an explicit property.
  uint64_t IsPropertyAccessor : 1;

  /// True if this method is a synthesized property accessor stub.
  uint64_t IsSynthesizedAccessorStub : 1;

  /// Method has a definition.
  uint64_t IsDefined : 1;

  /// Method redeclaration in the same interface.
  uint64_t IsRedeclaration : 1;

  /// Is redeclared in the same interface.
  mutable uint64_t HasRedeclaration : 1;

  /// \@required/\@optional
  uint64_t DeclImplementation : 2;

  /// in, inout, etc.
  uint64_t objcDeclQualifier : 7;

  /// Indicates whether this method has a related result type.
  uint64_t RelatedResultType : 1;

  /// Whether the locations of the selector identifiers are in a
  /// "standard" position, a enum SelectorLocationsKind.
  uint64_t SelLocsKind : 2;

  /// Whether this method overrides any other in the class hierarchy.
  ///
  /// A method is said to override any method in the class's
  /// base classes, its protocols, or its categories' protocols, that has
  /// the same selector and is of the same kind (class or instance).
  /// A method in an implementation is not considered as overriding the same
  /// method in the interface or its categories.
  uint64_t IsOverriding : 1;

  /// Indicates if the method was a definition but its body was skipped.
  uint64_t HasSkippedBody : 1;
};

/// Number of non-inherited bits in ObjCMethodDeclBitfields.
enum { NumObjCMethodDeclBits = 24 };

/// Stores the bits used by ObjCContainerDecl.
/// If modified NumObjCContainerDeclBits and the accessor
/// methods in ObjCContainerDecl should be updated appropriately.
class ObjCContainerDeclBitfields {
  friend class ObjCContainerDecl;
  /// For the bits in DeclContextBitfields
  uint32_t : NumDeclContextBits;

  // Not a bitfield but this saves space.
  // Note that ObjCContainerDeclBitfields is full.
  SourceLocation AtStart;
};

/// Number of non-inherited bits in ObjCContainerDeclBitfields.
/// Note that here we rely on the fact that SourceLocation is 32 bits
/// wide. We check this with the static_assert in the ctor of DeclContext.
enum { NumObjCContainerDeclBits = 64 - NumDeclContextBits };

/// Stores the bits used by LinkageSpecDecl.
/// If modified NumLinkageSpecDeclBits and the accessor
/// methods in LinkageSpecDecl should be updated appropriately.
class LinkageSpecDeclBitfields {
  friend class LinkageSpecDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;

  /// The language for this linkage specification with values
  /// in the enum LinkageSpecDecl::LanguageIDs.
  uint64_t Language : 3;

  /// True if this linkage spec has braces.
  /// This is needed so that hasBraces() returns the correct result while the
  /// linkage spec body is being parsed.  Once RBraceLoc has been set this is
  /// not used, so it doesn't need to be serialized.
  uint64_t HasBraces : 1;
};

/// Number of non-inherited bits in LinkageSpecDeclBitfields.
enum { NumLinkageSpecDeclBits = 4 };

/// Stores the bits used by BlockDecl.
/// If modified NumBlockDeclBits and the accessor
/// methods in BlockDecl should be updated appropriately.
class BlockDeclBitfields {
  friend class BlockDecl;
  /// For the bits in DeclContextBitfields.
  uint64_t : NumDeclContextBits;

  uint64_t IsVariadic : 1;
  uint64_t CapturesCXXThis : 1;
  uint64_t BlockMissingReturnType : 1;
  uint64_t IsConversionFromLambda : 1;

  /// A bit that indicates this block is passed directly to a function as a
  /// non-escaping parameter.
  uint64_t DoesNotEscape : 1;

  /// A bit that indicates whether it's possible to avoid coying this block to
  /// the heap when it initializes or is assigned to a local variable with
  /// automatic storage.
  uint64_t CanAvoidCopyToHeap : 1;
};

/// Number of non-inherited bits in BlockDeclBitfields.
enum { NumBlockDeclBits = 5 };

/// Pointer to the data structure used to lookup declarations
/// within this context (or a DependentStoredDeclsMap if this is a
/// dependent context). We maintain the invariant that, if the map
/// contains an entry for a DeclarationName (and we haven't lazily
/// omitted anything), then it contains all relevant entries for that
/// name (modulo the hasExternalDecls() flag).
mutable StoredDeclsMap *LookupPtr = nullptr;

1786protected:
/// This anonymous union stores the bits belonging to DeclContext and classes
/// deriving from it. The goal is to use otherwise wasted
/// space in DeclContext to store data belonging to derived classes.
/// The space saved is especially significient when pointers are aligned
/// to 8 bytes. In this case due to alignment requirements we have a
/// little less than 8 bytes free in DeclContext which we can use.
/// We check that none of the classes in this union is larger than
/// 8 bytes with static_asserts in the ctor of DeclContext.
union {
  DeclContextBitfields DeclContextBits;
  TagDeclBitfields TagDeclBits;
  EnumDeclBitfields EnumDeclBits;
  RecordDeclBitfields RecordDeclBits;
  OMPDeclareReductionDeclBitfields OMPDeclareReductionDeclBits;
  FunctionDeclBitfields FunctionDeclBits;
  CXXConstructorDeclBitfields CXXConstructorDeclBits;
  ObjCMethodDeclBitfields ObjCMethodDeclBits;
  ObjCContainerDeclBitfields ObjCContainerDeclBits;
  LinkageSpecDeclBitfields LinkageSpecDeclBits;
  BlockDeclBitfields BlockDeclBits;

  static_assert(sizeof(DeclContextBitfields) <= 8,
                "DeclContextBitfields is larger than 8 bytes!");
  static_assert(sizeof(TagDeclBitfields) <= 8,
                "TagDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(EnumDeclBitfields) <= 8,
                "EnumDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(RecordDeclBitfields) <= 8,
                "RecordDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(OMPDeclareReductionDeclBitfields) <= 8,
                "OMPDeclareReductionDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(FunctionDeclBitfields) <= 8,
                "FunctionDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(CXXConstructorDeclBitfields) <= 8,
                "CXXConstructorDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(ObjCMethodDeclBitfields) <= 8,
                "ObjCMethodDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(ObjCContainerDeclBitfields) <= 8,
                "ObjCContainerDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(LinkageSpecDeclBitfields) <= 8,
                "LinkageSpecDeclBitfields is larger than 8 bytes!");
  static_assert(sizeof(BlockDeclBitfields) <= 8,
                "BlockDeclBitfields is larger than 8 bytes!");
};

/// FirstDecl - The first declaration stored within this declaration
/// context.
mutable Decl *FirstDecl = nullptr;

/// LastDecl - The last declaration stored within this declaration
/// context. FIXME: We could probably cache this value somewhere
/// outside of the DeclContext, to reduce the size of DeclContext by
/// another pointer.
mutable Decl *LastDecl = nullptr;

/// Build up a chain of declarations.
///
/// \returns the first/last pair of declarations.
static std::pair<Decl *, Decl *>
BuildDeclChain(ArrayRef<Decl*> Decls, bool FieldsAlreadyLoaded);

DeclContext(Decl::Kind K);

1850public:
~DeclContext();

Decl::Kind getDeclKind() const {
  return static_cast<Decl::Kind>(DeclContextBits.DeclKind);
}

const char *getDeclKindName() const;

/// getParent - Returns the containing DeclContext.
DeclContext *getParent() {
  return cast<Decl>(this)->getDeclContext();
}
const DeclContext *getParent() const {
  return const_cast<DeclContext*>(this)->getParent();
}

/// getLexicalParent - Returns the containing lexical DeclContext. May be
/// different from getParent, e.g.:
///
///   namespace A {
///      struct S;
///   }
///   struct A::S {}; // getParent() == namespace 'A'
///                   // getLexicalParent() == translation unit
///
DeclContext *getLexicalParent() {
  return cast<Decl>(this)->getLexicalDeclContext();
}
const DeclContext *getLexicalParent() const {
  return const_cast<DeclContext*>(this)->getLexicalParent();
}

DeclContext *getLookupParent();

const DeclContext *getLookupParent() const {
  return const_cast<DeclContext*>(this)->getLookupParent();
}

ASTContext &getParentASTContext() const {
  return cast<Decl>(this)->getASTContext();
}

bool isClosure() const { return getDeclKind() == Decl::Block; }

/// Return this DeclContext if it is a BlockDecl. Otherwise, return the
/// innermost enclosing BlockDecl or null if there are no enclosing blocks.
const BlockDecl *getInnermostBlockDecl() const;

bool isObjCContainer() const {
  switch (getDeclKind()) {
  case Decl::ObjCCategory:
  case Decl::ObjCCategoryImpl:
  case Decl::ObjCImplementation:
  case Decl::ObjCInterface:
  case Decl::ObjCProtocol:
    return true;
  default:
    return false;
  }
}

bool isFunctionOrMethod() const {
  switch (getDeclKind()) {
16
←
Control jumps to the 'default' case at line 1918→
  case Decl::Block:
  case Decl::Captured:
  case Decl::ObjCMethod:
    return true;
  default:
    return getDeclKind() >= Decl::firstFunction &&
17
←
Assuming the condition is false→
18
←
Returning zero, which participates in a condition later→
           getDeclKind() <= Decl::lastFunction;
  }
}

/// Test whether the context supports looking up names.
bool isLookupContext() const {
  return !isFunctionOrMethod() && getDeclKind() != Decl::LinkageSpec &&
         getDeclKind() != Decl::Export;
}

bool isFileContext() const {
  return getDeclKind() == Decl::TranslationUnit ||
         getDeclKind() == Decl::Namespace;
}

bool isTranslationUnit() const {
  return getDeclKind() == Decl::TranslationUnit;
}

bool isRecord() const {
  return getDeclKind() >= Decl::firstRecord &&
         getDeclKind() <= Decl::lastRecord;
}

bool isNamespace() const { return getDeclKind() == Decl::Namespace; }

bool isStdNamespace() const;

bool isInlineNamespace() const;

/// Determines whether this context is dependent on a
/// template parameter.
bool isDependentContext() const;

/// isTransparentContext - Determines whether this context is a
/// "transparent" context, meaning that the members declared in this
/// context are semantically declared in the nearest enclosing
/// non-transparent (opaque) context but are lexically declared in
/// this context. For example, consider the enumerators of an
/// enumeration type:
/// @code
/// enum E {
///   Val1
/// };
/// @endcode
/// Here, E is a transparent context, so its enumerator (Val1) will
/// appear (semantically) that it is in the same context of E.
/// Examples of transparent contexts include: enumerations (except for
/// C++0x scoped enums), and C++ linkage specifications.
bool isTransparentContext() const;

/// Determines whether this context or some of its ancestors is a
/// linkage specification context that specifies C linkage.
bool isExternCContext() const;

/// Retrieve the nearest enclosing C linkage specification context.
const LinkageSpecDecl *getExternCContext() const;

/// Determines whether this context or some of its ancestors is a
/// linkage specification context that specifies C++ linkage.
bool isExternCXXContext() const;

/// Determine whether this declaration context is equivalent
/// to the declaration context DC.
bool Equals(const DeclContext *DC) const {
  return DC && this->getPrimaryContext() == DC->getPrimaryContext();
}

/// Determine whether this declaration context encloses the
/// declaration context DC.
bool Encloses(const DeclContext *DC) const;

/// Find the nearest non-closure ancestor of this context,
/// i.e. the innermost semantic parent of this context which is not
/// a closure.  A context may be its own non-closure ancestor.
Decl *getNonClosureAncestor();
const Decl *getNonClosureAncestor() const {
  return const_cast<DeclContext*>(this)->getNonClosureAncestor();
}

// Retrieve the nearest context that is not a transparent context.
DeclContext *getNonTransparentContext();
const DeclContext *getNonTransparentContext() const {
  return const_cast<DeclContext *>(this)->getNonTransparentContext();
}

/// getPrimaryContext - There may be many different
/// declarations of the same entity (including forward declarations
/// of classes, multiple definitions of namespaces, etc.), each with
/// a different set of declarations. This routine returns the
/// "primary" DeclContext structure, which will contain the
/// information needed to perform name lookup into this context.
DeclContext *getPrimaryContext();
const DeclContext *getPrimaryContext() const {
  return const_cast<DeclContext*>(this)->getPrimaryContext();
}

/// getRedeclContext - Retrieve the context in which an entity conflicts with
/// other entities of the same name, or where it is a redeclaration if the
/// two entities are compatible. This skips through transparent contexts.
DeclContext *getRedeclContext();
const DeclContext *getRedeclContext() const {
  return const_cast<DeclContext *>(this)->getRedeclContext();
}

/// Retrieve the nearest enclosing namespace context.
DeclContext *getEnclosingNamespaceContext();
const DeclContext *getEnclosingNamespaceContext() const {
  return const_cast<DeclContext *>(this)->getEnclosingNamespaceContext();
}

/// Retrieve the outermost lexically enclosing record context.
RecordDecl *getOuterLexicalRecordContext();
const RecordDecl *getOuterLexicalRecordContext() const {
  return const_cast<DeclContext *>(this)->getOuterLexicalRecordContext();
}

/// Test if this context is part of the enclosing namespace set of
/// the context NS, as defined in C++0x [namespace.def]p9. If either context
/// isn't a namespace, this is equivalent to Equals().
///
/// The enclosing namespace set of a namespace is the namespace and, if it is
/// inline, its enclosing namespace, recursively.
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const;

/// Collects all of the declaration contexts that are semantically
/// connected to this declaration context.
///
/// For declaration contexts that have multiple semantically connected but
/// syntactically distinct contexts, such as C++ namespaces, this routine
/// retrieves the complete set of such declaration contexts in source order.
/// For example, given:
///
/// \code
/// namespace N {
///   int x;
/// }
/// namespace N {
///   int y;
/// }
/// \endcode
///
/// The \c Contexts parameter will contain both definitions of N.
///
/// \param Contexts Will be cleared and set to the set of declaration
/// contexts that are semanticaly connected to this declaration context,
/// in source order, including this context (which may be the only result,
/// for non-namespace contexts).
void collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts);

/// decl_iterator - Iterates through the declarations stored
/// within this context.
class decl_iterator {
  /// Current - The current declaration.
  Decl *Current = nullptr;

public:
  using value_type = Decl *;
  using reference = const value_type &;
  using pointer = const value_type *;
  using iterator_category = std::forward_iterator_tag;
  using difference_type = std::ptrdiff_t;

  decl_iterator() = default;
  explicit decl_iterator(Decl *C) : Current(C) {}

  reference operator*() const { return Current; }

  // This doesn't meet the iterator requirements, but it's convenient
  value_type operator->() const { return Current; }

  decl_iterator& operator++() {
    Current = Current->getNextDeclInContext();
    return *this;
  }

  decl_iterator operator++(int) {
    decl_iterator tmp(*this);
    ++(*this);
    return tmp;
  }

  friend bool operator==(decl_iterator x, decl_iterator y) {
    return x.Current == y.Current;
  }

  friend bool operator!=(decl_iterator x, decl_iterator y) {
    return x.Current != y.Current;
  }
};

using decl_range = llvm::iterator_range<decl_iterator>;

/// decls_begin/decls_end - Iterate over the declarations stored in
/// this context.
decl_range decls() const { return decl_range(decls_begin(), decls_end()); }
decl_iterator decls_begin() const;
decl_iterator decls_end() const { return decl_iterator(); }
bool decls_empty() const;

/// noload_decls_begin/end - Iterate over the declarations stored in this
/// context that are currently loaded; don't attempt to retrieve anything
/// from an external source.
decl_range noload_decls() const {
  return decl_range(noload_decls_begin(), noload_decls_end());
}
decl_iterator noload_decls_begin() const { return decl_iterator(FirstDecl); }
decl_iterator noload_decls_end() const { return decl_iterator(); }

/// specific_decl_iterator - Iterates over a subrange of
/// declarations stored in a DeclContext, providing only those that
/// are of type SpecificDecl (or a class derived from it). This
/// iterator is used, for example, to provide iteration over just
/// the fields within a RecordDecl (with SpecificDecl = FieldDecl).
template<typename SpecificDecl>
class specific_decl_iterator {
  /// Current - The current, underlying declaration iterator, which
  /// will either be NULL or will point to a declaration of
  /// type SpecificDecl.
  DeclContext::decl_iterator Current;

  /// SkipToNextDecl - Advances the current position up to the next
  /// declaration of type SpecificDecl that also meets the criteria
  /// required by Acceptable.
  void SkipToNextDecl() {
    while (*Current && !isa<SpecificDecl>(*Current))
      ++Current;
  }

public:
  using value_type = SpecificDecl *;
  // TODO: Add reference and pointer types (with some appropriate proxy type)
  // if we ever have a need for them.
  using reference = void;
  using pointer = void;
  using difference_type =
      std::iterator_traits<DeclContext::decl_iterator>::difference_type;
  using iterator_category = std::forward_iterator_tag;

  specific_decl_iterator() = default;

  /// specific_decl_iterator - Construct a new iterator over a
  /// subset of the declarations the range [C,
  /// end-of-declarations). If A is non-NULL, it is a pointer to a
  /// member function of SpecificDecl that should return true for
  /// all of the SpecificDecl instances that will be in the subset
  /// of iterators. For example, if you want Objective-C instance
  /// methods, SpecificDecl will be ObjCMethodDecl and A will be
  /// &ObjCMethodDecl::isInstanceMethod.
  explicit specific_decl_iterator(DeclContext::decl_iterator C) : Current(C) {
    SkipToNextDecl();
  }

  value_type operator*() const { return cast<SpecificDecl>(*Current); }

  // This doesn't meet the iterator requirements, but it's convenient
  value_type operator->() const { return **this; }

  specific_decl_iterator& operator++() {
    ++Current;
    SkipToNextDecl();
    return *this;
  }

  specific_decl_iterator operator++(int) {
    specific_decl_iterator tmp(*this);
    ++(*this);
    return tmp;
  }

  friend bool operator==(const specific_decl_iterator& x,
                         const specific_decl_iterator& y) {
    return x.Current == y.Current;
  }

  friend bool operator!=(const specific_decl_iterator& x,
                         const specific_decl_iterator& y) {
    return x.Current != y.Current;
  }
};

/// Iterates over a filtered subrange of declarations stored
/// in a DeclContext.
///
/// This iterator visits only those declarations that are of type
/// SpecificDecl (or a class derived from it) and that meet some
/// additional run-time criteria. This iterator is used, for
/// example, to provide access to the instance methods within an
/// Objective-C interface (with SpecificDecl = ObjCMethodDecl and
/// Acceptable = ObjCMethodDecl::isInstanceMethod).
template<typename SpecificDecl, bool (SpecificDecl::*Acceptable)() const>
class filtered_decl_iterator {
  /// Current - The current, underlying declaration iterator, which
  /// will either be NULL or will point to a declaration of
  /// type SpecificDecl.
  DeclContext::decl_iterator Current;

  /// SkipToNextDecl - Advances the current position up to the next
  /// declaration of type SpecificDecl that also meets the criteria
  /// required by Acceptable.
  void SkipToNextDecl() {
    while (*Current &&
           (!isa<SpecificDecl>(*Current) ||
            (Acceptable && !(cast<SpecificDecl>(*Current)->*Acceptable)())))
      ++Current;
  }

public:
  using value_type = SpecificDecl *;
  // TODO: Add reference and pointer types (with some appropriate proxy type)
  // if we ever have a need for them.
  using reference = void;
  using pointer = void;
  using difference_type =
      std::iterator_traits<DeclContext::decl_iterator>::difference_type;
  using iterator_category = std::forward_iterator_tag;

  filtered_decl_iterator() = default;

  /// filtered_decl_iterator - Construct a new iterator over a
  /// subset of the declarations the range [C,
  /// end-of-declarations). If A is non-NULL, it is a pointer to a
  /// member function of SpecificDecl that should return true for
  /// all of the SpecificDecl instances that will be in the subset
  /// of iterators. For example, if you want Objective-C instance
  /// methods, SpecificDecl will be ObjCMethodDecl and A will be
  /// &ObjCMethodDecl::isInstanceMethod.
  explicit filtered_decl_iterator(DeclContext::decl_iterator C) : Current(C) {
    SkipToNextDecl();
  }

  value_type operator*() const { return cast<SpecificDecl>(*Current); }
  value_type operator->() const { return cast<SpecificDecl>(*Current); }

  filtered_decl_iterator& operator++() {
    ++Current;
    SkipToNextDecl();
    return *this;
  }

  filtered_decl_iterator operator++(int) {
    filtered_decl_iterator tmp(*this);
    ++(*this);
    return tmp;
  }

  friend bool operator==(const filtered_decl_iterator& x,
                         const filtered_decl_iterator& y) {
    return x.Current == y.Current;
  }

  friend bool operator!=(const filtered_decl_iterator& x,
                         const filtered_decl_iterator& y) {
    return x.Current != y.Current;
  }
};

/// Add the declaration D into this context.
///
/// This routine should be invoked when the declaration D has first
/// been declared, to place D into the context where it was
/// (lexically) defined. Every declaration must be added to one
/// (and only one!) context, where it can be visited via
/// [decls_begin(), decls_end()). Once a declaration has been added
/// to its lexical context, the corresponding DeclContext owns the
/// declaration.
///
/// If D is also a NamedDecl, it will be made visible within its
/// semantic context via makeDeclVisibleInContext.
void addDecl(Decl *D);

/// Add the declaration D into this context, but suppress
/// searches for external declarations with the same name.
///
/// Although analogous in function to addDecl, this removes an
/// important check.  This is only useful if the Decl is being
/// added in response to an external search; in all other cases,
/// addDecl() is the right function to use.
/// See the ASTImporter for use cases.
void addDeclInternal(Decl *D);

/// Add the declaration D to this context without modifying
/// any lookup tables.
///
/// This is useful for some operations in dependent contexts where
/// the semantic context might not be dependent;  this basically
/// only happens with friends.
void addHiddenDecl(Decl *D);

/// Removes a declaration from this context.
void removeDecl(Decl *D);

/// Checks whether a declaration is in this context.
bool containsDecl(Decl *D) const;

/// Checks whether a declaration is in this context.
/// This also loads the Decls from the external source before the check.
bool containsDeclAndLoad(Decl *D) const;

using lookup_result = DeclContextLookupResult;
using lookup_iterator = lookup_result::iterator;

/// lookup - Find the declarations (if any) with the given Name in
/// this context. Returns a range of iterators that contains all of
/// the declarations with this name, with object, function, member,
/// and enumerator names preceding any tag name. Note that this
/// routine will not look into parent contexts.
lookup_result lookup(DeclarationName Name) const;

/// Find the declarations with the given name that are visible
/// within this context; don't attempt to retrieve anything from an
/// external source.
lookup_result noload_lookup(DeclarationName Name);

/// A simplistic name lookup mechanism that performs name lookup
/// into this declaration context without consulting the external source.
///
/// This function should almost never be used, because it subverts the
/// usual relationship between a DeclContext and the external source.
/// See the ASTImporter for the (few, but important) use cases.
///
/// FIXME: This is very inefficient; replace uses of it with uses of
/// noload_lookup.
void localUncachedLookup(DeclarationName Name,
                         SmallVectorImpl<NamedDecl *> &Results);

/// Makes a declaration visible within this context.
///
/// This routine makes the declaration D visible to name lookup
/// within this context and, if this is a transparent context,
/// within its parent contexts up to the first enclosing
/// non-transparent context. Making a declaration visible within a
/// context does not transfer ownership of a declaration, and a
/// declaration can be visible in many contexts that aren't its
/// lexical context.
///
/// If D is a redeclaration of an existing declaration that is
/// visible from this context, as determined by
/// NamedDecl::declarationReplaces, the previous declaration will be
/// replaced with D.
void makeDeclVisibleInContext(NamedDecl *D);

/// all_lookups_iterator - An iterator that provides a view over the results
/// of looking up every possible name.
class all_lookups_iterator;

using lookups_range = llvm::iterator_range<all_lookups_iterator>;

lookups_range lookups() const;
// Like lookups(), but avoids loading external declarations.
// If PreserveInternalState, avoids building lookup data structures too.
lookups_range noload_lookups(bool PreserveInternalState) const;

/// Iterators over all possible lookups within this context.
all_lookups_iterator lookups_begin() const;
all_lookups_iterator lookups_end() const;

/// Iterators over all possible lookups within this context that are
/// currently loaded; don't attempt to retrieve anything from an external
/// source.
all_lookups_iterator noload_lookups_begin() const;
all_lookups_iterator noload_lookups_end() const;

struct udir_iterator;

using udir_iterator_base =
    llvm::iterator_adaptor_base<udir_iterator, lookup_iterator,
                                typename lookup_iterator::iterator_category,
                                UsingDirectiveDecl *>;

struct udir_iterator : udir_iterator_base {
  udir_iterator(lookup_iterator I) : udir_iterator_base(I) {}

  UsingDirectiveDecl *operator*() const;
};

using udir_range = llvm::iterator_range<udir_iterator>;

udir_range using_directives() const;

// These are all defined in DependentDiagnostic.h.
class ddiag_iterator;

using ddiag_range = llvm::iterator_range<DeclContext::ddiag_iterator>;

inline ddiag_range ddiags() const;

// Low-level accessors

/// Mark that there are external lexical declarations that we need
/// to include in our lookup table (and that are not available as external
/// visible lookups). These extra lookup results will be found by walking
/// the lexical declarations of this context. This should be used only if
/// setHasExternalLexicalStorage() has been called on any decl context for
/// which this is the primary context.
void setMustBuildLookupTable() {
  assert(this == getPrimaryContext() &&(static_cast <bool> (this == getPrimaryContext() &&
 "should only be called on primary context") ? void (0) : __assert_fail
 ("this == getPrimaryContext() && \"should only be called on primary context\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 2417, __extension__ __PRETTY_FUNCTION__))
         "should only be called on primary context")(static_cast <bool> (this == getPrimaryContext() &&
 "should only be called on primary context") ? void (0) : __assert_fail
 ("this == getPrimaryContext() && \"should only be called on primary context\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/DeclBase.h"
, 2417, __extension__ __PRETTY_FUNCTION__));
  DeclContextBits.HasLazyExternalLexicalLookups = true;
}

/// Retrieve the internal representation of the lookup structure.
/// This may omit some names if we are lazily building the structure.
StoredDeclsMap *getLookupPtr() const { return LookupPtr; }

/// Ensure the lookup structure is fully-built and return it.
StoredDeclsMap *buildLookup();

/// Whether this DeclContext has external storage containing
/// additional declarations that are lexically in this context.
bool hasExternalLexicalStorage() const {
  return DeclContextBits.ExternalLexicalStorage;
}

/// State whether this DeclContext has external storage for
/// declarations lexically in this context.
void setHasExternalLexicalStorage(bool ES = true) const {
  DeclContextBits.ExternalLexicalStorage = ES;
}

/// Whether this DeclContext has external storage containing
/// additional declarations that are visible in this context.
bool hasExternalVisibleStorage() const {
  return DeclContextBits.ExternalVisibleStorage;
}

/// State whether this DeclContext has external storage for
/// declarations visible in this context.
void setHasExternalVisibleStorage(bool ES = true) const {
  DeclContextBits.ExternalVisibleStorage = ES;
  if (ES && LookupPtr)
    DeclContextBits.NeedToReconcileExternalVisibleStorage = true;
}

/// Determine whether the given declaration is stored in the list of
/// declarations lexically within this context.
bool isDeclInLexicalTraversal(const Decl *D) const {
  return D && (D->NextInContextAndBits.getPointer() || D == FirstDecl ||
               D == LastDecl);
}

bool setUseQualifiedLookup(bool use = true) const {
  bool old_value = DeclContextBits.UseQualifiedLookup;
  DeclContextBits.UseQualifiedLookup = use;
  return old_value;
}

bool shouldUseQualifiedLookup() const {
  return DeclContextBits.UseQualifiedLookup;
}

static bool classof(const Decl *D);
static bool classof(const DeclContext *D) { return true; }

void dumpDeclContext() const;
void dumpLookups() const;
void dumpLookups(llvm::raw_ostream &OS, bool DumpDecls = false,
                 bool Deserialize = false) const;

2479private:
/// Whether this declaration context has had externally visible
/// storage added since the last lookup. In this case, \c LookupPtr's
/// invariant may not hold and needs to be fixed before we perform
/// another lookup.
bool hasNeedToReconcileExternalVisibleStorage() const {
  return DeclContextBits.NeedToReconcileExternalVisibleStorage;
}

/// State that this declaration context has had externally visible
/// storage added since the last lookup. In this case, \c LookupPtr's
/// invariant may not hold and needs to be fixed before we perform
/// another lookup.
void setNeedToReconcileExternalVisibleStorage(bool Need = true) const {
  DeclContextBits.NeedToReconcileExternalVisibleStorage = Need;
}

/// If \c true, this context may have local lexical declarations
/// that are missing from the lookup table.
bool hasLazyLocalLexicalLookups() const {
  return DeclContextBits.HasLazyLocalLexicalLookups;
}

/// If \c true, this context may have local lexical declarations
/// that are missing from the lookup table.
void setHasLazyLocalLexicalLookups(bool HasLLLL = true) const {
  DeclContextBits.HasLazyLocalLexicalLookups = HasLLLL;
}

/// If \c true, the external source may have lexical declarations
/// that are missing from the lookup table.
bool hasLazyExternalLexicalLookups() const {
  return DeclContextBits.HasLazyExternalLexicalLookups;
}

/// If \c true, the external source may have lexical declarations
/// that are missing from the lookup table.
void setHasLazyExternalLexicalLookups(bool HasLELL = true) const {
  DeclContextBits.HasLazyExternalLexicalLookups = HasLELL;
}

void reconcileExternalVisibleStorage() const;
bool LoadLexicalDeclsFromExternalStorage() const;

/// Makes a declaration visible within this context, but
/// suppresses searches for external declarations with the same
/// name.
///
/// Analogous to makeDeclVisibleInContext, but for the exclusive
/// use of addDeclInternal().
void makeDeclVisibleInContextInternal(NamedDecl *D);

StoredDeclsMap *CreateStoredDeclsMap(ASTContext &C) const;

void loadLazyLocalLexicalLookups();
void buildLookupImpl(DeclContext *DCtx, bool Internal);
void makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
                                       bool Rediscoverable);
void makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal);
2538};

2540inline bool Decl::isTemplateParameter() const {
return getKind() == TemplateTypeParm || getKind() == NonTypeTemplateParm ||
       getKind() == TemplateTemplateParm;
2543}

2545// Specialization selected when ToTy is not a known subclass of DeclContext.
2546template <class ToTy,
        bool IsKnownSubtype = ::std::is_base_of<DeclContext, ToTy>::value>
2548struct cast_convert_decl_context {
static const ToTy *doit(const DeclContext *Val) {
  return static_cast<const ToTy*>(Decl::castFromDeclContext(Val));
}

static ToTy *doit(DeclContext *Val) {
  return static_cast<ToTy*>(Decl::castFromDeclContext(Val));
}
2556};

2558// Specialization selected when ToTy is a known subclass of DeclContext.
2559template <class ToTy>
2560struct cast_convert_decl_context<ToTy, true> {
static const ToTy *doit(const DeclContext *Val) {
  return static_cast<const ToTy*>(Val);
}

static ToTy *doit(DeclContext *Val) {
  return static_cast<ToTy*>(Val);
}
2568};

2570} // namespace clang

2572namespace llvm {

2574/// isa<T>(DeclContext*)
2575template <typename To>
2576struct isa_impl<To, ::clang::DeclContext> {
static bool doit(const ::clang::DeclContext &Val) {
  return To::classofKind(Val.getDeclKind());
}
2580};

2582/// cast<T>(DeclContext*)
2583template<class ToTy>
2584struct cast_convert_val<ToTy,
                      const ::clang::DeclContext,const ::clang::DeclContext> {
static const ToTy &doit(const ::clang::DeclContext &Val) {
  return *::clang::cast_convert_decl_context<ToTy>::doit(&Val);
}
2589};

2591template<class ToTy>
2592struct cast_convert_val<ToTy, ::clang::DeclContext, ::clang::DeclContext> {
static ToTy &doit(::clang::DeclContext &Val) {
  return *::clang::cast_convert_decl_context<ToTy>::doit(&Val);
}
2596};

2598template<class ToTy>
2599struct cast_convert_val<ToTy,
                   const ::clang::DeclContext*, const ::clang::DeclContext*> {
static const ToTy *doit(const ::clang::DeclContext *Val) {
  return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
}
2604};

2606template<class ToTy>
2607struct cast_convert_val<ToTy, ::clang::DeclContext*, ::clang::DeclContext*> {
static ToTy *doit(::clang::DeclContext *Val) {
  return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
}
2611};

2613/// Implement cast_convert_val for Decl -> DeclContext conversions.
2614template<class FromTy>
2615struct cast_convert_val< ::clang::DeclContext, FromTy, FromTy> {
static ::clang::DeclContext &doit(const FromTy &Val) {
  return *FromTy::castToDeclContext(&Val);
}
2619};

2621template<class FromTy>
2622struct cast_convert_val< ::clang::DeclContext, FromTy*, FromTy*> {
static ::clang::DeclContext *doit(const FromTy *Val) {
  return FromTy::castToDeclContext(Val);
}
2626};

2628template<class FromTy>
2629struct cast_convert_val< const ::clang::DeclContext, FromTy, FromTy> {
static const ::clang::DeclContext &doit(const FromTy &Val) {
  return *FromTy::castToDeclContext(&Val);
}
2633};

2635template<class FromTy>
2636struct cast_convert_val< const ::clang::DeclContext, FromTy*, FromTy*> {
static const ::clang::DeclContext *doit(const FromTy *Val) {
  return FromTy::castToDeclContext(Val);
}
2640};

2642} // namespace llvm

2644#endif // LLVM_CLANG_AST_DECLBASE_H

←

/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h

→

1//===- llvm/Support/Error.h - Recoverable error handling --------*- C++ -*-===//
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 an API used to report recoverable errors.
10//
11//===----------------------------------------------------------------------===//
12 
13#ifndef LLVM_SUPPORT_ERROR_H
14#define LLVM_SUPPORT_ERROR_H
15 
16#include "llvm-c/Error.h"
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/ADT/Twine.h"
21#include "llvm/Config/abi-breaking.h"
22#include "llvm/Support/AlignOf.h"
23#include "llvm/Support/Compiler.h"
24#include "llvm/Support/Debug.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/ErrorOr.h"
27#include "llvm/Support/Format.h"
28#include "llvm/Support/raw_ostream.h"
29#include <algorithm>
30#include <cassert>
31#include <cstdint>
32#include <cstdlib>
33#include <functional>
34#include <memory>
35#include <new>
36#include <string>
37#include <system_error>
38#include <type_traits>
39#include <utility>
40#include <vector>
41 
42namespace llvm {
43 
44class ErrorSuccess;
45 
46/// Base class for error info classes. Do not extend this directly: Extend
47/// the ErrorInfo template subclass instead.
48class ErrorInfoBase {
49public:
50  virtual ~ErrorInfoBase() = default;
51 
52  /// Print an error message to an output stream.
53  virtual void log(raw_ostream &OS) const = 0;
54 
55  /// Return the error message as a string.
56  virtual std::string message() const {
57    std::string Msg;
58    raw_string_ostream OS(Msg);
59    log(OS);
60    return OS.str();
61  }
62 
63  /// Convert this error to a std::error_code.
64  ///
65  /// This is a temporary crutch to enable interaction with code still
66  /// using std::error_code. It will be removed in the future.
67  virtual std::error_code convertToErrorCode() const = 0;
68 
69  // Returns the class ID for this type.
70  static const void *classID() { return &ID; }
71 
72  // Returns the class ID for the dynamic type of this ErrorInfoBase instance.
73  virtual const void *dynamicClassID() const = 0;
74 
75  // Check whether this instance is a subclass of the class identified by
76  // ClassID.
77  virtual bool isA(const void *const ClassID) const {
78    return ClassID == classID();
79  }
80 
81  // Check whether this instance is a subclass of ErrorInfoT.
82  template <typename ErrorInfoT> bool isA() const {
83    return isA(ErrorInfoT::classID());
84  }
85 
86private:
87  virtual void anchor();
88 
89  static char ID;
90};
91 
92/// Lightweight error class with error context and mandatory checking.
93///
94/// Instances of this class wrap a ErrorInfoBase pointer. Failure states
95/// are represented by setting the pointer to a ErrorInfoBase subclass
96/// instance containing information describing the failure. Success is
97/// represented by a null pointer value.
98///
99/// Instances of Error also contains a 'Checked' flag, which must be set
100/// before the destructor is called, otherwise the destructor will trigger a
101/// runtime error. This enforces at runtime the requirement that all Error
102/// instances be checked or returned to the caller.
103///
104/// There are two ways to set the checked flag, depending on what state the
105/// Error instance is in. For Error instances indicating success, it
106/// is sufficient to invoke the boolean conversion operator. E.g.:
107///
108///   @code{.cpp}
109///   Error foo(<...>);
110///
111///   if (auto E = foo(<...>))
112///     return E; // <- Return E if it is in the error state.
113///   // We have verified that E was in the success state. It can now be safely
114///   // destroyed.
115///   @endcode
116///
117/// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
118/// without testing the return value will raise a runtime error, even if foo
119/// returns success.
120///
121/// For Error instances representing failure, you must use either the
122/// handleErrors or handleAllErrors function with a typed handler. E.g.:
123///
124///   @code{.cpp}
125///   class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
126///     // Custom error info.
127///   };
128///
129///   Error foo(<...>) { return make_error<MyErrorInfo>(...); }
130///
131///   auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
132///   auto NewE =
133///     handleErrors(E,
134///       [](const MyErrorInfo &M) {
135///         // Deal with the error.
136///       },
137///       [](std::unique_ptr<OtherError> M) -> Error {
138///         if (canHandle(*M)) {
139///           // handle error.
140///           return Error::success();
141///         }
142///         // Couldn't handle this error instance. Pass it up the stack.
143///         return Error(std::move(M));
144///       );
145///   // Note - we must check or return NewE in case any of the handlers
146///   // returned a new error.
147///   @endcode
148///
149/// The handleAllErrors function is identical to handleErrors, except
150/// that it has a void return type, and requires all errors to be handled and
151/// no new errors be returned. It prevents errors (assuming they can all be
152/// handled) from having to be bubbled all the way to the top-level.
153///
154/// *All* Error instances must be checked before destruction, even if
155/// they're moved-assigned or constructed from Success values that have already
156/// been checked. This enforces checking through all levels of the call stack.
157class LLVM_NODISCARD[[clang::warn_unused_result]] Error {
158  // ErrorList needs to be able to yank ErrorInfoBase pointers out of Errors
159  // to add to the error list. It can't rely on handleErrors for this, since
160  // handleErrors does not support ErrorList handlers.
161  friend class ErrorList;
162 
163  // handleErrors needs to be able to set the Checked flag.
164  template <typename... HandlerTs>
165  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
166 
167  // Expected<T> needs to be able to steal the payload when constructed from an
168  // error.
169  template <typename T> friend class Expected;
170 
171  // wrap needs to be able to steal the payload.
172  friend LLVMErrorRef wrap(Error);
173 
174protected:
175  /// Create a success value. Prefer using 'Error::success()' for readability
176  Error() {
177    setPtr(nullptr);
178    setChecked(false);
179  }
180 
181public:
182  /// Create a success value.
183  static ErrorSuccess success();
184 
185  // Errors are not copy-constructable.
186  Error(const Error &Other) = delete;
187 
188  /// Move-construct an error value. The newly constructed error is considered
189  /// unchecked, even if the source error had been checked. The original error
190  /// becomes a checked Success value, regardless of its original state.
191  Error(Error &&Other) {
192    setChecked(true);
193    *this = std::move(Other);
194  }
195 
196  /// Create an error value. Prefer using the 'make_error' function, but
197  /// this constructor can be useful when "re-throwing" errors from handlers.
198  Error(std::unique_ptr<ErrorInfoBase> Payload) {
199    setPtr(Payload.release());
200    setChecked(false);
201  }
202 
203  // Errors are not copy-assignable.
204  Error &operator=(const Error &Other) = delete;
205 
206  /// Move-assign an error value. The current error must represent success, you
207  /// you cannot overwrite an unhandled error. The current error is then
208  /// considered unchecked. The source error becomes a checked success value,
209  /// regardless of its original state.
210  Error &operator=(Error &&Other) {
211    // Don't allow overwriting of unchecked values.
212    assertIsChecked();
213    setPtr(Other.getPtr());
214 
215    // This Error is unchecked, even if the source error was checked.
216    setChecked(false);
217 
218    // Null out Other's payload and set its checked bit.
219    Other.setPtr(nullptr);
220    Other.setChecked(true);
221 
222    return *this;
223  }
224 
225  /// Destroy a Error. Fails with a call to abort() if the error is
226  /// unchecked.
227  ~Error() {
228    assertIsChecked();
229    delete getPtr();
230  }
231 
232  /// Bool conversion. Returns true if this Error is in a failure state,
233  /// and false if it is in an accept state. If the error is in a Success state
234  /// it will be considered checked.
235  explicit operator bool() {
236    setChecked(getPtr() == nullptr);
237    return getPtr() != nullptr;
238  }
239 
240  /// Check whether one error is a subclass of another.
241  template <typename ErrT> bool isA() const {
242    return getPtr() && getPtr()->isA(ErrT::classID());
243  }
244 
245  /// Returns the dynamic class id of this error, or null if this is a success
246  /// value.
247  const void* dynamicClassID() const {
248    if (!getPtr())
249      return nullptr;
250    return getPtr()->dynamicClassID();
251  }
252 
253private:
254#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
255  // assertIsChecked() happens very frequently, but under normal circumstances
256  // is supposed to be a no-op.  So we want it to be inlined, but having a bunch
257  // of debug prints can cause the function to be too large for inlining.  So
258  // it's important that we define this function out of line so that it can't be
259  // inlined.
260  [[noreturn]] void fatalUncheckedError() const;
261#endif
262 
263  void assertIsChecked() {
264#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
265    if (LLVM_UNLIKELY(!getChecked() || getPtr())__builtin_expect((bool)(!getChecked() || getPtr()), false))
266      fatalUncheckedError();
267#endif
268  }
269 
270  ErrorInfoBase *getPtr() const {
271#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
272    return reinterpret_cast<ErrorInfoBase*>(
273             reinterpret_cast<uintptr_t>(Payload) &
274             ~static_cast<uintptr_t>(0x1));
275#else
276    return Payload;
277#endif
278  }
279 
280  void setPtr(ErrorInfoBase *EI) {
281#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
282    Payload = reinterpret_cast<ErrorInfoBase*>(
283                (reinterpret_cast<uintptr_t>(EI) &
284                 ~static_cast<uintptr_t>(0x1)) |
285                (reinterpret_cast<uintptr_t>(Payload) & 0x1));
286#else
287    Payload = EI;
288#endif
289  }
290 
291  bool getChecked() const {
292#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
293    return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
294#else
295    return true;
296#endif
297  }
298 
299  void setChecked(bool V) {
300#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
301    Payload = reinterpret_cast<ErrorInfoBase*>(
302                (reinterpret_cast<uintptr_t>(Payload) &
303                  ~static_cast<uintptr_t>(0x1)) |
304                  (V ? 0 : 1));
305#endif
306  }
307 
308  std::unique_ptr<ErrorInfoBase> takePayload() {
309    std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
310    setPtr(nullptr);
311    setChecked(true);
312    return Tmp;
313  }
314 
315  friend raw_ostream &operator<<(raw_ostream &OS, const Error &E) {
316    if (auto P = E.getPtr())
317      P->log(OS);
318    else
319      OS << "success";
320    return OS;
321  }
322 
323  ErrorInfoBase *Payload = nullptr;
324};
325 
326/// Subclass of Error for the sole purpose of identifying the success path in
327/// the type system. This allows to catch invalid conversion to Expected<T> at
328/// compile time.
329class ErrorSuccess final : public Error {};
330 
331inline ErrorSuccess Error::success() { return ErrorSuccess(); }
332 
333/// Make a Error instance representing failure using the given error info
334/// type.
335template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
336  return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
337}
338 
339/// Base class for user error types. Users should declare their error types
340/// like:
341///
342/// class MyError : public ErrorInfo<MyError> {
343///   ....
344/// };
345///
346/// This class provides an implementation of the ErrorInfoBase::kind
347/// method, which is used by the Error RTTI system.
348template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
349class ErrorInfo : public ParentErrT {
350public:
351  using ParentErrT::ParentErrT; // inherit constructors
352 
353  static const void *classID() { return &ThisErrT::ID; }
354 
355  const void *dynamicClassID() const override { return &ThisErrT::ID; }
356 
357  bool isA(const void *const ClassID) const override {
358    return ClassID == classID() || ParentErrT::isA(ClassID);
359  }
360};
361 
362/// Special ErrorInfo subclass representing a list of ErrorInfos.
363/// Instances of this class are constructed by joinError.
364class ErrorList final : public ErrorInfo<ErrorList> {
365  // handleErrors needs to be able to iterate the payload list of an
366  // ErrorList.
367  template <typename... HandlerTs>
368  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
369 
370  // joinErrors is implemented in terms of join.
371  friend Error joinErrors(Error, Error);
372 
373public:
374  void log(raw_ostream &OS) const override {
375    OS << "Multiple errors:\n";
376    for (auto &ErrPayload : Payloads) {
377      ErrPayload->log(OS);
378      OS << "\n";
379    }
380  }
381 
382  std::error_code convertToErrorCode() const override;
383 
384  // Used by ErrorInfo::classID.
385  static char ID;
386 
387private:
388  ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
389            std::unique_ptr<ErrorInfoBase> Payload2) {
390    assert(!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() &&(static_cast <bool> (!Payload1->isA<ErrorList>
() && !Payload2->isA<ErrorList>() &&
 "ErrorList constructor payloads should be singleton errors")
 ? void (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 391, __extension__ __PRETTY_FUNCTION__))
391           "ErrorList constructor payloads should be singleton errors")(static_cast <bool> (!Payload1->isA<ErrorList>
() && !Payload2->isA<ErrorList>() &&
 "ErrorList constructor payloads should be singleton errors")
 ? void (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 391, __extension__ __PRETTY_FUNCTION__));
392    Payloads.push_back(std::move(Payload1));
393    Payloads.push_back(std::move(Payload2));
394  }
395 
396  static Error join(Error E1, Error E2) {
397    if (!E1)
398      return E2;
399    if (!E2)
400      return E1;
401    if (E1.isA<ErrorList>()) {
402      auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
403      if (E2.isA<ErrorList>()) {
404        auto E2Payload = E2.takePayload();
405        auto &E2List = static_cast<ErrorList &>(*E2Payload);
406        for (auto &Payload : E2List.Payloads)
407          E1List.Payloads.push_back(std::move(Payload));
408      } else
409        E1List.Payloads.push_back(E2.takePayload());
410 
411      return E1;
412    }
413    if (E2.isA<ErrorList>()) {
414      auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
415      E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
416      return E2;
417    }
418    return Error(std::unique_ptr<ErrorList>(
419        new ErrorList(E1.takePayload(), E2.takePayload())));
420  }
421 
422  std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
423};
424 
425/// Concatenate errors. The resulting Error is unchecked, and contains the
426/// ErrorInfo(s), if any, contained in E1, followed by the
427/// ErrorInfo(s), if any, contained in E2.
428inline Error joinErrors(Error E1, Error E2) {
429  return ErrorList::join(std::move(E1), std::move(E2));
430}
431 
432/// Tagged union holding either a T or a Error.
433///
434/// This class parallels ErrorOr, but replaces error_code with Error. Since
435/// Error cannot be copied, this class replaces getError() with
436/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
437/// error class type.
438///
439/// Example usage of 'Expected<T>' as a function return type:
440///
441///   @code{.cpp}
442///     Expected<int> myDivide(int A, int B) {
443///       if (B == 0) {
444///         // return an Error
445///         return createStringError(inconvertibleErrorCode(),
446///                                  "B must not be zero!");
447///       }
448///       // return an integer
449///       return A / B;
450///     }
451///   @endcode
452///
453///   Checking the results of to a function returning 'Expected<T>':
454///   @code{.cpp}
455///     if (auto E = Result.takeError()) {
456///       // We must consume the error. Typically one of:
457///       // - return the error to our caller
458///       // - toString(), when logging
459///       // - consumeError(), to silently swallow the error
460///       // - handleErrors(), to distinguish error types
461///       errs() << "Problem with division " << toString(std::move(E)) << "\n";
462///       return;
463///     }
464///     // use the result
465///     outs() << "The answer is " << *Result << "\n";
466///   @endcode
467///
468///  For unit-testing a function returning an 'Expceted<T>', see the
469///  'EXPECT_THAT_EXPECTED' macros in llvm/Testing/Support/Error.h
470 
471template <class T> class LLVM_NODISCARD[[clang::warn_unused_result]] Expected {
472  template <class T1> friend class ExpectedAsOutParameter;
473  template <class OtherT> friend class Expected;
474 
475  static constexpr bool isRef = std::is_reference<T>::value;
476 
477  using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
478 
479  using error_type = std::unique_ptr<ErrorInfoBase>;
480 
481public:
482  using storage_type = std::conditional_t<isRef, wrap, T>;
483  using value_type = T;
484 
485private:
486  using reference = std::remove_reference_t<T> &;
487  using const_reference = const std::remove_reference_t<T> &;
488  using pointer = std::remove_reference_t<T> *;
489  using const_pointer = const std::remove_reference_t<T> *;
490 
491public:
492  /// Create an Expected<T> error value from the given Error.
493  Expected(Error Err)
494      : HasError(true)
495#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
496        // Expected is unchecked upon construction in Debug builds.
497        , Unchecked(true)
498#endif
499  {
500    assert(Err && "Cannot create Expected<T> from Error success value.")(static_cast <bool> (Err && "Cannot create Expected<T> from Error success value."
) ? void (0) : __assert_fail ("Err && \"Cannot create Expected<T> from Error success value.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 500, __extension__ __PRETTY_FUNCTION__));
501    new (getErrorStorage()) error_type(Err.takePayload());
502  }
503 
504  /// Forbid to convert from Error::success() implicitly, this avoids having
505  /// Expected<T> foo() { return Error::success(); } which compiles otherwise
506  /// but triggers the assertion above.
507  Expected(ErrorSuccess) = delete;
508 
509  /// Create an Expected<T> success value from the given OtherT value, which
510  /// must be convertible to T.
511  template <typename OtherT>
512  Expected(OtherT &&Val,
513           std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr)
514      : HasError(false)
515#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
516        // Expected is unchecked upon construction in Debug builds.
517        ,
518        Unchecked(true)
519#endif
520  {
521    new (getStorage()) storage_type(std::forward<OtherT>(Val));
522  }
523 
524  /// Move construct an Expected<T> value.
525  Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
526 
527  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
528  /// must be convertible to T.
529  template <class OtherT>
530  Expected(
531      Expected<OtherT> &&Other,
532      std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr) {
533    moveConstruct(std::move(Other));
534  }
535 
536  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
537  /// isn't convertible to T.
538  template <class OtherT>
539  explicit Expected(
540      Expected<OtherT> &&Other,
541      std::enable_if_t<!std::is_convertible<OtherT, T>::value> * = nullptr) {
542    moveConstruct(std::move(Other));
543  }
544 
545  /// Move-assign from another Expected<T>.
546  Expected &operator=(Expected &&Other) {
547    moveAssign(std::move(Other));
548    return *this;
549  }
550 
551  /// Destroy an Expected<T>.
552  ~Expected() {
553    assertIsChecked();
554    if (!HasError)
555      getStorage()->~storage_type();
556    else
557      getErrorStorage()->~error_type();
558  }
559 
560  /// Return false if there is an error.
561  explicit operator bool() {
562#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
563    Unchecked = HasError;
564#endif
565    return !HasError;
23
←
Assuming field 'HasError' is false→
24
←
Returning the value 1, which participates in a condition later→
566  }
567 
568  /// Returns a reference to the stored T value.
569  reference get() {
570    assertIsChecked();
571    return *getStorage();
572  }
573 
574  /// Returns a const reference to the stored T value.
575  const_reference get() const {
576    assertIsChecked();
577    return const_cast<Expected<T> *>(this)->get();
578  }
579 
580  /// Check that this Expected<T> is an error of type ErrT.
581  template <typename ErrT> bool errorIsA() const {
582    return HasError && (*getErrorStorage())->template isA<ErrT>();
583  }
584 
585  /// Take ownership of the stored error.
586  /// After calling this the Expected<T> is in an indeterminate state that can
587  /// only be safely destructed. No further calls (beside the destructor) should
588  /// be made on the Expected<T> value.
589  Error takeError() {
590#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
591    Unchecked = false;
592#endif
593    return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
594  }
595 
596  /// Returns a pointer to the stored T value.
597  pointer operator->() {
598    assertIsChecked();
599    return toPointer(getStorage());
600  }
601 
602  /// Returns a const pointer to the stored T value.
603  const_pointer operator->() const {
604    assertIsChecked();
605    return toPointer(getStorage());
606  }
607 
608  /// Returns a reference to the stored T value.
609  reference operator*() {
610    assertIsChecked();
611    return *getStorage();
612  }
613 
614  /// Returns a const reference to the stored T value.
615  const_reference operator*() const {
616    assertIsChecked();
617    return *getStorage();
618  }
619 
620private:
621  template <class T1>
622  static bool compareThisIfSameType(const T1 &a, const T1 &b) {
623    return &a == &b;
624  }
625 
626  template <class T1, class T2>
627  static bool compareThisIfSameType(const T1 &, const T2 &) {
628    return false;
629  }
630 
631  template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
632    HasError = Other.HasError;
633#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
634    Unchecked = true;
635    Other.Unchecked = false;
636#endif
637 
638    if (!HasError)
639      new (getStorage()) storage_type(std::move(*Other.getStorage()));
640    else
641      new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
642  }
643 
644  template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
645    assertIsChecked();
646 
647    if (compareThisIfSameType(*this, Other))
648      return;
649 
650    this->~Expected();
651    new (this) Expected(std::move(Other));
652  }
653 
654  pointer toPointer(pointer Val) { return Val; }
655 
656  const_pointer toPointer(const_pointer Val) const { return Val; }
657 
658  pointer toPointer(wrap *Val) { return &Val->get(); }
659 
660  const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
661 
662  storage_type *getStorage() {
663    assert(!HasError && "Cannot get value when an error exists!")(static_cast <bool> (!HasError && "Cannot get value when an error exists!"
) ? void (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 663, __extension__ __PRETTY_FUNCTION__));
664    return reinterpret_cast<storage_type *>(&TStorage);
665  }
666 
667  const storage_type *getStorage() const {
668    assert(!HasError && "Cannot get value when an error exists!")(static_cast <bool> (!HasError && "Cannot get value when an error exists!"
) ? void (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 668, __extension__ __PRETTY_FUNCTION__));
669    return reinterpret_cast<const storage_type *>(&TStorage);
670  }
671 
672  error_type *getErrorStorage() {
673    assert(HasError && "Cannot get error when a value exists!")(static_cast <bool> (HasError && "Cannot get error when a value exists!"
) ? void (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 673, __extension__ __PRETTY_FUNCTION__));
674    return reinterpret_cast<error_type *>(&ErrorStorage);
675  }
676 
677  const error_type *getErrorStorage() const {
678    assert(HasError && "Cannot get error when a value exists!")(static_cast <bool> (HasError && "Cannot get error when a value exists!"
) ? void (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 678, __extension__ __PRETTY_FUNCTION__));
679    return reinterpret_cast<const error_type *>(&ErrorStorage);
680  }
681 
682  // Used by ExpectedAsOutParameter to reset the checked flag.
683  void setUnchecked() {
684#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
685    Unchecked = true;
686#endif
687  }
688 
689#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
690  [[noreturn]] LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) void fatalUncheckedExpected() const {
691    dbgs() << "Expected<T> must be checked before access or destruction.\n";
692    if (HasError) {
693      dbgs() << "Unchecked Expected<T> contained error:\n";
694      (*getErrorStorage())->log(dbgs());
695    } else
696      dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
697                "values in success mode must still be checked prior to being "
698                "destroyed).\n";
699    abort();
700  }
701#endif
702 
703  void assertIsChecked() const {
704#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
705    if (LLVM_UNLIKELY(Unchecked)__builtin_expect((bool)(Unchecked), false))
706      fatalUncheckedExpected();
707#endif
708  }
709 
710  union {
711    AlignedCharArrayUnion<storage_type> TStorage;
712    AlignedCharArrayUnion<error_type> ErrorStorage;
713  };
714  bool HasError : 1;
715#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
716  bool Unchecked : 1;
717#endif
718};
719 
720/// Report a serious error, calling any installed error handler. See
721/// ErrorHandling.h.
722[[noreturn]] void report_fatal_error(Error Err, bool gen_crash_diag = true);
723 
724/// Report a fatal error if Err is a failure value.
725///
726/// This function can be used to wrap calls to fallible functions ONLY when it
727/// is known that the Error will always be a success value. E.g.
728///
729///   @code{.cpp}
730///   // foo only attempts the fallible operation if DoFallibleOperation is
731///   // true. If DoFallibleOperation is false then foo always returns
732///   // Error::success().
733///   Error foo(bool DoFallibleOperation);
734///
735///   cantFail(foo(false));
736///   @endcode
737inline void cantFail(Error Err, const char *Msg = nullptr) {
738  if (Err) {
739    if (!Msg)
740      Msg = "Failure value returned from cantFail wrapped call";
741#ifndef NDEBUG
742    std::string Str;
743    raw_string_ostream OS(Str);
744    OS << Msg << "\n" << Err;
745    Msg = OS.str().c_str();
746#endif
747    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 747);
748  }
749}
750 
751/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
752/// returns the contained value.
753///
754/// This function can be used to wrap calls to fallible functions ONLY when it
755/// is known that the Error will always be a success value. E.g.
756///
757///   @code{.cpp}
758///   // foo only attempts the fallible operation if DoFallibleOperation is
759///   // true. If DoFallibleOperation is false then foo always returns an int.
760///   Expected<int> foo(bool DoFallibleOperation);
761///
762///   int X = cantFail(foo(false));
763///   @endcode
764template <typename T>
765T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
766  if (ValOrErr)
767    return std::move(*ValOrErr);
768  else {
769    if (!Msg)
770      Msg = "Failure value returned from cantFail wrapped call";
771#ifndef NDEBUG
772    std::string Str;
773    raw_string_ostream OS(Str);
774    auto E = ValOrErr.takeError();
775    OS << Msg << "\n" << E;
776    Msg = OS.str().c_str();
777#endif
778    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 778);
779  }
780}
781 
782/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
783/// returns the contained reference.
784///
785/// This function can be used to wrap calls to fallible functions ONLY when it
786/// is known that the Error will always be a success value. E.g.
787///
788///   @code{.cpp}
789///   // foo only attempts the fallible operation if DoFallibleOperation is
790///   // true. If DoFallibleOperation is false then foo always returns a Bar&.
791///   Expected<Bar&> foo(bool DoFallibleOperation);
792///
793///   Bar &X = cantFail(foo(false));
794///   @endcode
795template <typename T>
796T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
797  if (ValOrErr)
798    return *ValOrErr;
799  else {
800    if (!Msg)
801      Msg = "Failure value returned from cantFail wrapped call";
802#ifndef NDEBUG
803    std::string Str;
804    raw_string_ostream OS(Str);
805    auto E = ValOrErr.takeError();
806    OS << Msg << "\n" << E;
807    Msg = OS.str().c_str();
808#endif
809    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 809);
810  }
811}
812 
813/// Helper for testing applicability of, and applying, handlers for
814/// ErrorInfo types.
815template <typename HandlerT>
816class ErrorHandlerTraits
817    : public ErrorHandlerTraits<decltype(
818          &std::remove_reference<HandlerT>::type::operator())> {};
819 
820// Specialization functions of the form 'Error (const ErrT&)'.
821template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
822public:
823  static bool appliesTo(const ErrorInfoBase &E) {
824    return E.template isA<ErrT>();
825  }
826 
827  template <typename HandlerT>
828  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
829    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 829, __extension__ __PRETTY_FUNCTION__));
830    return H(static_cast<ErrT &>(*E));
831  }
832};
833 
834// Specialization functions of the form 'void (const ErrT&)'.
835template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
836public:
837  static bool appliesTo(const ErrorInfoBase &E) {
838    return E.template isA<ErrT>();
839  }
840 
841  template <typename HandlerT>
842  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
843    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 843, __extension__ __PRETTY_FUNCTION__));
844    H(static_cast<ErrT &>(*E));
845    return Error::success();
846  }
847};
848 
849/// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
850template <typename ErrT>
851class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
852public:
853  static bool appliesTo(const ErrorInfoBase &E) {
854    return E.template isA<ErrT>();
855  }
856 
857  template <typename HandlerT>
858  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
859    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 859, __extension__ __PRETTY_FUNCTION__));
860    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
861    return H(std::move(SubE));
862  }
863};
864 
865/// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
866template <typename ErrT>
867class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
868public:
869  static bool appliesTo(const ErrorInfoBase &E) {
870    return E.template isA<ErrT>();
871  }
872 
873  template <typename HandlerT>
874  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
875    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 875, __extension__ __PRETTY_FUNCTION__));
876    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
877    H(std::move(SubE));
878    return Error::success();
879  }
880};
881 
882// Specialization for member functions of the form 'RetT (const ErrT&)'.
883template <typename C, typename RetT, typename ErrT>
884class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
885    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
886 
887// Specialization for member functions of the form 'RetT (const ErrT&) const'.
888template <typename C, typename RetT, typename ErrT>
889class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
890    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
891 
892// Specialization for member functions of the form 'RetT (const ErrT&)'.
893template <typename C, typename RetT, typename ErrT>
894class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
895    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
896 
897// Specialization for member functions of the form 'RetT (const ErrT&) const'.
898template <typename C, typename RetT, typename ErrT>
899class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
900    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
901 
902/// Specialization for member functions of the form
903/// 'RetT (std::unique_ptr<ErrT>)'.
904template <typename C, typename RetT, typename ErrT>
905class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
906    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
907 
908/// Specialization for member functions of the form
909/// 'RetT (std::unique_ptr<ErrT>) const'.
910template <typename C, typename RetT, typename ErrT>
911class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
912    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
913 
914inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
915  return Error(std::move(Payload));
916}
917 
918template <typename HandlerT, typename... HandlerTs>
919Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
920                      HandlerT &&Handler, HandlerTs &&... Handlers) {
921  if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
922    return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
923                                               std::move(Payload));
924  return handleErrorImpl(std::move(Payload),
925                         std::forward<HandlerTs>(Handlers)...);
926}
927 
928/// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
929/// unhandled errors (or Errors returned by handlers) are re-concatenated and
930/// returned.
931/// Because this function returns an error, its result must also be checked
932/// or returned. If you intend to handle all errors use handleAllErrors
933/// (which returns void, and will abort() on unhandled errors) instead.
934template <typename... HandlerTs>
935Error handleErrors(Error E, HandlerTs &&... Hs) {
936  if (!E)
937    return Error::success();
938 
939  std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
940 
941  if (Payload->isA<ErrorList>()) {
942    ErrorList &List = static_cast<ErrorList &>(*Payload);
943    Error R;
944    for (auto &P : List.Payloads)
945      R = ErrorList::join(
946          std::move(R),
947          handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
948    return R;
949  }
950 
951  return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
952}
953 
954/// Behaves the same as handleErrors, except that by contract all errors
955/// *must* be handled by the given handlers (i.e. there must be no remaining
956/// errors after running the handlers, or llvm_unreachable is called).
957template <typename... HandlerTs>
958void handleAllErrors(Error E, HandlerTs &&... Handlers) {
959  cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
960}
961 
962/// Check that E is a non-error, then drop it.
963/// If E is an error, llvm_unreachable will be called.
964inline void handleAllErrors(Error E) {
965  cantFail(std::move(E));
966}
967 
968/// Handle any errors (if present) in an Expected<T>, then try a recovery path.
969///
970/// If the incoming value is a success value it is returned unmodified. If it
971/// is a failure value then it the contained error is passed to handleErrors.
972/// If handleErrors is able to handle the error then the RecoveryPath functor
973/// is called to supply the final result. If handleErrors is not able to
974/// handle all errors then the unhandled errors are returned.
975///
976/// This utility enables the follow pattern:
977///
978///   @code{.cpp}
979///   enum FooStrategy { Aggressive, Conservative };
980///   Expected<Foo> foo(FooStrategy S);
981///
982///   auto ResultOrErr =
983///     handleExpected(
984///       foo(Aggressive),
985///       []() { return foo(Conservative); },
986///       [](AggressiveStrategyError&) {
987///         // Implicitly conusme this - we'll recover by using a conservative
988///         // strategy.
989///       });
990///
991///   @endcode
992template <typename T, typename RecoveryFtor, typename... HandlerTs>
993Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
994                           HandlerTs &&... Handlers) {
995  if (ValOrErr)
996    return ValOrErr;
997 
998  if (auto Err = handleErrors(ValOrErr.takeError(),
999                              std::forward<HandlerTs>(Handlers)...))
1000    return std::move(Err);
1001 
1002  return RecoveryPath();
1003}
1004 
1005/// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
1006/// will be printed before the first one is logged. A newline will be printed
1007/// after each error.
1008///
1009/// This function is compatible with the helpers from Support/WithColor.h. You
1010/// can pass any of them as the OS. Please consider using them instead of
1011/// including 'error: ' in the ErrorBanner.
1012///
1013/// This is useful in the base level of your program to allow clean termination
1014/// (allowing clean deallocation of resources, etc.), while reporting error
1015/// information to the user.
1016void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
1017 
1018/// Write all error messages (if any) in E to a string. The newline character
1019/// is used to separate error messages.
1020inline std::string toString(Error E) {
1021  SmallVector<std::string, 2> Errors;
1022  handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
1023    Errors.push_back(EI.message());
1024  });
1025  return join(Errors.begin(), Errors.end(), "\n");
1026}
1027 
1028/// Consume a Error without doing anything. This method should be used
1029/// only where an error can be considered a reasonable and expected return
1030/// value.
1031///
1032/// Uses of this method are potentially indicative of design problems: If it's
1033/// legitimate to do nothing while processing an "error", the error-producer
1034/// might be more clearly refactored to return an Optional<T>.
1035inline void consumeError(Error Err) {
1036  handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
1037}
1038 
1039/// Convert an Expected to an Optional without doing anything. This method
1040/// should be used only where an error can be considered a reasonable and
1041/// expected return value.
1042///
1043/// Uses of this method are potentially indicative of problems: perhaps the
1044/// error should be propagated further, or the error-producer should just
1045/// return an Optional in the first place.
1046template <typename T> Optional<T> expectedToOptional(Expected<T> &&E) {
1047  if (E)
1048    return std::move(*E);
1049  consumeError(E.takeError());
1050  return None;
1051}
1052 
1053/// Helper for converting an Error to a bool.
1054///
1055/// This method returns true if Err is in an error state, or false if it is
1056/// in a success state.  Puts Err in a checked state in both cases (unlike
1057/// Error::operator bool(), which only does this for success states).
1058inline bool errorToBool(Error Err) {
1059  bool IsError = static_cast<bool>(Err);
1060  if (IsError)
1061    consumeError(std::move(Err));
1062  return IsError;
1063}
1064 
1065/// Helper for Errors used as out-parameters.
1066///
1067/// This helper is for use with the Error-as-out-parameter idiom, where an error
1068/// is passed to a function or method by reference, rather than being returned.
1069/// In such cases it is helpful to set the checked bit on entry to the function
1070/// so that the error can be written to (unchecked Errors abort on assignment)
1071/// and clear the checked bit on exit so that clients cannot accidentally forget
1072/// to check the result. This helper performs these actions automatically using
1073/// RAII:
1074///
1075///   @code{.cpp}
1076///   Result foo(Error &Err) {
1077///     ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1078///     // <body of foo>
1079///     // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1080///   }
1081///   @endcode
1082///
1083/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1084/// used with optional Errors (Error pointers that are allowed to be null). If
1085/// ErrorAsOutParameter took an Error reference, an instance would have to be
1086/// created inside every condition that verified that Error was non-null. By
1087/// taking an Error pointer we can just create one instance at the top of the
1088/// function.
1089class ErrorAsOutParameter {
1090public:
1091  ErrorAsOutParameter(Error *Err) : Err(Err) {
1092    // Raise the checked bit if Err is success.
1093    if (Err)
1094      (void)!!*Err;
1095  }
1096 
1097  ~ErrorAsOutParameter() {
1098    // Clear the checked bit.
1099    if (Err && !*Err)
1100      *Err = Error::success();
1101  }
1102 
1103private:
1104  Error *Err;
1105};
1106 
1107/// Helper for Expected<T>s used as out-parameters.
1108///
1109/// See ErrorAsOutParameter.
1110template <typename T>
1111class ExpectedAsOutParameter {
1112public:
1113  ExpectedAsOutParameter(Expected<T> *ValOrErr)
1114    : ValOrErr(ValOrErr) {
1115    if (ValOrErr)
1116      (void)!!*ValOrErr;
1117  }
1118 
1119  ~ExpectedAsOutParameter() {
1120    if (ValOrErr)
1121      ValOrErr->setUnchecked();
1122  }
1123 
1124private:
1125  Expected<T> *ValOrErr;
1126};
1127 
1128/// This class wraps a std::error_code in a Error.
1129///
1130/// This is useful if you're writing an interface that returns a Error
1131/// (or Expected) and you want to call code that still returns
1132/// std::error_codes.
1133class ECError : public ErrorInfo<ECError> {
1134  friend Error errorCodeToError(std::error_code);
1135 
1136  virtual void anchor() override;
1137 
1138public:
1139  void setErrorCode(std::error_code EC) { this->EC = EC; }
1140  std::error_code convertToErrorCode() const override { return EC; }
1141  void log(raw_ostream &OS) const override { OS << EC.message(); }
1142 
1143  // Used by ErrorInfo::classID.
1144  static char ID;
1145 
1146protected:
1147  ECError() = default;
1148  ECError(std::error_code EC) : EC(EC) {}
1149 
1150  std::error_code EC;
1151};
1152 
1153/// The value returned by this function can be returned from convertToErrorCode
1154/// for Error values where no sensible translation to std::error_code exists.
1155/// It should only be used in this situation, and should never be used where a
1156/// sensible conversion to std::error_code is available, as attempts to convert
1157/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1158///error to try to convert such a value).
1159std::error_code inconvertibleErrorCode();
1160 
1161/// Helper for converting an std::error_code to a Error.
1162Error errorCodeToError(std::error_code EC);
1163 
1164/// Helper for converting an ECError to a std::error_code.
1165///
1166/// This method requires that Err be Error() or an ECError, otherwise it
1167/// will trigger a call to abort().
1168std::error_code errorToErrorCode(Error Err);
1169 
1170/// Convert an ErrorOr<T> to an Expected<T>.
1171template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1172  if (auto EC = EO.getError())
1173    return errorCodeToError(EC);
1174  return std::move(*EO);
1175}
1176 
1177/// Convert an Expected<T> to an ErrorOr<T>.
1178template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1179  if (auto Err = E.takeError())
1180    return errorToErrorCode(std::move(Err));
1181  return std::move(*E);
1182}
1183 
1184/// This class wraps a string in an Error.
1185///
1186/// StringError is useful in cases where the client is not expected to be able
1187/// to consume the specific error message programmatically (for example, if the
1188/// error message is to be presented to the user).
1189///
1190/// StringError can also be used when additional information is to be printed
1191/// along with a error_code message. Depending on the constructor called, this
1192/// class can either display:
1193///    1. the error_code message (ECError behavior)
1194///    2. a string
1195///    3. the error_code message and a string
1196///
1197/// These behaviors are useful when subtyping is required; for example, when a
1198/// specific library needs an explicit error type. In the example below,
1199/// PDBError is derived from StringError:
1200///
1201///   @code{.cpp}
1202///   Expected<int> foo() {
1203///      return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1204///                                        "Additional information");
1205///   }
1206///   @endcode
1207///
1208class StringError : public ErrorInfo<StringError> {
1209public:
1210  static char ID;
1211 
1212  // Prints EC + S and converts to EC
1213  StringError(std::error_code EC, const Twine &S = Twine());
1214 
1215  // Prints S and converts to EC
1216  StringError(const Twine &S, std::error_code EC);
1217 
1218  void log(raw_ostream &OS) const override;
1219  std::error_code convertToErrorCode() const override;
1220 
1221  const std::string &getMessage() const { return Msg; }
1222 
1223private:
1224  std::string Msg;
1225  std::error_code EC;
1226  const bool PrintMsgOnly = false;
1227};
1228 
1229/// Create formatted StringError object.
1230template <typename... Ts>
1231inline Error createStringError(std::error_code EC, char const *Fmt,
1232                               const Ts &... Vals) {
1233  std::string Buffer;
1234  raw_string_ostream Stream(Buffer);
1235  Stream << format(Fmt, Vals...);
1236  return make_error<StringError>(Stream.str(), EC);
1237}
1238 
1239Error createStringError(std::error_code EC, char const *Msg);
1240 
1241inline Error createStringError(std::error_code EC, const Twine &S) {
1242  return createStringError(EC, S.str().c_str());
1243}
1244 
1245template <typename... Ts>
1246inline Error createStringError(std::errc EC, char const *Fmt,
1247                               const Ts &... Vals) {
1248  return createStringError(std::make_error_code(EC), Fmt, Vals...);
1249}
1250 
1251/// This class wraps a filename and another Error.
1252///
1253/// In some cases, an error needs to live along a 'source' name, in order to
1254/// show more detailed information to the user.
1255class FileError final : public ErrorInfo<FileError> {
1256 
1257  friend Error createFileError(const Twine &, Error);
1258  friend Error createFileError(const Twine &, size_t, Error);
1259 
1260public:
1261  void log(raw_ostream &OS) const override {
1262    assert(Err && !FileName.empty() && "Trying to log after takeError().")(static_cast <bool> (Err && !FileName.empty() &&
 "Trying to log after takeError().") ? void (0) : __assert_fail
 ("Err && !FileName.empty() && \"Trying to log after takeError().\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 1262, __extension__ __PRETTY_FUNCTION__));
1263    OS << "'" << FileName << "': ";
1264    if (Line.hasValue())
1265      OS << "line " << Line.getValue() << ": ";
1266    Err->log(OS);
1267  }
1268 
1269  StringRef getFileName() { return FileName; }
1270 
1271  Error takeError() { return Error(std::move(Err)); }
1272 
1273  std::error_code convertToErrorCode() const override;
1274 
1275  // Used by ErrorInfo::classID.
1276  static char ID;
1277 
1278private:
1279  FileError(const Twine &F, Optional<size_t> LineNum,
1280            std::unique_ptr<ErrorInfoBase> E) {
1281    assert(E && "Cannot create FileError from Error success value.")(static_cast <bool> (E && "Cannot create FileError from Error success value."
) ? void (0) : __assert_fail ("E && \"Cannot create FileError from Error success value.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 1281, __extension__ __PRETTY_FUNCTION__));
1282    assert(!F.isTriviallyEmpty() &&(static_cast <bool> (!F.isTriviallyEmpty() && "The file name provided to FileError must not be empty."
) ? void (0) : __assert_fail ("!F.isTriviallyEmpty() && \"The file name provided to FileError must not be empty.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 1283, __extension__ __PRETTY_FUNCTION__))
1283           "The file name provided to FileError must not be empty.")(static_cast <bool> (!F.isTriviallyEmpty() && "The file name provided to FileError must not be empty."
) ? void (0) : __assert_fail ("!F.isTriviallyEmpty() && \"The file name provided to FileError must not be empty.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/Error.h"
, 1283, __extension__ __PRETTY_FUNCTION__));
1284    FileName = F.str();
1285    Err = std::move(E);
1286    Line = std::move(LineNum);
1287  }
1288 
1289  static Error build(const Twine &F, Optional<size_t> Line, Error E) {
1290    std::unique_ptr<ErrorInfoBase> Payload;
1291    handleAllErrors(std::move(E),
1292                    [&](std::unique_ptr<ErrorInfoBase> EIB) -> Error {
1293                      Payload = std::move(EIB);
1294                      return Error::success();
1295                    });
1296    return Error(
1297        std::unique_ptr<FileError>(new FileError(F, Line, std::move(Payload))));
1298  }
1299 
1300  std::string FileName;
1301  Optional<size_t> Line;
1302  std::unique_ptr<ErrorInfoBase> Err;
1303};
1304 
1305/// Concatenate a source file path and/or name with an Error. The resulting
1306/// Error is unchecked.
1307inline Error createFileError(const Twine &F, Error E) {
1308  return FileError::build(F, Optional<size_t>(), std::move(E));
1309}
1310 
1311/// Concatenate a source file path and/or name with line number and an Error.
1312/// The resulting Error is unchecked.
1313inline Error createFileError(const Twine &F, size_t Line, Error E) {
1314  return FileError::build(F, Optional<size_t>(Line), std::move(E));
1315}
1316 
1317/// Concatenate a source file path and/or name with a std::error_code 
1318/// to form an Error object.
1319inline Error createFileError(const Twine &F, std::error_code EC) {
1320  return createFileError(F, errorCodeToError(EC));
1321}
1322 
1323/// Concatenate a source file path and/or name with line number and
1324/// std::error_code to form an Error object.
1325inline Error createFileError(const Twine &F, size_t Line, std::error_code EC) {
1326  return createFileError(F, Line, errorCodeToError(EC));
1327}
1328 
1329Error createFileError(const Twine &F, ErrorSuccess) = delete;
1330 
1331/// Helper for check-and-exit error handling.
1332///
1333/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1334///
1335class ExitOnError {
1336public:
1337  /// Create an error on exit helper.
1338  ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1339      : Banner(std::move(Banner)),
1340        GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1341 
1342  /// Set the banner string for any errors caught by operator().
1343  void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1344 
1345  /// Set the exit-code mapper function.
1346  void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1347    this->GetExitCode = std::move(GetExitCode);
1348  }
1349 
1350  /// Check Err. If it's in a failure state log the error(s) and exit.
1351  void operator()(Error Err) const { checkError(std::move(Err)); }
1352 
1353  /// Check E. If it's in a success state then return the contained value. If
1354  /// it's in a failure state log the error(s) and exit.
1355  template <typename T> T operator()(Expected<T> &&E) const {
1356    checkError(E.takeError());
1357    return std::move(*E);
1358  }
1359 
1360  /// Check E. If it's in a success state then return the contained reference. If
1361  /// it's in a failure state log the error(s) and exit.
1362  template <typename T> T& operator()(Expected<T&> &&E) const {
1363    checkError(E.takeError());
1364    return *E;
1365  }
1366 
1367private:
1368  void checkError(Error Err) const {
1369    if (Err) {
1370      int ExitCode = GetExitCode(Err);
1371      logAllUnhandledErrors(std::move(Err), errs(), Banner);
1372      exit(ExitCode);
1373    }
1374  }
1375 
1376  std::string Banner;
1377  std::function<int(const Error &)> GetExitCode;
1378};
1379 
1380/// Conversion from Error to LLVMErrorRef for C error bindings.
1381inline LLVMErrorRef wrap(Error Err) {
1382  return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1383}
1384 
1385/// Conversion from LLVMErrorRef to Error for C error bindings.
1386inline Error unwrap(LLVMErrorRef ErrRef) {
1387  return Error(std::unique_ptr<ErrorInfoBase>(
1388      reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1389}
1390 
1391} // end namespace llvm
1392 
1393#endif // LLVM_SUPPORT_ERROR_H

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/move.h

1// Move, forward and identity for C++11 + swap -*- C++ -*-

3// Copyright (C) 2007-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file bits/move.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{utility}
*/

30#ifndef _MOVE_H1
31#define _MOVE_H1 1

33#include <bits/c++config.h>
34#if __cplusplus201402L < 201103L
35# include <bits/concept_check.h>
36#endif

38namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
39{
40_GLIBCXX_BEGIN_NAMESPACE_VERSION

// Used, in C++03 mode too, by allocators, etc.
/**
 *  @brief Same as C++11 std::addressof
 *  @ingroup utilities
 */
template<typename _Tp>
  inline _GLIBCXX_CONSTEXPRconstexpr _Tp*
  __addressof(_Tp& __r) _GLIBCXX_NOEXCEPTnoexcept
  { return __builtin_addressof(__r); }

52#if __cplusplus201402L >= 201103L

54_GLIBCXX_END_NAMESPACE_VERSION
55} // namespace

57#include <type_traits> // Brings in std::declval too.

59namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
60{
61_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 *  @addtogroup utilities
 *  @{
 */

/**
 *  @brief  Forward an lvalue.
 *  @return The parameter cast to the specified type.
 *
 *  This function is used to implement "perfect forwarding".
 */
template<typename _Tp>
  constexpr _Tp&&
  forward(typename std::remove_reference<_Tp>::type& __t) noexcept
  { return static_cast<_Tp&&>(__t); }
40
←
Returning pointer (reference to 'TemplatedFD')→
50
←
Returning pointer (reference to 'TemplatedFD')→
56
←
Returning pointer (reference to 'TemplatedFD')→

/**
 *  @brief  Forward an rvalue.
 *  @return The parameter cast to the specified type.
 *
 *  This function is used to implement "perfect forwarding".
 */
template<typename _Tp>
  constexpr _Tp&&
  forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
  {
    static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
    " substituting _Tp is an lvalue reference type");
    return static_cast<_Tp&&>(__t);
  }

/**
 *  @brief  Convert a value to an rvalue.
 *  @param  __t  A thing of arbitrary type.
 *  @return The parameter cast to an rvalue-reference to allow moving it.
*/
template<typename _Tp>
  constexpr typename std::remove_reference<_Tp>::type&&
  move(_Tp&& __t) noexcept
  { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }


template<typename _Tp>
  struct __move_if_noexcept_cond
  : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
                  is_copy_constructible<_Tp>>::type { };

/**
 *  @brief  Conditionally convert a value to an rvalue.
 *  @param  __x  A thing of arbitrary type.
 *  @return The parameter, possibly cast to an rvalue-reference.
 *
 *  Same as std::move unless the type's move constructor could throw and the
 *  type is copyable, in which case an lvalue-reference is returned instead.
 */
template<typename _Tp>
  constexpr typename
  conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
  move_if_noexcept(_Tp& __x) noexcept
  { return std::move(__x); }

// declval, from type_traits.

126#if __cplusplus201402L > 201402L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2296. std::addressof should be constexpr
129# define __cpp_lib_addressof_constexpr 201603
130#endif
/**
 *  @brief Returns the actual address of the object or function
 *         referenced by r, even in the presence of an overloaded
 *         operator&.
 *  @param  __r  Reference to an object or function.
 *  @return   The actual address.
*/
template<typename _Tp>
  inline _GLIBCXX17_CONSTEXPR _Tp*
  addressof(_Tp& __r) noexcept
  { return std::__addressof(__r); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2598. addressof works on temporaries
template<typename _Tp>
  const _Tp* addressof(const _Tp&&) = delete;

// C++11 version of std::exchange for internal use.
template <typename _Tp, typename _Up = _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _Tp
  __exchange(_Tp& __obj, _Up&& __new_val)
  {
    _Tp __old_val = std::move(__obj);
    __obj = std::forward<_Up>(__new_val);
    return __old_val;
  }

/// @} group utilities

161#define _GLIBCXX_MOVE(__val)std::move(__val) std::move(__val)
162#define _GLIBCXX_FORWARD(_Tp, __val)std::forward<_Tp>(__val) std::forward<_Tp>(__val)
163#else
164#define _GLIBCXX_MOVE(__val)std::move(__val) (__val)
165#define _GLIBCXX_FORWARD(_Tp, __val)std::forward<_Tp>(__val) (__val)
166#endif

/**
 *  @addtogroup utilities
 *  @{
 */

/**
 *  @brief Swaps two values.
 *  @param  __a  A thing of arbitrary type.
 *  @param  __b  Another thing of arbitrary type.
 *  @return   Nothing.
*/
template<typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline
182#if __cplusplus201402L >= 201103L
  typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
	      is_move_constructible<_Tp>,
	      is_move_assignable<_Tp>>::value>::type
186#else
  void
188#endif
  swap(_Tp& __a, _Tp& __b)
  _GLIBCXX_NOEXCEPT_IF(__and_<is_nothrow_move_constructible<_Tp>,noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable
<_Tp>>::value)
		is_nothrow_move_assignable<_Tp>>::value)noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable
<_Tp>>::value)
  {
193#if __cplusplus201402L < 201103L
    // concept requirements
    __glibcxx_function_requires(_SGIAssignableConcept<_Tp>)
196#endif
    _Tp __tmp = _GLIBCXX_MOVE(__a)std::move(__a);
    __a = _GLIBCXX_MOVE(__b)std::move(__b);
    __b = _GLIBCXX_MOVE(__tmp)std::move(__tmp);
  }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 809. std::swap should be overloaded for array types.
/// Swap the contents of two arrays.
template<typename _Tp, size_t _Nm>
  _GLIBCXX20_CONSTEXPR
  inline
208#if __cplusplus201402L >= 201103L
  typename enable_if<__is_swappable<_Tp>::value>::type
210#else
  void
212#endif
  swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
  _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Tp>::value)noexcept(__is_nothrow_swappable<_Tp>::value)
  {
    for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
  }

/// @} group utilities
221_GLIBCXX_END_NAMESPACE_VERSION
222} // namespace

224#endif /* _MOVE_H */