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//===----------------------------------------------------------------------===//
13
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>
73
74namespace clang {
75
76  using llvm::make_error;
77  using llvm::Error;
78  using llvm::Expected;
79  using ExpectedType = llvm::Expected<QualType>;
80  using ExpectedStmt = llvm::Expected<Stmt *>;
81  using ExpectedExpr = llvm::Expected<Expr *>;
82  using ExpectedDecl = llvm::Expected<Decl *>;
83  using ExpectedSLoc = llvm::Expected<SourceLocation>;
84  using ExpectedName = llvm::Expected<DeclarationName>;
85
86  std::string ImportError::toString() const {
87    // FIXME: Improve error texts.
88    switch (Error) {
89    case NameConflict:
90      return "NameConflict";
91    case UnsupportedConstruct:
92      return "UnsupportedConstruct";
93    case Unknown:
94      return "Unknown error";
95    }
96    llvm_unreachable("Invalid error code.");
97    return "Invalid error code.";
98  }
99
100  void ImportError::log(raw_ostream &OS) const {
101    OS << toString();
102  }
103
104  std::error_code ImportError::convertToErrorCode() const {
105    llvm_unreachable("Function not implemented.");
106  }
107
108  char ImportError::ID;
109
110  template <class T>
111  SmallVector<Decl *, 2>
112  getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
113    SmallVector<Decl *, 2> Redecls;
114    for (auto *R : D->getFirstDecl()->redecls()) {
115      if (R != D->getFirstDecl())
116        Redecls.push_back(R);
117    }
118    Redecls.push_back(D->getFirstDecl());
119    std::reverse(Redecls.begin(), Redecls.end());
120    return Redecls;
121  }
122
123  SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
124    if (auto *FD = dyn_cast<FunctionDecl>(D))
125      return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
126    if (auto *VD = dyn_cast<VarDecl>(D))
127      return getCanonicalForwardRedeclChain<VarDecl>(VD);
128    if (auto *TD = dyn_cast<TagDecl>(D))
129      return getCanonicalForwardRedeclChain<TagDecl>(TD);
130    llvm_unreachable("Bad declaration kind");
131  }
132
133  void updateFlags(const Decl *From, Decl *To) {
134    // Check if some flags or attrs are new in 'From' and copy into 'To'.
135    // FIXME: Other flags or attrs?
136    if (From->isUsed(false) && !To->isUsed(false))
137      To->setIsUsed();
138  }
139
140  class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>,
141                          public DeclVisitor<ASTNodeImporter, ExpectedDecl>,
142                          public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
143    ASTImporter &Importer;
144
145    // Use this instead of Importer.importInto .
146    template <typename ImportT>
147    LLVM_NODISCARD Error importInto(ImportT &To, const ImportT &From) {
148      return Importer.importInto(To, From);
149    }
150
151    // Use this to import pointers of specific type.
152    template <typename ImportT>
153    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
154      auto ToOrErr = Importer.Import(From);
155      if (ToOrErr)
156        To = cast_or_null<ImportT>(*ToOrErr);
157      return ToOrErr.takeError();
158    }
159
160    // Call the import function of ASTImporter for a baseclass of type `T` and
161    // cast the return value to `T`.
162    template <typename T>
163    Expected<T *> import(T *From) {
164      auto ToOrErr = Importer.Import(From);
165      if (!ToOrErr)
166        return ToOrErr.takeError();
167      return cast_or_null<T>(*ToOrErr);
168    }
169
170    template <typename T>
171    Expected<T *> import(const T *From) {
172      return import(const_cast<T *>(From));
173    }
174
175    // Call the import function of ASTImporter for type `T`.
176    template <typename T>
177    Expected<T> import(const T &From) {
178      return Importer.Import(From);
179    }
180
181    // Import an Optional<T> by importing the contained T, if any.
182    template<typename T>
183    Expected<Optional<T>> import(Optional<T> From) {
184      if (!From)
185        return Optional<T>();
186      return import(*From);
187    }
188
189    // Helper for chaining together multiple imports. If an error is detected,
190    // subsequent imports will return default constructed nodes, so that failure
191    // can be detected with a single conditional branch after a sequence of
192    // imports.
193    template <typename T> T importChecked(Error &Err, const T &From) {
194      // Don't attempt to import nodes if we hit an error earlier.
195      if (Err)
196        return T{};
197      Expected<T> MaybeVal = import(From);
198      if (!MaybeVal) {
199        Err = MaybeVal.takeError();
200        return T{};
201      }
202      return *MaybeVal;
203    }
204
205    ExplicitSpecifier importExplicitSpecifier(Error &Err,
206                                              ExplicitSpecifier ESpec);
207
208    // Wrapper for an overload set.
209    template <typename ToDeclT> struct CallOverloadedCreateFun {
210      template <typename... Args> decltype(auto) operator()(Args &&... args) {
211        return ToDeclT::Create(std::forward<Args>(args)...);
212      }
213    };
214
215    // Always use these functions to create a Decl during import. There are
216    // certain tasks which must be done after the Decl was created, e.g. we
217    // must immediately register that as an imported Decl.  The parameter `ToD`
218    // will be set to the newly created Decl or if had been imported before
219    // then to the already imported Decl.  Returns a bool value set to true if
220    // the `FromD` had been imported before.
221    template <typename ToDeclT, typename FromDeclT, typename... Args>
222    LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
223                                                Args &&... args) {
224      // There may be several overloads of ToDeclT::Create. We must make sure
225      // to call the one which would be chosen by the arguments, thus we use a
226      // wrapper for the overload set.
227      CallOverloadedCreateFun<ToDeclT> OC;
228      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
229                                            std::forward<Args>(args)...);
230    }
231    // Use this overload if a special Type is needed to be created.  E.g if we
232    // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
233    // then:
234    // TypedefNameDecl *ToTypedef;
235    // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
236    template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
237              typename... Args>
238    LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
239                                                Args &&... args) {
240      CallOverloadedCreateFun<NewDeclT> OC;
241      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
242                                            std::forward<Args>(args)...);
243    }
244    // Use this version if a special create function must be
245    // used, e.g. CXXRecordDecl::CreateLambda .
246    template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
247              typename... Args>
248    LLVM_NODISCARD bool
249    GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
250                                   FromDeclT *FromD, Args &&... args) {
251      if (Importer.getImportDeclErrorIfAny(FromD)) {
252        ToD = nullptr;
253        return true; // Already imported but with error.
254      }
255      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
256      if (ToD)
257        return true; // Already imported.
258      ToD = CreateFun(std::forward<Args>(args)...);
259      // Keep track of imported Decls.
260      Importer.RegisterImportedDecl(FromD, ToD);
261      InitializeImportedDecl(FromD, ToD);
262      return false; // A new Decl is created.
263    }
264
265    void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
266      ToD->IdentifierNamespace = FromD->IdentifierNamespace;
267      if (FromD->isUsed())
268        ToD->setIsUsed();
269      if (FromD->isImplicit())
270        ToD->setImplicit();
271    }
272
273    // Check if we have found an existing definition.  Returns with that
274    // definition if yes, otherwise returns null.
275    Decl *FindAndMapDefinition(FunctionDecl *D, FunctionDecl *FoundFunction) {
276      const FunctionDecl *Definition = nullptr;
277      if (D->doesThisDeclarationHaveABody() &&
278          FoundFunction->hasBody(Definition))
279        return Importer.MapImported(D, const_cast<FunctionDecl *>(Definition));
280      return nullptr;
281    }
282
283    void addDeclToContexts(Decl *FromD, Decl *ToD) {
284      if (Importer.isMinimalImport()) {
285        // In minimal import case the decl must be added even if it is not
286        // contained in original context, for LLDB compatibility.
287        // FIXME: Check if a better solution is possible.
288        if (!FromD->getDescribedTemplate() &&
289            FromD->getFriendObjectKind() == Decl::FOK_None)
290          ToD->getLexicalDeclContext()->addDeclInternal(ToD);
291        return;
292      }
293
294      DeclContext *FromDC = FromD->getDeclContext();
295      DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
296      DeclContext *ToDC = ToD->getDeclContext();
297      DeclContext *ToLexicalDC = ToD->getLexicalDeclContext();
298
299      bool Visible = false;
300      if (FromDC->containsDeclAndLoad(FromD)) {
301        ToDC->addDeclInternal(ToD);
302        Visible = true;
303      }
304      if (ToDC != ToLexicalDC && FromLexicalDC->containsDeclAndLoad(FromD)) {
305        ToLexicalDC->addDeclInternal(ToD);
306        Visible = true;
307      }
308
309      // If the Decl was added to any context, it was made already visible.
310      // Otherwise it is still possible that it should be visible.
311      if (!Visible) {
312        if (auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
313          auto *ToNamed = cast<NamedDecl>(ToD);
314          DeclContextLookupResult FromLookup =
315              FromDC->lookup(FromNamed->getDeclName());
316          for (NamedDecl *ND : FromLookup)
317            if (ND == FromNamed) {
318              ToDC->makeDeclVisibleInContext(ToNamed);
319              break;
320            }
321        }
322      }
323    }
324
325  public:
326    explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
327
328    using TypeVisitor<ASTNodeImporter, ExpectedType>::Visit;
329    using DeclVisitor<ASTNodeImporter, ExpectedDecl>::Visit;
330    using StmtVisitor<ASTNodeImporter, ExpectedStmt>::Visit;
331
332    // Importing types
333    ExpectedType VisitType(const Type *T);
334    ExpectedType VisitAtomicType(const AtomicType *T);
335    ExpectedType VisitBuiltinType(const BuiltinType *T);
336    ExpectedType VisitDecayedType(const DecayedType *T);
337    ExpectedType VisitComplexType(const ComplexType *T);
338    ExpectedType VisitPointerType(const PointerType *T);
339    ExpectedType VisitBlockPointerType(const BlockPointerType *T);
340    ExpectedType VisitLValueReferenceType(const LValueReferenceType *T);
341    ExpectedType VisitRValueReferenceType(const RValueReferenceType *T);
342    ExpectedType VisitMemberPointerType(const MemberPointerType *T);
343    ExpectedType VisitConstantArrayType(const ConstantArrayType *T);
344    ExpectedType VisitIncompleteArrayType(const IncompleteArrayType *T);
345    ExpectedType VisitVariableArrayType(const VariableArrayType *T);
346    ExpectedType VisitDependentSizedArrayType(const DependentSizedArrayType *T);
347    // FIXME: DependentSizedExtVectorType
348    ExpectedType VisitVectorType(const VectorType *T);
349    ExpectedType VisitExtVectorType(const ExtVectorType *T);
350    ExpectedType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
351    ExpectedType VisitFunctionProtoType(const FunctionProtoType *T);
352    ExpectedType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
353    ExpectedType VisitParenType(const ParenType *T);
354    ExpectedType VisitTypedefType(const TypedefType *T);
355    ExpectedType VisitTypeOfExprType(const TypeOfExprType *T);
356    // FIXME: DependentTypeOfExprType
357    ExpectedType VisitTypeOfType(const TypeOfType *T);
358    ExpectedType VisitDecltypeType(const DecltypeType *T);
359    ExpectedType VisitUnaryTransformType(const UnaryTransformType *T);
360    ExpectedType VisitAutoType(const AutoType *T);
361    ExpectedType VisitDeducedTemplateSpecializationType(
362        const DeducedTemplateSpecializationType *T);
363    ExpectedType VisitInjectedClassNameType(const InjectedClassNameType *T);
364    // FIXME: DependentDecltypeType
365    ExpectedType VisitRecordType(const RecordType *T);
366    ExpectedType VisitEnumType(const EnumType *T);
367    ExpectedType VisitAttributedType(const AttributedType *T);
368    ExpectedType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
369    ExpectedType VisitSubstTemplateTypeParmType(
370        const SubstTemplateTypeParmType *T);
371    ExpectedType VisitTemplateSpecializationType(
372        const TemplateSpecializationType *T);
373    ExpectedType VisitElaboratedType(const ElaboratedType *T);
374    ExpectedType VisitDependentNameType(const DependentNameType *T);
375    ExpectedType VisitPackExpansionType(const PackExpansionType *T);
376    ExpectedType VisitDependentTemplateSpecializationType(
377        const DependentTemplateSpecializationType *T);
378    ExpectedType VisitObjCInterfaceType(const ObjCInterfaceType *T);
379    ExpectedType VisitObjCObjectType(const ObjCObjectType *T);
380    ExpectedType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
381
382    // Importing declarations
383    Error ImportDeclParts(NamedDecl *D, DeclarationName &Name, NamedDecl *&ToD,
384                          SourceLocation &Loc);
385    Error ImportDeclParts(
386        NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
387        DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc);
388    Error ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
389    Error ImportDeclarationNameLoc(
390        const DeclarationNameInfo &From, DeclarationNameInfo &To);
391    Error ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
392    Error ImportDeclContext(
393        Decl *From, DeclContext *&ToDC, DeclContext *&ToLexicalDC);
394    Error ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
395
396    Expected<CXXCastPath> ImportCastPath(CastExpr *E);
397    Expected<APValue> ImportAPValue(const APValue &FromValue);
398
399    using Designator = DesignatedInitExpr::Designator;
400
401    /// What we should import from the definition.
402    enum ImportDefinitionKind {
403      /// Import the default subset of the definition, which might be
404      /// nothing (if minimal import is set) or might be everything (if minimal
405      /// import is not set).
406      IDK_Default,
407      /// Import everything.
408      IDK_Everything,
409      /// Import only the bare bones needed to establish a valid
410      /// DeclContext.
411      IDK_Basic
412    };
413
414    bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
415      return IDK == IDK_Everything ||
416             (IDK == IDK_Default && !Importer.isMinimalImport());
417    }
418
419    Error ImportInitializer(VarDecl *From, VarDecl *To);
420    Error ImportDefinition(
421        RecordDecl *From, RecordDecl *To,
422        ImportDefinitionKind Kind = IDK_Default);
423    Error ImportDefinition(
424        EnumDecl *From, EnumDecl *To,
425        ImportDefinitionKind Kind = IDK_Default);
426    Error ImportDefinition(
427        ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
428        ImportDefinitionKind Kind = IDK_Default);
429    Error ImportDefinition(
430        ObjCProtocolDecl *From, ObjCProtocolDecl *To,
431        ImportDefinitionKind Kind = IDK_Default);
432    Error ImportTemplateArguments(
433        const TemplateArgument *FromArgs, unsigned NumFromArgs,
434        SmallVectorImpl<TemplateArgument> &ToArgs);
435    Expected<TemplateArgument>
436    ImportTemplateArgument(const TemplateArgument &From);
437
438    template <typename InContainerTy>
439    Error ImportTemplateArgumentListInfo(
440        const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo);
441
442    template<typename InContainerTy>
443    Error ImportTemplateArgumentListInfo(
444      SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
445      const InContainerTy &Container, TemplateArgumentListInfo &Result);
446
447    using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
448    using FunctionTemplateAndArgsTy =
449        std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
450    Expected<FunctionTemplateAndArgsTy>
451    ImportFunctionTemplateWithTemplateArgsFromSpecialization(
452        FunctionDecl *FromFD);
453    Error ImportTemplateParameterLists(const DeclaratorDecl *FromD,
454                                       DeclaratorDecl *ToD);
455
456    Error ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD);
457
458    Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD);
459
460    Error ImportDefaultArgOfParmVarDecl(const ParmVarDecl *FromParam,
461                                        ParmVarDecl *ToParam);
462
463    template <typename T>
464    bool hasSameVisibilityContextAndLinkage(T *Found, T *From);
465
466    bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
467    bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
468                           bool Complain = true);
469    bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
470                           bool Complain = true);
471    bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
472    bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
473    bool IsStructuralMatch(FunctionTemplateDecl *From,
474                           FunctionTemplateDecl *To);
475    bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
476    bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
477    bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
478    ExpectedDecl VisitDecl(Decl *D);
479    ExpectedDecl VisitImportDecl(ImportDecl *D);
480    ExpectedDecl VisitEmptyDecl(EmptyDecl *D);
481    ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D);
482    ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D);
483    ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
484    ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D);
485    ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
486    ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
487    ExpectedDecl VisitTypedefDecl(TypedefDecl *D);
488    ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D);
489    ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
490    ExpectedDecl VisitLabelDecl(LabelDecl *D);
491    ExpectedDecl VisitEnumDecl(EnumDecl *D);
492    ExpectedDecl VisitRecordDecl(RecordDecl *D);
493    ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D);
494    ExpectedDecl VisitFunctionDecl(FunctionDecl *D);
495    ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D);
496    ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D);
497    ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D);
498    ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D);
499    ExpectedDecl VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
500    ExpectedDecl VisitFieldDecl(FieldDecl *D);
501    ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D);
502    ExpectedDecl VisitFriendDecl(FriendDecl *D);
503    ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D);
504    ExpectedDecl VisitVarDecl(VarDecl *D);
505    ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D);
506    ExpectedDecl VisitParmVarDecl(ParmVarDecl *D);
507    ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D);
508    ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
509    ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D);
510    ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D);
511    ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D);
512    ExpectedDecl VisitUsingDecl(UsingDecl *D);
513    ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D);
514    ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
515    ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
516    ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
517    ExpectedDecl VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
518    ExpectedDecl
519    VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
520
521    Expected<ObjCTypeParamList *>
522    ImportObjCTypeParamList(ObjCTypeParamList *list);
523
524    ExpectedDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
525    ExpectedDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
526    ExpectedDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D);
527    ExpectedDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D);
528    ExpectedDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
529    ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
530    ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
531    ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
532    ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D);
533    ExpectedDecl VisitClassTemplateSpecializationDecl(
534                                            ClassTemplateSpecializationDecl *D);
535    ExpectedDecl VisitVarTemplateDecl(VarTemplateDecl *D);
536    ExpectedDecl VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
537    ExpectedDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
538
539    // Importing statements
540    ExpectedStmt VisitStmt(Stmt *S);
541    ExpectedStmt VisitGCCAsmStmt(GCCAsmStmt *S);
542    ExpectedStmt VisitDeclStmt(DeclStmt *S);
543    ExpectedStmt VisitNullStmt(NullStmt *S);
544    ExpectedStmt VisitCompoundStmt(CompoundStmt *S);
545    ExpectedStmt VisitCaseStmt(CaseStmt *S);
546    ExpectedStmt VisitDefaultStmt(DefaultStmt *S);
547    ExpectedStmt VisitLabelStmt(LabelStmt *S);
548    ExpectedStmt VisitAttributedStmt(AttributedStmt *S);
549    ExpectedStmt VisitIfStmt(IfStmt *S);
550    ExpectedStmt VisitSwitchStmt(SwitchStmt *S);
551    ExpectedStmt VisitWhileStmt(WhileStmt *S);
552    ExpectedStmt VisitDoStmt(DoStmt *S);
553    ExpectedStmt VisitForStmt(ForStmt *S);
554    ExpectedStmt VisitGotoStmt(GotoStmt *S);
555    ExpectedStmt VisitIndirectGotoStmt(IndirectGotoStmt *S);
556    ExpectedStmt VisitContinueStmt(ContinueStmt *S);
557    ExpectedStmt VisitBreakStmt(BreakStmt *S);
558    ExpectedStmt VisitReturnStmt(ReturnStmt *S);
559    // FIXME: MSAsmStmt
560    // FIXME: SEHExceptStmt
561    // FIXME: SEHFinallyStmt
562    // FIXME: SEHTryStmt
563    // FIXME: SEHLeaveStmt
564    // FIXME: CapturedStmt
565    ExpectedStmt VisitCXXCatchStmt(CXXCatchStmt *S);
566    ExpectedStmt VisitCXXTryStmt(CXXTryStmt *S);
567    ExpectedStmt VisitCXXForRangeStmt(CXXForRangeStmt *S);
568    // FIXME: MSDependentExistsStmt
569    ExpectedStmt VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
570    ExpectedStmt VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
571    ExpectedStmt VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
572    ExpectedStmt VisitObjCAtTryStmt(ObjCAtTryStmt *S);
573    ExpectedStmt VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
574    ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
575    ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
576
577    // Importing expressions
578    ExpectedStmt VisitExpr(Expr *E);
579    ExpectedStmt VisitSourceLocExpr(SourceLocExpr *E);
580    ExpectedStmt VisitVAArgExpr(VAArgExpr *E);
581    ExpectedStmt VisitChooseExpr(ChooseExpr *E);
582    ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E);
583    ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E);
584    ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E);
585    ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E);
586    ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
587    ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E);
588    ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
589    ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E);
590    ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E);
591    ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E);
592    ExpectedStmt VisitFixedPointLiteral(FixedPointLiteral *E);
593    ExpectedStmt VisitCharacterLiteral(CharacterLiteral *E);
594    ExpectedStmt VisitStringLiteral(StringLiteral *E);
595    ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
596    ExpectedStmt VisitAtomicExpr(AtomicExpr *E);
597    ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E);
598    ExpectedStmt VisitConstantExpr(ConstantExpr *E);
599    ExpectedStmt VisitParenExpr(ParenExpr *E);
600    ExpectedStmt VisitParenListExpr(ParenListExpr *E);
601    ExpectedStmt VisitStmtExpr(StmtExpr *E);
602    ExpectedStmt VisitUnaryOperator(UnaryOperator *E);
603    ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
604    ExpectedStmt VisitBinaryOperator(BinaryOperator *E);
605    ExpectedStmt VisitConditionalOperator(ConditionalOperator *E);
606    ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
607    ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E);
608    ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
609    ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E);
610    ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E);
611    ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E);
612    ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E);
613    ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E);
614    ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE);
615    ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E);
616    ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
617    ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
618    ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
619    ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
620    ExpectedStmt VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
621    ExpectedStmt VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
622    ExpectedStmt VisitPackExpansionExpr(PackExpansionExpr *E);
623    ExpectedStmt VisitSizeOfPackExpr(SizeOfPackExpr *E);
624    ExpectedStmt VisitCXXNewExpr(CXXNewExpr *E);
625    ExpectedStmt VisitCXXDeleteExpr(CXXDeleteExpr *E);
626    ExpectedStmt VisitCXXConstructExpr(CXXConstructExpr *E);
627    ExpectedStmt VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
628    ExpectedStmt VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
629    ExpectedStmt VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
630    ExpectedStmt VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
631    ExpectedStmt VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
632    ExpectedStmt VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
633    ExpectedStmt VisitExprWithCleanups(ExprWithCleanups *E);
634    ExpectedStmt VisitCXXThisExpr(CXXThisExpr *E);
635    ExpectedStmt VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
636    ExpectedStmt VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
637    ExpectedStmt VisitMemberExpr(MemberExpr *E);
638    ExpectedStmt VisitCallExpr(CallExpr *E);
639    ExpectedStmt VisitLambdaExpr(LambdaExpr *LE);
640    ExpectedStmt VisitInitListExpr(InitListExpr *E);
641    ExpectedStmt VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
642    ExpectedStmt VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E);
643    ExpectedStmt VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
644    ExpectedStmt VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
645    ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
646    ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
647    ExpectedStmt VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
648    ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E);
649    ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E);
650    ExpectedStmt VisitCXXFoldExpr(CXXFoldExpr *E);
651
652    template<typename IIter, typename OIter>
653    Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
654      using ItemT = std::remove_reference_t<decltype(*Obegin)>;
655      for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
656        Expected<ItemT> ToOrErr = import(*Ibegin);
657        if (!ToOrErr)
658          return ToOrErr.takeError();
659        *Obegin = *ToOrErr;
660      }
661      return Error::success();
662    }
663
664    // Import every item from a container structure into an output container.
665    // If error occurs, stops at first error and returns the error.
666    // The output container should have space for all needed elements (it is not
667    // expanded, new items are put into from the beginning).
668    template<typename InContainerTy, typename OutContainerTy>
669    Error ImportContainerChecked(
670        const InContainerTy &InContainer, OutContainerTy &OutContainer) {
671      return ImportArrayChecked(
672          InContainer.begin(), InContainer.end(), OutContainer.begin());
673    }
674
675    template<typename InContainerTy, typename OIter>
676    Error ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
677      return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
678    }
679
680    Error ImportOverriddenMethods(CXXMethodDecl *ToMethod,
681                                  CXXMethodDecl *FromMethod);
682
683    Expected<FunctionDecl *> FindFunctionTemplateSpecialization(
684        FunctionDecl *FromFD);
685
686    // Returns true if the given function has a placeholder return type and
687    // that type is declared inside the body of the function.
688    // E.g. auto f() { struct X{}; return X(); }
689    bool hasAutoReturnTypeDeclaredInside(FunctionDecl *D);
690  };
691
692template <typename InContainerTy>
693Error ASTNodeImporter::ImportTemplateArgumentListInfo(
694    SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
695    const InContainerTy &Container, TemplateArgumentListInfo &Result) {
696  auto ToLAngleLocOrErr = import(FromLAngleLoc);
697  if (!ToLAngleLocOrErr)
698    return ToLAngleLocOrErr.takeError();
699  auto ToRAngleLocOrErr = import(FromRAngleLoc);
700  if (!ToRAngleLocOrErr)
701    return ToRAngleLocOrErr.takeError();
702
703  TemplateArgumentListInfo ToTAInfo(*ToLAngleLocOrErr, *ToRAngleLocOrErr);
704  if (auto Err = ImportTemplateArgumentListInfo(Container, ToTAInfo))
705    return Err;
706  Result = ToTAInfo;
707  return Error::success();
708}
709
710template <>
711Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
712    const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
713  return ImportTemplateArgumentListInfo(
714      From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
715}
716
717template <>
718Error ASTNodeImporter::ImportTemplateArgumentListInfo<
719    ASTTemplateArgumentListInfo>(
720        const ASTTemplateArgumentListInfo &From,
721        TemplateArgumentListInfo &Result) {
722  return ImportTemplateArgumentListInfo(
723      From.LAngleLoc, From.RAngleLoc, From.arguments(), Result);
724}
725
726Expected<ASTNodeImporter::FunctionTemplateAndArgsTy>
727ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
728    FunctionDecl *FromFD) {
729  assert(FromFD->getTemplatedKind() ==
730      FunctionDecl::TK_FunctionTemplateSpecialization);
731
732  FunctionTemplateAndArgsTy Result;
733
734  auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
735  if (Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate()))
736    return std::move(Err);
737
738  // Import template arguments.
739  auto TemplArgs = FTSInfo->TemplateArguments->asArray();
740  if (Error Err = ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
741      std::get<1>(Result)))
742    return std::move(Err);
743
744  return Result;
745}
746
747template <>
748Expected<TemplateParameterList *>
749ASTNodeImporter::import(TemplateParameterList *From) {
750  SmallVector<NamedDecl *, 4> To(From->size());
751  if (Error Err = ImportContainerChecked(*From, To))
752    return std::move(Err);
753
754  ExpectedExpr ToRequiresClause = import(From->getRequiresClause());
755  if (!ToRequiresClause)
756    return ToRequiresClause.takeError();
757
758  auto ToTemplateLocOrErr = import(From->getTemplateLoc());
759  if (!ToTemplateLocOrErr)
760    return ToTemplateLocOrErr.takeError();
761  auto ToLAngleLocOrErr = import(From->getLAngleLoc());
762  if (!ToLAngleLocOrErr)
763    return ToLAngleLocOrErr.takeError();
764  auto ToRAngleLocOrErr = import(From->getRAngleLoc());
765  if (!ToRAngleLocOrErr)
766    return ToRAngleLocOrErr.takeError();
767
768  return TemplateParameterList::Create(
769      Importer.getToContext(),
770      *ToTemplateLocOrErr,
771      *ToLAngleLocOrErr,
772      To,
773      *ToRAngleLocOrErr,
774      *ToRequiresClause);
775}
776
777template <>
778Expected<TemplateArgument>
779ASTNodeImporter::import(const TemplateArgument &From) {
780  switch (From.getKind()) {
781  case TemplateArgument::Null:
782    return TemplateArgument();
783
784  case TemplateArgument::Type: {
785    ExpectedType ToTypeOrErr = import(From.getAsType());
786    if (!ToTypeOrErr)
787      return ToTypeOrErr.takeError();
788    return TemplateArgument(*ToTypeOrErr);
789  }
790
791  case TemplateArgument::Integral: {
792    ExpectedType ToTypeOrErr = import(From.getIntegralType());
793    if (!ToTypeOrErr)
794      return ToTypeOrErr.takeError();
795    return TemplateArgument(From, *ToTypeOrErr);
796  }
797
798  case TemplateArgument::Declaration: {
799    Expected<ValueDecl *> ToOrErr = import(From.getAsDecl());
800    if (!ToOrErr)
801      return ToOrErr.takeError();
802    ExpectedType ToTypeOrErr = import(From.getParamTypeForDecl());
803    if (!ToTypeOrErr)
804      return ToTypeOrErr.takeError();
805    return TemplateArgument(*ToOrErr, *ToTypeOrErr);
806  }
807
808  case TemplateArgument::NullPtr: {
809    ExpectedType ToTypeOrErr = import(From.getNullPtrType());
810    if (!ToTypeOrErr)
811      return ToTypeOrErr.takeError();
812    return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/true);
813  }
814
815  case TemplateArgument::Template: {
816    Expected<TemplateName> ToTemplateOrErr = import(From.getAsTemplate());
817    if (!ToTemplateOrErr)
818      return ToTemplateOrErr.takeError();
819
820    return TemplateArgument(*ToTemplateOrErr);
821  }
822
823  case TemplateArgument::TemplateExpansion: {
824    Expected<TemplateName> ToTemplateOrErr =
825        import(From.getAsTemplateOrTemplatePattern());
826    if (!ToTemplateOrErr)
827      return ToTemplateOrErr.takeError();
828
829    return TemplateArgument(
830        *ToTemplateOrErr, From.getNumTemplateExpansions());
831  }
832
833  case TemplateArgument::Expression:
834    if (ExpectedExpr ToExpr = import(From.getAsExpr()))
835      return TemplateArgument(*ToExpr);
836    else
837      return ToExpr.takeError();
838
839  case TemplateArgument::Pack: {
840    SmallVector<TemplateArgument, 2> ToPack;
841    ToPack.reserve(From.pack_size());
842    if (Error Err = ImportTemplateArguments(
843        From.pack_begin(), From.pack_size(), ToPack))
844      return std::move(Err);
845
846    return TemplateArgument(
847        llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
848  }
849  }
850
851  llvm_unreachable("Invalid template argument kind");
852}
853
854template <>
855Expected<TemplateArgumentLoc>
856ASTNodeImporter::import(const TemplateArgumentLoc &TALoc) {
857  Expected<TemplateArgument> ArgOrErr = import(TALoc.getArgument());
858  if (!ArgOrErr)
859    return ArgOrErr.takeError();
860  TemplateArgument Arg = *ArgOrErr;
861
862  TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
863
864  TemplateArgumentLocInfo ToInfo;
865  if (Arg.getKind() == TemplateArgument::Expression) {
866    ExpectedExpr E = import(FromInfo.getAsExpr());
867    if (!E)
868      return E.takeError();
869    ToInfo = TemplateArgumentLocInfo(*E);
870  } else if (Arg.getKind() == TemplateArgument::Type) {
871    if (auto TSIOrErr = import(FromInfo.getAsTypeSourceInfo()))
872      ToInfo = TemplateArgumentLocInfo(*TSIOrErr);
873    else
874      return TSIOrErr.takeError();
875  } else {
876    auto ToTemplateQualifierLocOrErr =
877        import(FromInfo.getTemplateQualifierLoc());
878    if (!ToTemplateQualifierLocOrErr)
879      return ToTemplateQualifierLocOrErr.takeError();
880    auto ToTemplateNameLocOrErr = import(FromInfo.getTemplateNameLoc());
881    if (!ToTemplateNameLocOrErr)
882      return ToTemplateNameLocOrErr.takeError();
883    auto ToTemplateEllipsisLocOrErr =
884        import(FromInfo.getTemplateEllipsisLoc());
885    if (!ToTemplateEllipsisLocOrErr)
886      return ToTemplateEllipsisLocOrErr.takeError();
887    ToInfo = TemplateArgumentLocInfo(
888        Importer.getToContext(), *ToTemplateQualifierLocOrErr,
889        *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
890  }
891
892  return TemplateArgumentLoc(Arg, ToInfo);
893}
894
895template <>
896Expected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) {
897  if (DG.isNull())
898    return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
899  size_t NumDecls = DG.end() - DG.begin();
900  SmallVector<Decl *, 1> ToDecls;
901  ToDecls.reserve(NumDecls);
902  for (Decl *FromD : DG) {
903    if (auto ToDOrErr = import(FromD))
904      ToDecls.push_back(*ToDOrErr);
905    else
906      return ToDOrErr.takeError();
907  }
908  return DeclGroupRef::Create(Importer.getToContext(),
909                              ToDecls.begin(),
910                              NumDecls);
911}
912
913template <>
914Expected<ASTNodeImporter::Designator>
915ASTNodeImporter::import(const Designator &D) {
916  if (D.isFieldDesignator()) {
917    IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
918
919    ExpectedSLoc ToDotLocOrErr = import(D.getDotLoc());
920    if (!ToDotLocOrErr)
921      return ToDotLocOrErr.takeError();
922
923    ExpectedSLoc ToFieldLocOrErr = import(D.getFieldLoc());
924    if (!ToFieldLocOrErr)
925      return ToFieldLocOrErr.takeError();
926
927    return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
928  }
929
930  ExpectedSLoc ToLBracketLocOrErr = import(D.getLBracketLoc());
931  if (!ToLBracketLocOrErr)
932    return ToLBracketLocOrErr.takeError();
933
934  ExpectedSLoc ToRBracketLocOrErr = import(D.getRBracketLoc());
935  if (!ToRBracketLocOrErr)
936    return ToRBracketLocOrErr.takeError();
937
938  if (D.isArrayDesignator())
939    return Designator(D.getFirstExprIndex(),
940                      *ToLBracketLocOrErr, *ToRBracketLocOrErr);
941
942  ExpectedSLoc ToEllipsisLocOrErr = import(D.getEllipsisLoc());
943  if (!ToEllipsisLocOrErr)
944    return ToEllipsisLocOrErr.takeError();
945
946  assert(D.isArrayRangeDesignator());
947  return Designator(
948      D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
949      *ToRBracketLocOrErr);
950}
951
952template <>
953Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
954  VarDecl *Var = nullptr;
955  if (From.capturesVariable()) {
956    if (auto VarOrErr = import(From.getCapturedVar()))
957      Var = *VarOrErr;
958    else
959      return VarOrErr.takeError();
960  }
961
962  auto LocationOrErr = import(From.getLocation());
963  if (!LocationOrErr)
964    return LocationOrErr.takeError();
965
966  SourceLocation EllipsisLoc;
967  if (From.isPackExpansion())
968    if (Error Err = importInto(EllipsisLoc, From.getEllipsisLoc()))
969      return std::move(Err);
970
971  return LambdaCapture(
972      *LocationOrErr, From.isImplicit(), From.getCaptureKind(), Var,
973      EllipsisLoc);
974}
975
976template <typename T>
977bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(T *Found, T *From) {
978  if (Found->getLinkageInternal() != From->getLinkageInternal())
979    return false;
980
981  if (From->hasExternalFormalLinkage())
982    return Found->hasExternalFormalLinkage();
983  if (Importer.GetFromTU(Found) != From->getTranslationUnitDecl())
984    return false;
985  if (From->isInAnonymousNamespace())
986    return Found->isInAnonymousNamespace();
987  else
988    return !Found->isInAnonymousNamespace() &&
989           !Found->hasExternalFormalLinkage();
990}
991
992template <>
993bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(TypedefNameDecl *Found,
994                                               TypedefNameDecl *From) {
995  if (Found->getLinkageInternal() != From->getLinkageInternal())
996    return false;
997
998  if (From->isInAnonymousNamespace() && Found->isInAnonymousNamespace())
999    return Importer.GetFromTU(Found) == From->getTranslationUnitDecl();
1000  return From->isInAnonymousNamespace() == Found->isInAnonymousNamespace();
1001}
1002
1003} // namespace clang
1004
1005//----------------------------------------------------------------------------
1006// Import Types
1007//----------------------------------------------------------------------------
1008
1009using namespace clang;
1010
1011ExpectedType ASTNodeImporter::VisitType(const Type *T) {
1012  Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1013    << T->getTypeClassName();
1014  return make_error<ImportError>(ImportError::UnsupportedConstruct);
1015}
1016
1017ExpectedType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
1018  ExpectedType UnderlyingTypeOrErr = import(T->getValueType());
1019  if (!UnderlyingTypeOrErr)
1020    return UnderlyingTypeOrErr.takeError();
1021
1022  return Importer.getToContext().getAtomicType(*UnderlyingTypeOrErr);
1023}
1024
1025ExpectedType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1026  switch (T->getKind()) {
1027#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1028  case BuiltinType::Id: \
1029    return Importer.getToContext().SingletonId;
1030#include "clang/Basic/OpenCLImageTypes.def"
1031#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1032  case BuiltinType::Id: \
1033    return Importer.getToContext().Id##Ty;
1034#include "clang/Basic/OpenCLExtensionTypes.def"
1035#define SVE_TYPE(Name, Id, SingletonId) \
1036  case BuiltinType::Id: \
1037    return Importer.getToContext().SingletonId;
1038#include "clang/Basic/AArch64SVEACLETypes.def"
1039#define PPC_VECTOR_TYPE(Name, Id, Size) \
1040  case BuiltinType::Id: \
1041    return Importer.getToContext().Id##Ty;
1042#include "clang/Basic/PPCTypes.def"
1043#define RVV_TYPE(Name, Id, SingletonId)                                        \
1044  case BuiltinType::Id:                                                        \
1045    return Importer.getToContext().SingletonId;
1046#include "clang/Basic/RISCVVTypes.def"
1047#define SHARED_SINGLETON_TYPE(Expansion)
1048#define BUILTIN_TYPE(Id, SingletonId) \
1049  case BuiltinType::Id: return Importer.getToContext().SingletonId;
1050#include "clang/AST/BuiltinTypes.def"
1051
1052  // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1053  // context supports C++.
1054
1055  // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1056  // context supports ObjC.
1057
1058  case BuiltinType::Char_U:
1059    // The context we're importing from has an unsigned 'char'. If we're
1060    // importing into a context with a signed 'char', translate to
1061    // 'unsigned char' instead.
1062    if (Importer.getToContext().getLangOpts().CharIsSigned)
1063      return Importer.getToContext().UnsignedCharTy;
1064
1065    return Importer.getToContext().CharTy;
1066
1067  case BuiltinType::Char_S:
1068    // The context we're importing from has an unsigned 'char'. If we're
1069    // importing into a context with a signed 'char', translate to
1070    // 'unsigned char' instead.
1071    if (!Importer.getToContext().getLangOpts().CharIsSigned)
1072      return Importer.getToContext().SignedCharTy;
1073
1074    return Importer.getToContext().CharTy;
1075
1076  case BuiltinType::WChar_S:
1077  case BuiltinType::WChar_U:
1078    // FIXME: If not in C++, shall we translate to the C equivalent of
1079    // wchar_t?
1080    return Importer.getToContext().WCharTy;
1081  }
1082
1083  llvm_unreachable("Invalid BuiltinType Kind!");
1084}
1085
1086ExpectedType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
1087  ExpectedType ToOriginalTypeOrErr = import(T->getOriginalType());
1088  if (!ToOriginalTypeOrErr)
1089    return ToOriginalTypeOrErr.takeError();
1090
1091  return Importer.getToContext().getDecayedType(*ToOriginalTypeOrErr);
1092}
1093
1094ExpectedType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1095  ExpectedType ToElementTypeOrErr = import(T->getElementType());
1096  if (!ToElementTypeOrErr)
1097    return ToElementTypeOrErr.takeError();
1098
1099  return Importer.getToContext().getComplexType(*ToElementTypeOrErr);
1100}
1101
1102ExpectedType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1103  ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1104  if (!ToPointeeTypeOrErr)
1105    return ToPointeeTypeOrErr.takeError();
1106
1107  return Importer.getToContext().getPointerType(*ToPointeeTypeOrErr);
1108}
1109
1110ExpectedType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1111  // FIXME: Check for blocks support in "to" context.
1112  ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1113  if (!ToPointeeTypeOrErr)
1114    return ToPointeeTypeOrErr.takeError();
1115
1116  return Importer.getToContext().getBlockPointerType(*ToPointeeTypeOrErr);
1117}
1118
1119ExpectedType
1120ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1121  // FIXME: Check for C++ support in "to" context.
1122  ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
1123  if (!ToPointeeTypeOrErr)
1124    return ToPointeeTypeOrErr.takeError();
1125
1126  return Importer.getToContext().getLValueReferenceType(*ToPointeeTypeOrErr);
1127}
1128
1129ExpectedType
1130ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1131  // FIXME: Check for C++0x support in "to" context.
1132  ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
1133  if (!ToPointeeTypeOrErr)
1134    return ToPointeeTypeOrErr.takeError();
1135
1136  return Importer.getToContext().getRValueReferenceType(*ToPointeeTypeOrErr);
1137}
1138
1139ExpectedType
1140ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1141  // FIXME: Check for C++ support in "to" context.
1142  ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1143  if (!ToPointeeTypeOrErr)
1144    return ToPointeeTypeOrErr.takeError();
1145
1146  ExpectedType ClassTypeOrErr = import(QualType(T->getClass(), 0));
1147  if (!ClassTypeOrErr)
1148    return ClassTypeOrErr.takeError();
1149
1150  return Importer.getToContext().getMemberPointerType(
1151      *ToPointeeTypeOrErr, (*ClassTypeOrErr).getTypePtr());
1152}
1153
1154ExpectedType
1155ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1156  Error Err = Error::success();
1157  auto ToElementType = importChecked(Err, T->getElementType());
1158  auto ToSizeExpr = importChecked(Err, T->getSizeExpr());
1159  if (Err)
1160    return std::move(Err);
1161
1162  return Importer.getToContext().getConstantArrayType(
1163      ToElementType, T->getSize(), ToSizeExpr, T->getSizeModifier(),
1164      T->getIndexTypeCVRQualifiers());
1165}
1166
1167ExpectedType
1168ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1169  ExpectedType ToElementTypeOrErr = import(T->getElementType());
1170  if (!ToElementTypeOrErr)
1171    return ToElementTypeOrErr.takeError();
1172
1173  return Importer.getToContext().getIncompleteArrayType(*ToElementTypeOrErr,
1174                                                        T->getSizeModifier(),
1175                                                T->getIndexTypeCVRQualifiers());
1176}
1177
1178ExpectedType
1179ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1180  Error Err = Error::success();
1181  QualType ToElementType = importChecked(Err, T->getElementType());
1182  Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
1183  SourceRange ToBracketsRange = importChecked(Err, T->getBracketsRange());
1184  if (Err)
1185    return std::move(Err);
1186  return Importer.getToContext().getVariableArrayType(
1187      ToElementType, ToSizeExpr, T->getSizeModifier(),
1188      T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1189}
1190
1191ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
1192    const DependentSizedArrayType *T) {
1193  Error Err = Error::success();
1194  QualType ToElementType = importChecked(Err, T->getElementType());
1195  Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
1196  SourceRange ToBracketsRange = importChecked(Err, T->getBracketsRange());
1197  if (Err)
1198    return std::move(Err);
1199  // SizeExpr may be null if size is not specified directly.
1200  // For example, 'int a[]'.
1201
1202  return Importer.getToContext().getDependentSizedArrayType(
1203      ToElementType, ToSizeExpr, T->getSizeModifier(),
1204      T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1205}
1206
1207ExpectedType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1208  ExpectedType ToElementTypeOrErr = import(T->getElementType());
1209  if (!ToElementTypeOrErr)
1210    return ToElementTypeOrErr.takeError();
1211
1212  return Importer.getToContext().getVectorType(*ToElementTypeOrErr,
1213                                               T->getNumElements(),
1214                                               T->getVectorKind());
1215}
1216
1217ExpectedType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1218  ExpectedType ToElementTypeOrErr = import(T->getElementType());
1219  if (!ToElementTypeOrErr)
1220    return ToElementTypeOrErr.takeError();
1221
1222  return Importer.getToContext().getExtVectorType(*ToElementTypeOrErr,
1223                                                  T->getNumElements());
1224}
1225
1226ExpectedType
1227ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1228  // FIXME: What happens if we're importing a function without a prototype
1229  // into C++? Should we make it variadic?
1230  ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1231  if (!ToReturnTypeOrErr)
1232    return ToReturnTypeOrErr.takeError();
1233
1234  return Importer.getToContext().getFunctionNoProtoType(*ToReturnTypeOrErr,
1235                                                        T->getExtInfo());
1236}
1237
1238ExpectedType
1239ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1240  ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1241  if (!ToReturnTypeOrErr)
1242    return ToReturnTypeOrErr.takeError();
1243
1244  // Import argument types
1245  SmallVector<QualType, 4> ArgTypes;
1246  for (const auto &A : T->param_types()) {
1247    ExpectedType TyOrErr = import(A);
1248    if (!TyOrErr)
1249      return TyOrErr.takeError();
1250    ArgTypes.push_back(*TyOrErr);
1251  }
1252
1253  // Import exception types
1254  SmallVector<QualType, 4> ExceptionTypes;
1255  for (const auto &E : T->exceptions()) {
1256    ExpectedType TyOrErr = import(E);
1257    if (!TyOrErr)
1258      return TyOrErr.takeError();
1259    ExceptionTypes.push_back(*TyOrErr);
1260  }
1261
1262  FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1263  Error Err = Error::success();
1264  FunctionProtoType::ExtProtoInfo ToEPI;
1265  ToEPI.ExtInfo = FromEPI.ExtInfo;
1266  ToEPI.Variadic = FromEPI.Variadic;
1267  ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1268  ToEPI.TypeQuals = FromEPI.TypeQuals;
1269  ToEPI.RefQualifier = FromEPI.RefQualifier;
1270  ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
1271  ToEPI.ExceptionSpec.NoexceptExpr =
1272      importChecked(Err, FromEPI.ExceptionSpec.NoexceptExpr);
1273  ToEPI.ExceptionSpec.SourceDecl =
1274      importChecked(Err, FromEPI.ExceptionSpec.SourceDecl);
1275  ToEPI.ExceptionSpec.SourceTemplate =
1276      importChecked(Err, FromEPI.ExceptionSpec.SourceTemplate);
1277  ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
1278
1279  if (Err)
1280    return std::move(Err);
1281
1282  return Importer.getToContext().getFunctionType(
1283      *ToReturnTypeOrErr, ArgTypes, ToEPI);
1284}
1285
1286ExpectedType ASTNodeImporter::VisitUnresolvedUsingType(
1287    const UnresolvedUsingType *T) {
1288  Error Err = Error::success();
1289  auto ToD = importChecked(Err, T->getDecl());
1290  auto ToPrevD = importChecked(Err, T->getDecl()->getPreviousDecl());
1291  if (Err)
1292    return std::move(Err);
1293
1294  return Importer.getToContext().getTypeDeclType(
1295      ToD, cast_or_null<TypeDecl>(ToPrevD));
1296}
1297
1298ExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) {
1299  ExpectedType ToInnerTypeOrErr = import(T->getInnerType());
1300  if (!ToInnerTypeOrErr)
1301    return ToInnerTypeOrErr.takeError();
1302
1303  return Importer.getToContext().getParenType(*ToInnerTypeOrErr);
1304}
1305
1306ExpectedType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1307  Expected<TypedefNameDecl *> ToDeclOrErr = import(T->getDecl());
1308  if (!ToDeclOrErr)
1309    return ToDeclOrErr.takeError();
1310
1311  return Importer.getToContext().getTypeDeclType(*ToDeclOrErr);
1312}
1313
1314ExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1315  ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1316  if (!ToExprOrErr)
1317    return ToExprOrErr.takeError();
1318
1319  return Importer.getToContext().getTypeOfExprType(*ToExprOrErr);
1320}
1321
1322ExpectedType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1323  ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1324  if (!ToUnderlyingTypeOrErr)
1325    return ToUnderlyingTypeOrErr.takeError();
1326
1327  return Importer.getToContext().getTypeOfType(*ToUnderlyingTypeOrErr);
1328}
1329
1330ExpectedType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1331  // FIXME: Make sure that the "to" context supports C++0x!
1332  ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1333  if (!ToExprOrErr)
1334    return ToExprOrErr.takeError();
1335
1336  ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1337  if (!ToUnderlyingTypeOrErr)
1338    return ToUnderlyingTypeOrErr.takeError();
1339
1340  return Importer.getToContext().getDecltypeType(
1341      *ToExprOrErr, *ToUnderlyingTypeOrErr);
1342}
1343
1344ExpectedType
1345ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1346  ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1347  if (!ToBaseTypeOrErr)
1348    return ToBaseTypeOrErr.takeError();
1349
1350  ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1351  if (!ToUnderlyingTypeOrErr)
1352    return ToUnderlyingTypeOrErr.takeError();
1353
1354  return Importer.getToContext().getUnaryTransformType(
1355      *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->getUTTKind());
1356}
1357
1358ExpectedType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1359  // FIXME: Make sure that the "to" context supports C++11!
1360  ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1361  if (!ToDeducedTypeOrErr)
1362    return ToDeducedTypeOrErr.takeError();
1363
1364  ExpectedDecl ToTypeConstraintConcept = import(T->getTypeConstraintConcept());
1365  if (!ToTypeConstraintConcept)
1366    return ToTypeConstraintConcept.takeError();
1367
1368  SmallVector<TemplateArgument, 2> ToTemplateArgs;
1369  ArrayRef<TemplateArgument> FromTemplateArgs = T->getTypeConstraintArguments();
1370  if (Error Err = ImportTemplateArguments(FromTemplateArgs.data(),
1371                                          FromTemplateArgs.size(),
1372                                          ToTemplateArgs))
1373    return std::move(Err);
1374
1375  return Importer.getToContext().getAutoType(
1376      *ToDeducedTypeOrErr, T->getKeyword(), /*IsDependent*/false,
1377      /*IsPack=*/false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1378      ToTemplateArgs);
1379}
1380
1381ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
1382    const DeducedTemplateSpecializationType *T) {
1383  // FIXME: Make sure that the "to" context supports C++17!
1384  Expected<TemplateName> ToTemplateNameOrErr = import(T->getTemplateName());
1385  if (!ToTemplateNameOrErr)
1386    return ToTemplateNameOrErr.takeError();
1387  ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1388  if (!ToDeducedTypeOrErr)
1389    return ToDeducedTypeOrErr.takeError();
1390
1391  return Importer.getToContext().getDeducedTemplateSpecializationType(
1392      *ToTemplateNameOrErr, *ToDeducedTypeOrErr, T->isDependentType());
1393}
1394
1395ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
1396    const InjectedClassNameType *T) {
1397  Expected<CXXRecordDecl *> ToDeclOrErr = import(T->getDecl());
1398  if (!ToDeclOrErr)
1399    return ToDeclOrErr.takeError();
1400
1401  ExpectedType ToInjTypeOrErr = import(T->getInjectedSpecializationType());
1402  if (!ToInjTypeOrErr)
1403    return ToInjTypeOrErr.takeError();
1404
1405  // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
1406  // See comments in InjectedClassNameType definition for details
1407  // return Importer.getToContext().getInjectedClassNameType(D, InjType);
1408  enum {
1409    TypeAlignmentInBits = 4,
1410    TypeAlignment = 1 << TypeAlignmentInBits
1411  };
1412
1413  return QualType(new (Importer.getToContext(), TypeAlignment)
1414                  InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0);
1415}
1416
1417ExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1418  Expected<RecordDecl *> ToDeclOrErr = import(T->getDecl());
1419  if (!ToDeclOrErr)
1420    return ToDeclOrErr.takeError();
1421
1422  return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
1423}
1424
1425ExpectedType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1426  Expected<EnumDecl *> ToDeclOrErr = import(T->getDecl());
1427  if (!ToDeclOrErr)
1428    return ToDeclOrErr.takeError();
1429
1430  return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
1431}
1432
1433ExpectedType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
1434  ExpectedType ToModifiedTypeOrErr = import(T->getModifiedType());
1435  if (!ToModifiedTypeOrErr)
1436    return ToModifiedTypeOrErr.takeError();
1437  ExpectedType ToEquivalentTypeOrErr = import(T->getEquivalentType());
1438  if (!ToEquivalentTypeOrErr)
1439    return ToEquivalentTypeOrErr.takeError();
1440
1441  return Importer.getToContext().getAttributedType(T->getAttrKind(),
1442      *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1443}
1444
1445ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
1446    const TemplateTypeParmType *T) {
1447  Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(T->getDecl());
1448  if (!ToDeclOrErr)
1449    return ToDeclOrErr.takeError();
1450
1451  return Importer.getToContext().getTemplateTypeParmType(
1452      T->getDepth(), T->getIndex(), T->isParameterPack(), *ToDeclOrErr);
1453}
1454
1455ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1456    const SubstTemplateTypeParmType *T) {
1457  ExpectedType ReplacedOrErr = import(QualType(T->getReplacedParameter(), 0));
1458  if (!ReplacedOrErr)
1459    return ReplacedOrErr.takeError();
1460  const TemplateTypeParmType *Replaced =
1461      cast<TemplateTypeParmType>((*ReplacedOrErr).getTypePtr());
1462
1463  ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType());
1464  if (!ToReplacementTypeOrErr)
1465    return ToReplacementTypeOrErr.takeError();
1466
1467  return Importer.getToContext().getSubstTemplateTypeParmType(
1468        Replaced, (*ToReplacementTypeOrErr).getCanonicalType());
1469}
1470
1471ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
1472                                       const TemplateSpecializationType *T) {
1473  auto ToTemplateOrErr = import(T->getTemplateName());
1474  if (!ToTemplateOrErr)
1475    return ToTemplateOrErr.takeError();
1476
1477  SmallVector<TemplateArgument, 2> ToTemplateArgs;
1478  if (Error Err = ImportTemplateArguments(
1479      T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1480    return std::move(Err);
1481
1482  QualType ToCanonType;
1483  if (!QualType(T, 0).isCanonical()) {
1484    QualType FromCanonType
1485      = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1486    if (ExpectedType TyOrErr = import(FromCanonType))
1487      ToCanonType = *TyOrErr;
1488    else
1489      return TyOrErr.takeError();
1490  }
1491  return Importer.getToContext().getTemplateSpecializationType(*ToTemplateOrErr,
1492                                                               ToTemplateArgs,
1493                                                               ToCanonType);
1494}
1495
1496ExpectedType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1497  // Note: the qualifier in an ElaboratedType is optional.
1498  auto ToQualifierOrErr = import(T->getQualifier());
1499  if (!ToQualifierOrErr)
1500    return ToQualifierOrErr.takeError();
1501
1502  ExpectedType ToNamedTypeOrErr = import(T->getNamedType());
1503  if (!ToNamedTypeOrErr)
1504    return ToNamedTypeOrErr.takeError();
1505
1506  Expected<TagDecl *> ToOwnedTagDeclOrErr = import(T->getOwnedTagDecl());
1507  if (!ToOwnedTagDeclOrErr)
1508    return ToOwnedTagDeclOrErr.takeError();
1509
1510  return Importer.getToContext().getElaboratedType(T->getKeyword(),
1511                                                   *ToQualifierOrErr,
1512                                                   *ToNamedTypeOrErr,
1513                                                   *ToOwnedTagDeclOrErr);
1514}
1515
1516ExpectedType
1517ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
1518  ExpectedType ToPatternOrErr = import(T->getPattern());
1519  if (!ToPatternOrErr)
1520    return ToPatternOrErr.takeError();
1521
1522  return Importer.getToContext().getPackExpansionType(*ToPatternOrErr,
1523                                                      T->getNumExpansions(),
1524                                                      /*ExpactPack=*/false);
1525}
1526
1527ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1528    const DependentTemplateSpecializationType *T) {
1529  auto ToQualifierOrErr = import(T->getQualifier());
1530  if (!ToQualifierOrErr)
1531    return ToQualifierOrErr.takeError();
1532
1533  IdentifierInfo *ToName = Importer.Import(T->getIdentifier());
1534
1535  SmallVector<TemplateArgument, 2> ToPack;
1536  ToPack.reserve(T->getNumArgs());
1537  if (Error Err = ImportTemplateArguments(
1538      T->getArgs(), T->getNumArgs(), ToPack))
1539    return std::move(Err);
1540
1541  return Importer.getToContext().getDependentTemplateSpecializationType(
1542      T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1543}
1544
1545ExpectedType
1546ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
1547  auto ToQualifierOrErr = import(T->getQualifier());
1548  if (!ToQualifierOrErr)
1549    return ToQualifierOrErr.takeError();
1550
1551  IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1552
1553  QualType Canon;
1554  if (T != T->getCanonicalTypeInternal().getTypePtr()) {
1555    if (ExpectedType TyOrErr = import(T->getCanonicalTypeInternal()))
1556      Canon = (*TyOrErr).getCanonicalType();
1557    else
1558      return TyOrErr.takeError();
1559  }
1560
1561  return Importer.getToContext().getDependentNameType(T->getKeyword(),
1562                                                      *ToQualifierOrErr,
1563                                                      Name, Canon);
1564}
1565
1566ExpectedType
1567ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1568  Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(T->getDecl());
1569  if (!ToDeclOrErr)
1570    return ToDeclOrErr.takeError();
1571
1572  return Importer.getToContext().getObjCInterfaceType(*ToDeclOrErr);
1573}
1574
1575ExpectedType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1576  ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1577  if (!ToBaseTypeOrErr)
1578    return ToBaseTypeOrErr.takeError();
1579
1580  SmallVector<QualType, 4> TypeArgs;
1581  for (auto TypeArg : T->getTypeArgsAsWritten()) {
1582    if (ExpectedType TyOrErr = import(TypeArg))
1583      TypeArgs.push_back(*TyOrErr);
1584    else
1585      return TyOrErr.takeError();
1586  }
1587
1588  SmallVector<ObjCProtocolDecl *, 4> Protocols;
1589  for (auto *P : T->quals()) {
1590    if (Expected<ObjCProtocolDecl *> ProtocolOrErr = import(P))
1591      Protocols.push_back(*ProtocolOrErr);
1592    else
1593      return ProtocolOrErr.takeError();
1594
1595  }
1596
1597  return Importer.getToContext().getObjCObjectType(*ToBaseTypeOrErr, TypeArgs,
1598                                                   Protocols,
1599                                                   T->isKindOfTypeAsWritten());
1600}
1601
1602ExpectedType
1603ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1604  ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1605  if (!ToPointeeTypeOrErr)
1606    return ToPointeeTypeOrErr.takeError();
1607
1608  return Importer.getToContext().getObjCObjectPointerType(*ToPointeeTypeOrErr);
1609}
1610
1611//----------------------------------------------------------------------------
1612// Import Declarations
1613//----------------------------------------------------------------------------
1614Error ASTNodeImporter::ImportDeclParts(
1615    NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
1616    DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc) {
1617  // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
1618  // example: int struct_in_proto(struct data_t{int a;int b;} *d);
1619  // FIXME: We could support these constructs by importing a different type of
1620  // this parameter and by importing the original type of the parameter only
1621  // after the FunctionDecl is created. See
1622  // VisitFunctionDecl::UsedDifferentProtoType.
1623  DeclContext *OrigDC = D->getDeclContext();
1624  FunctionDecl *FunDecl;
1625  if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1626      FunDecl->hasBody()) {
1627    auto getLeafPointeeType = [](const Type *T) {
1628      while (T->isPointerType() || T->isArrayType()) {
1629        T = T->getPointeeOrArrayElementType();
1630      }
1631      return T;
1632    };
1633    for (const ParmVarDecl *P : FunDecl->parameters()) {
1634      const Type *LeafT =
1635          getLeafPointeeType(P->getType().getCanonicalType().getTypePtr());
1636      auto *RT = dyn_cast<RecordType>(LeafT);
1637      if (RT && RT->getDecl() == D) {
1638        Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1639            << D->getDeclKindName();
1640        return make_error<ImportError>(ImportError::UnsupportedConstruct);
1641      }
1642    }
1643  }
1644
1645  // Import the context of this declaration.
1646  if (Error Err = ImportDeclContext(D, DC, LexicalDC))
1647    return Err;
1648
1649  // Import the name of this declaration.
1650  if (Error Err = importInto(Name, D->getDeclName()))
1651    return Err;
1652
1653  // Import the location of this declaration.
1654  if (Error Err = importInto(Loc, D->getLocation()))
1655    return Err;
1656
1657  ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1658  if (ToD)
1659    if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(D, ToD))
1660      return Err;
1661
1662  return Error::success();
1663}
1664
1665Error ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclarationName &Name,
1666                                       NamedDecl *&ToD, SourceLocation &Loc) {
1667
1668  // Import the name of this declaration.
1669  if (Error Err = importInto(Name, D->getDeclName()))
1670    return Err;
1671
1672  // Import the location of this declaration.
1673  if (Error Err = importInto(Loc, D->getLocation()))
1674    return Err;
1675
1676  ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1677  if (ToD)
1678    if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(D, ToD))
1679      return Err;
1680
1681  return Error::success();
1682}
1683
1684Error ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1685  if (!FromD)
1686    return Error::success();
1687
1688  if (!ToD)
1689    if (Error Err = importInto(ToD, FromD))
1690      return Err;
1691
1692  if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1693    if (RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
1694      if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
1695          !ToRecord->getDefinition()) {
1696        if (Error Err = ImportDefinition(FromRecord, ToRecord))
1697          return Err;
1698      }
1699    }
1700    return Error::success();
1701  }
1702
1703  if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1704    if (EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
1705      if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1706        if (Error Err = ImportDefinition(FromEnum, ToEnum))
1707          return Err;
1708      }
1709    }
1710    return Error::success();
1711  }
1712
1713  return Error::success();
1714}
1715
1716Error
1717ASTNodeImporter::ImportDeclarationNameLoc(
1718    const DeclarationNameInfo &From, DeclarationNameInfo& To) {
1719  // NOTE: To.Name and To.Loc are already imported.
1720  // We only have to import To.LocInfo.
1721  switch (To.getName().getNameKind()) {
1722  case DeclarationName::Identifier:
1723  case DeclarationName::ObjCZeroArgSelector:
1724  case DeclarationName::ObjCOneArgSelector:
1725  case DeclarationName::ObjCMultiArgSelector:
1726  case DeclarationName::CXXUsingDirective:
1727  case DeclarationName::CXXDeductionGuideName:
1728    return Error::success();
1729
1730  case DeclarationName::CXXOperatorName: {
1731    if (auto ToRangeOrErr = import(From.getCXXOperatorNameRange()))
1732      To.setCXXOperatorNameRange(*ToRangeOrErr);
1733    else
1734      return ToRangeOrErr.takeError();
1735    return Error::success();
1736  }
1737  case DeclarationName::CXXLiteralOperatorName: {
1738    if (ExpectedSLoc LocOrErr = import(From.getCXXLiteralOperatorNameLoc()))
1739      To.setCXXLiteralOperatorNameLoc(*LocOrErr);
1740    else
1741      return LocOrErr.takeError();
1742    return Error::success();
1743  }
1744  case DeclarationName::CXXConstructorName:
1745  case DeclarationName::CXXDestructorName:
1746  case DeclarationName::CXXConversionFunctionName: {
1747    if (auto ToTInfoOrErr = import(From.getNamedTypeInfo()))
1748      To.setNamedTypeInfo(*ToTInfoOrErr);
1749    else
1750      return ToTInfoOrErr.takeError();
1751    return Error::success();
1752  }
1753  }
1754  llvm_unreachable("Unknown name kind.");
1755}
1756
1757Error
1758ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1759  if (Importer.isMinimalImport() && !ForceImport) {
1760    auto ToDCOrErr = Importer.ImportContext(FromDC);
1761    return ToDCOrErr.takeError();
1762  }
1763
1764  // We use strict error handling in case of records and enums, but not
1765  // with e.g. namespaces.
1766  //
1767  // FIXME Clients of the ASTImporter should be able to choose an
1768  // appropriate error handling strategy for their needs.  For instance,
1769  // they may not want to mark an entire namespace as erroneous merely
1770  // because there is an ODR error with two typedefs.  As another example,
1771  // the client may allow EnumConstantDecls with same names but with
1772  // different values in two distinct translation units.
1773  bool AccumulateChildErrors = isa<TagDecl>(FromDC);
1774
1775  Error ChildErrors = Error::success();
1776  for (auto *From : FromDC->decls()) {
1777    ExpectedDecl ImportedOrErr = import(From);
1778
1779    // If we are in the process of ImportDefinition(...) for a RecordDecl we
1780    // want to make sure that we are also completing each FieldDecl. There
1781    // are currently cases where this does not happen and this is correctness
1782    // fix since operations such as code generation will expect this to be so.
1783    if (ImportedOrErr) {
1784      FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
1785      Decl *ImportedDecl = *ImportedOrErr;
1786      FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
1787      if (FieldFrom && FieldTo) {
1788        RecordDecl *FromRecordDecl = nullptr;
1789        RecordDecl *ToRecordDecl = nullptr;
1790        // If we have a field that is an ArrayType we need to check if the array
1791        // element is a RecordDecl and if so we need to import the defintion.
1792        if (FieldFrom->getType()->isArrayType()) {
1793          // getBaseElementTypeUnsafe(...) handles multi-dimensonal arrays for us.
1794          FromRecordDecl = FieldFrom->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
1795          ToRecordDecl = FieldTo->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
1796        }
1797
1798        if (!FromRecordDecl || !ToRecordDecl) {
1799          const RecordType *RecordFrom =
1800              FieldFrom->getType()->getAs<RecordType>();
1801          const RecordType *RecordTo = FieldTo->getType()->getAs<RecordType>();
1802
1803          if (RecordFrom && RecordTo) {
1804            FromRecordDecl = RecordFrom->getDecl();
1805            ToRecordDecl = RecordTo->getDecl();
1806          }
1807        }
1808
1809        if (FromRecordDecl && ToRecordDecl) {
1810          if (FromRecordDecl->isCompleteDefinition() &&
1811              !ToRecordDecl->isCompleteDefinition()) {
1812            Error Err = ImportDefinition(FromRecordDecl, ToRecordDecl);
1813
1814            if (Err && AccumulateChildErrors)
1815              ChildErrors =  joinErrors(std::move(ChildErrors), std::move(Err));
1816            else
1817              consumeError(std::move(Err));
1818          }
1819        }
1820      }
1821    } else {
1822      if (AccumulateChildErrors)
1823        ChildErrors =
1824            joinErrors(std::move(ChildErrors), ImportedOrErr.takeError());
1825      else
1826        consumeError(ImportedOrErr.takeError());
1827    }
1828  }
1829
1830  // We reorder declarations in RecordDecls because they may have another order
1831  // in the "to" context than they have in the "from" context. This may happen
1832  // e.g when we import a class like this:
1833  //    struct declToImport {
1834  //        int a = c + b;
1835  //        int b = 1;
1836  //        int c = 2;
1837  //    };
1838  // During the import of `a` we import first the dependencies in sequence,
1839  // thus the order would be `c`, `b`, `a`. We will get the normal order by
1840  // first removing the already imported members and then adding them in the
1841  // order as they apper in the "from" context.
1842  //
1843  // Keeping field order is vital because it determines structure layout.
1844  //
1845  // Here and below, we cannot call field_begin() method and its callers on
1846  // ToDC if it has an external storage. Calling field_begin() will
1847  // automatically load all the fields by calling
1848  // LoadFieldsFromExternalStorage(). LoadFieldsFromExternalStorage() would
1849  // call ASTImporter::Import(). This is because the ExternalASTSource
1850  // interface in LLDB is implemented by the means of the ASTImporter. However,
1851  // calling an import at this point would result in an uncontrolled import, we
1852  // must avoid that.
1853  const auto *FromRD = dyn_cast<RecordDecl>(FromDC);
1854  if (!FromRD)
1855    return ChildErrors;
1856
1857  auto ToDCOrErr = Importer.ImportContext(FromDC);
1858  if (!ToDCOrErr) {
1859    consumeError(std::move(ChildErrors));
1860    return ToDCOrErr.takeError();
1861  }
1862
1863  DeclContext *ToDC = *ToDCOrErr;
1864  // Remove all declarations, which may be in wrong order in the
1865  // lexical DeclContext and then add them in the proper order.
1866  for (auto *D : FromRD->decls()) {
1867    if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FriendDecl>(D)) {
1868      assert(D && "DC contains a null decl");
1869      Decl *ToD = Importer.GetAlreadyImportedOrNull(D);
1870      // Remove only the decls which we successfully imported.
1871      if (ToD) {
1872        assert(ToDC == ToD->getLexicalDeclContext() && ToDC->containsDecl(ToD));
1873        // Remove the decl from its wrong place in the linked list.
1874        ToDC->removeDecl(ToD);
1875        // Add the decl to the end of the linked list.
1876        // This time it will be at the proper place because the enclosing for
1877        // loop iterates in the original (good) order of the decls.
1878        ToDC->addDeclInternal(ToD);
1879      }
1880    }
1881  }
1882
1883  return ChildErrors;
1884}
1885
1886Error ASTNodeImporter::ImportDeclContext(
1887    Decl *FromD, DeclContext *&ToDC, DeclContext *&ToLexicalDC) {
1888  auto ToDCOrErr = Importer.ImportContext(FromD->getDeclContext());
1889  if (!ToDCOrErr)
1890    return ToDCOrErr.takeError();
1891  ToDC = *ToDCOrErr;
1892
1893  if (FromD->getDeclContext() != FromD->getLexicalDeclContext()) {
1894    auto ToLexicalDCOrErr = Importer.ImportContext(
1895        FromD->getLexicalDeclContext());
1896    if (!ToLexicalDCOrErr)
1897      return ToLexicalDCOrErr.takeError();
1898    ToLexicalDC = *ToLexicalDCOrErr;
1899  } else
1900    ToLexicalDC = ToDC;
1901
1902  return Error::success();
1903}
1904
1905Error ASTNodeImporter::ImportImplicitMethods(
1906    const CXXRecordDecl *From, CXXRecordDecl *To) {
1907  assert(From->isCompleteDefinition() && To->getDefinition() == To &&
1908      "Import implicit methods to or from non-definition");
1909
1910  for (CXXMethodDecl *FromM : From->methods())
1911    if (FromM->isImplicit()) {
1912      Expected<CXXMethodDecl *> ToMOrErr = import(FromM);
1913      if (!ToMOrErr)
1914        return ToMOrErr.takeError();
1915    }
1916
1917  return Error::success();
1918}
1919
1920static Error setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
1921                                       ASTImporter &Importer) {
1922  if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
1923    if (ExpectedDecl ToTypedefOrErr = Importer.Import(FromTypedef))
1924      To->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(*ToTypedefOrErr));
1925    else
1926      return ToTypedefOrErr.takeError();
1927  }
1928  return Error::success();
1929}
1930
1931Error ASTNodeImporter::ImportDefinition(
1932    RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind) {
1933  auto DefinitionCompleter = [To]() {
1934    // There are cases in LLDB when we first import a class without its
1935    // members. The class will have DefinitionData, but no members. Then,
1936    // importDefinition is called from LLDB, which tries to get the members, so
1937    // when we get here, the class already has the DefinitionData set, so we
1938    // must unset the CompleteDefinition here to be able to complete again the
1939    // definition.
1940    To->setCompleteDefinition(false);
1941    To->completeDefinition();
1942  };
1943
1944  if (To->getDefinition() || To->isBeingDefined()) {
1945    if (Kind == IDK_Everything ||
1946        // In case of lambdas, the class already has a definition ptr set, but
1947        // the contained decls are not imported yet. Also, isBeingDefined was
1948        // set in CXXRecordDecl::CreateLambda.  We must import the contained
1949        // decls here and finish the definition.
1950        (To->isLambda() && shouldForceImportDeclContext(Kind))) {
1951      if (To->isLambda()) {
1952        auto *FromCXXRD = cast<CXXRecordDecl>(From);
1953        SmallVector<LambdaCapture, 8> ToCaptures;
1954        ToCaptures.reserve(FromCXXRD->capture_size());
1955        for (const auto &FromCapture : FromCXXRD->captures()) {
1956          if (auto ToCaptureOrErr = import(FromCapture))
1957            ToCaptures.push_back(*ToCaptureOrErr);
1958          else
1959            return ToCaptureOrErr.takeError();
1960        }
1961        cast<CXXRecordDecl>(To)->setCaptures(Importer.getToContext(),
1962                                             ToCaptures);
1963      }
1964
1965      Error Result = ImportDeclContext(From, /*ForceImport=*/true);
1966      // Finish the definition of the lambda, set isBeingDefined to false.
1967      if (To->isLambda())
1968        DefinitionCompleter();
1969      return Result;
1970    }
1971
1972    return Error::success();
1973  }
1974
1975  To->startDefinition();
1976  // Complete the definition even if error is returned.
1977  // The RecordDecl may be already part of the AST so it is better to
1978  // have it in complete state even if something is wrong with it.
1979  auto DefinitionCompleterScopeExit =
1980      llvm::make_scope_exit(DefinitionCompleter);
1981
1982  if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
1983    return Err;
1984
1985  // Add base classes.
1986  auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
1987  auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
1988  if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
1989
1990    struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1991    struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
1992
1993    #define FIELD(Name, Width, Merge) \
1994    ToData.Name = FromData.Name;
1995    #include "clang/AST/CXXRecordDeclDefinitionBits.def"
1996
1997    // Copy over the data stored in RecordDeclBits
1998    ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
1999
2000    SmallVector<CXXBaseSpecifier *, 4> Bases;
2001    for (const auto &Base1 : FromCXX->bases()) {
2002      ExpectedType TyOrErr = import(Base1.getType());
2003      if (!TyOrErr)
2004        return TyOrErr.takeError();
2005
2006      SourceLocation EllipsisLoc;
2007      if (Base1.isPackExpansion()) {
2008        if (ExpectedSLoc LocOrErr = import(Base1.getEllipsisLoc()))
2009          EllipsisLoc = *LocOrErr;
2010        else
2011          return LocOrErr.takeError();
2012      }
2013
2014      // Ensure that we have a definition for the base.
2015      if (Error Err =
2016          ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()))
2017        return Err;
2018
2019      auto RangeOrErr = import(Base1.getSourceRange());
2020      if (!RangeOrErr)
2021        return RangeOrErr.takeError();
2022
2023      auto TSIOrErr = import(Base1.getTypeSourceInfo());
2024      if (!TSIOrErr)
2025        return TSIOrErr.takeError();
2026
2027      Bases.push_back(
2028          new (Importer.getToContext()) CXXBaseSpecifier(
2029              *RangeOrErr,
2030              Base1.isVirtual(),
2031              Base1.isBaseOfClass(),
2032              Base1.getAccessSpecifierAsWritten(),
2033              *TSIOrErr,
2034              EllipsisLoc));
2035    }
2036    if (!Bases.empty())
2037      ToCXX->setBases(Bases.data(), Bases.size());
2038  }
2039
2040  if (shouldForceImportDeclContext(Kind))
2041    if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
2042      return Err;
2043
2044  return Error::success();
2045}
2046
2047Error ASTNodeImporter::ImportInitializer(VarDecl *From, VarDecl *To) {
2048  if (To->getAnyInitializer())
2049    return Error::success();
2050
2051  Expr *FromInit = From->getInit();
2052  if (!FromInit)
2053    return Error::success();
2054
2055  ExpectedExpr ToInitOrErr = import(FromInit);
2056  if (!ToInitOrErr)
2057    return ToInitOrErr.takeError();
2058
2059  To->setInit(*ToInitOrErr);
2060  if (EvaluatedStmt *FromEval = From->getEvaluatedStmt()) {
2061    EvaluatedStmt *ToEval = To->ensureEvaluatedStmt();
2062    ToEval->HasConstantInitialization = FromEval->HasConstantInitialization;
2063    ToEval->HasConstantDestruction = FromEval->HasConstantDestruction;
2064    // FIXME: Also import the initializer value.
2065  }
2066
2067  // FIXME: Other bits to merge?
2068  return Error::success();
2069}
2070
2071Error ASTNodeImporter::ImportDefinition(
2072    EnumDecl *From, EnumDecl *To, ImportDefinitionKind Kind) {
2073  if (To->getDefinition() || To->isBeingDefined()) {
2074    if (Kind == IDK_Everything)
2075      return ImportDeclContext(From, /*ForceImport=*/true);
2076    return Error::success();
2077  }
2078
2079  To->startDefinition();
2080
2081  if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
2082    return Err;
2083
2084  ExpectedType ToTypeOrErr =
2085      import(Importer.getFromContext().getTypeDeclType(From));
2086  if (!ToTypeOrErr)
2087    return ToTypeOrErr.takeError();
2088
2089  ExpectedType ToPromotionTypeOrErr = import(From->getPromotionType());
2090  if (!ToPromotionTypeOrErr)
2091    return ToPromotionTypeOrErr.takeError();
2092
2093  if (shouldForceImportDeclContext(Kind))
2094    if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
2095      return Err;
2096
2097  // FIXME: we might need to merge the number of positive or negative bits
2098  // if the enumerator lists don't match.
2099  To->completeDefinition(*ToTypeOrErr, *ToPromotionTypeOrErr,
2100                         From->getNumPositiveBits(),
2101                         From->getNumNegativeBits());
2102  return Error::success();
2103}
2104
2105Error ASTNodeImporter::ImportTemplateArguments(
2106    const TemplateArgument *FromArgs, unsigned NumFromArgs,
2107    SmallVectorImpl<TemplateArgument> &ToArgs) {
2108  for (unsigned I = 0; I != NumFromArgs; ++I) {
2109    if (auto ToOrErr = import(FromArgs[I]))
2110      ToArgs.push_back(*ToOrErr);
2111    else
2112      return ToOrErr.takeError();
2113  }
2114
2115  return Error::success();
2116}
2117
2118// FIXME: Do not forget to remove this and use only 'import'.
2119Expected<TemplateArgument>
2120ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2121  return import(From);
2122}
2123
2124template <typename InContainerTy>
2125Error ASTNodeImporter::ImportTemplateArgumentListInfo(
2126    const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
2127  for (const auto &FromLoc : Container) {
2128    if (auto ToLocOrErr = import(FromLoc))
2129      ToTAInfo.addArgument(*ToLocOrErr);
2130    else
2131      return ToLocOrErr.takeError();
2132  }
2133  return Error::success();
2134}
2135
2136static StructuralEquivalenceKind
2137getStructuralEquivalenceKind(const ASTImporter &Importer) {
2138  return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
2139                                    : StructuralEquivalenceKind::Default;
2140}
2141
2142bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) {
2143  StructuralEquivalenceContext Ctx(
2144      Importer.getFromContext(), Importer.getToContext(),
2145      Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2146      false, Complain);
2147  return Ctx.IsEquivalent(From, To);
2148}
2149
2150bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2151                                        RecordDecl *ToRecord, bool Complain) {
2152  // Eliminate a potential failure point where we attempt to re-import
2153  // something we're trying to import while completing ToRecord.
2154  Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2155  if (ToOrigin) {
2156    auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2157    if (ToOriginRecord)
2158      ToRecord = ToOriginRecord;
2159  }
2160
2161  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2162                                   ToRecord->getASTContext(),
2163                                   Importer.getNonEquivalentDecls(),
2164                                   getStructuralEquivalenceKind(Importer),
2165                                   false, Complain);
2166  return Ctx.IsEquivalent(FromRecord, ToRecord);
2167}
2168
2169bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2170                                        bool Complain) {
2171  StructuralEquivalenceContext Ctx(
2172      Importer.getFromContext(), Importer.getToContext(),
2173      Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2174      false, Complain);
2175  return Ctx.IsEquivalent(FromVar, ToVar);
2176}
2177
2178bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2179  // Eliminate a potential failure point where we attempt to re-import
2180  // something we're trying to import while completing ToEnum.
2181  if (Decl *ToOrigin = Importer.GetOriginalDecl(ToEnum))
2182    if (auto *ToOriginEnum = dyn_cast<EnumDecl>(ToOrigin))
2183        ToEnum = ToOriginEnum;
2184
2185  StructuralEquivalenceContext Ctx(
2186      Importer.getFromContext(), Importer.getToContext(),
2187      Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
2188  return Ctx.IsEquivalent(FromEnum, ToEnum);
2189}
2190
2191bool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From,
2192                                        FunctionTemplateDecl *To) {
2193  StructuralEquivalenceContext Ctx(
2194      Importer.getFromContext(), Importer.getToContext(),
2195      Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2196      false, false);
2197  return Ctx.IsEquivalent(From, To);
2198}
2199
2200bool ASTNodeImporter::IsStructuralMatch(FunctionDecl *From, FunctionDecl *To) {
2201  StructuralEquivalenceContext Ctx(
2202      Importer.getFromContext(), Importer.getToContext(),
2203      Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2204      false, false);
2205  return Ctx.IsEquivalent(From, To);
2206}
2207
2208bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2209                                        EnumConstantDecl *ToEC) {
2210  const llvm::APSInt &FromVal = FromEC->getInitVal();
2211  const llvm::APSInt &ToVal = ToEC->getInitVal();
2212
2213  return FromVal.isSigned() == ToVal.isSigned() &&
2214         FromVal.getBitWidth() == ToVal.getBitWidth() &&
2215         FromVal == ToVal;
2216}
2217
2218bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2219                                        ClassTemplateDecl *To) {
2220  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2221                                   Importer.getToContext(),
2222                                   Importer.getNonEquivalentDecls(),
2223                                   getStructuralEquivalenceKind(Importer));
2224  return Ctx.IsEquivalent(From, To);
2225}
2226
2227bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2228                                        VarTemplateDecl *To) {
2229  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2230                                   Importer.getToContext(),
2231                                   Importer.getNonEquivalentDecls(),
2232                                   getStructuralEquivalenceKind(Importer));
2233  return Ctx.IsEquivalent(From, To);
2234}
2235
2236ExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) {
2237  Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2238    << D->getDeclKindName();
2239  return make_error<ImportError>(ImportError::UnsupportedConstruct);
2240}
2241
2242ExpectedDecl ASTNodeImporter::VisitImportDecl(ImportDecl *D) {
2243  Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2244      << D->getDeclKindName();
2245  return make_error<ImportError>(ImportError::UnsupportedConstruct);
2246}
2247
2248ExpectedDecl ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
2249  // Import the context of this declaration.
2250  DeclContext *DC, *LexicalDC;
2251  if (Error Err = ImportDeclContext(D, DC, LexicalDC))
2252    return std::move(Err);
2253
2254  // Import the location of this declaration.
2255  ExpectedSLoc LocOrErr = import(D->getLocation());
2256  if (!LocOrErr)
2257    return LocOrErr.takeError();
2258
2259  EmptyDecl *ToD;
2260  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, *LocOrErr))
2261    return ToD;
2262
2263  ToD->setLexicalDeclContext(LexicalDC);
2264  LexicalDC->addDeclInternal(ToD);
2265  return ToD;
2266}
2267
2268ExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2269  TranslationUnitDecl *ToD =
2270    Importer.getToContext().getTranslationUnitDecl();
2271
2272  Importer.MapImported(D, ToD);
2273
2274  return ToD;
2275}
2276
2277ExpectedDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
2278  ExpectedSLoc LocOrErr = import(D->getLocation());
2279  if (!LocOrErr)
2280    return LocOrErr.takeError();
2281  auto ColonLocOrErr = import(D->getColonLoc());
2282  if (!ColonLocOrErr)
2283    return ColonLocOrErr.takeError();
2284
2285  // Import the context of this declaration.
2286  auto DCOrErr = Importer.ImportContext(D->getDeclContext());
2287  if (!DCOrErr)
2288    return DCOrErr.takeError();
2289  DeclContext *DC = *DCOrErr;
2290
2291  AccessSpecDecl *ToD;
2292  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(),
2293                              DC, *LocOrErr, *ColonLocOrErr))
2294    return ToD;
2295
2296  // Lexical DeclContext and Semantic DeclContext
2297  // is always the same for the accessSpec.
2298  ToD->setLexicalDeclContext(DC);
2299  DC->addDeclInternal(ToD);
2300
2301  return ToD;
2302}
2303
2304ExpectedDecl ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2305  auto DCOrErr = Importer.ImportContext(D->getDeclContext());
2306  if (!DCOrErr)
2307    return DCOrErr.takeError();
2308  DeclContext *DC = *DCOrErr;
2309  DeclContext *LexicalDC = DC;
2310
2311  Error Err = Error::success();
2312  auto ToLocation = importChecked(Err, D->getLocation());
2313  auto ToRParenLoc = importChecked(Err, D->getRParenLoc());
2314  auto ToAssertExpr = importChecked(Err, D->getAssertExpr());
2315  auto ToMessage = importChecked(Err, D->getMessage());
2316  if (Err)
2317    return std::move(Err);
2318
2319  StaticAssertDecl *ToD;
2320  if (GetImportedOrCreateDecl(
2321      ToD, D, Importer.getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2322      ToRParenLoc, D->isFailed()))
2323    return ToD;
2324
2325  ToD->setLexicalDeclContext(LexicalDC);
2326  LexicalDC->addDeclInternal(ToD);
2327  return ToD;
2328}
2329
2330ExpectedDecl ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2331  // Import the major distinguishing characteristics of this namespace.
2332  DeclContext *DC, *LexicalDC;
2333  DeclarationName Name;
2334  SourceLocation Loc;
2335  NamedDecl *ToD;
2336  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2337    return std::move(Err);
2338  if (ToD)
2339    return ToD;
2340
2341  NamespaceDecl *MergeWithNamespace = nullptr;
2342  if (!Name) {
2343    // This is an anonymous namespace. Adopt an existing anonymous
2344    // namespace if we can.
2345    // FIXME: Not testable.
2346    if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2347      MergeWithNamespace = TU->getAnonymousNamespace();
2348    else
2349      MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2350  } else {
2351    SmallVector<NamedDecl *, 4> ConflictingDecls;
2352    auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2353    for (auto *FoundDecl : FoundDecls) {
2354      if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace))
2355        continue;
2356
2357      if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2358        MergeWithNamespace = FoundNS;
2359        ConflictingDecls.clear();
2360        break;
2361      }
2362
2363      ConflictingDecls.push_back(FoundDecl);
2364    }
2365
2366    if (!ConflictingDecls.empty()) {
2367      ExpectedName NameOrErr = Importer.HandleNameConflict(
2368          Name, DC, Decl::IDNS_Namespace, ConflictingDecls.data(),
2369          ConflictingDecls.size());
2370      if (NameOrErr)
2371        Name = NameOrErr.get();
2372      else
2373        return NameOrErr.takeError();
2374    }
2375  }
2376
2377  ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2378  if (!BeginLocOrErr)
2379    return BeginLocOrErr.takeError();
2380  ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
2381  if (!RBraceLocOrErr)
2382    return RBraceLocOrErr.takeError();
2383
2384  // Create the "to" namespace, if needed.
2385  NamespaceDecl *ToNamespace = MergeWithNamespace;
2386  if (!ToNamespace) {
2387    if (GetImportedOrCreateDecl(
2388            ToNamespace, D, Importer.getToContext(), DC, D->isInline(),
2389            *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2390            /*PrevDecl=*/nullptr))
2391      return ToNamespace;
2392    ToNamespace->setRBraceLoc(*RBraceLocOrErr);
2393    ToNamespace->setLexicalDeclContext(LexicalDC);
2394    LexicalDC->addDeclInternal(ToNamespace);
2395
2396    // If this is an anonymous namespace, register it as the anonymous
2397    // namespace within its context.
2398    if (!Name) {
2399      if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2400        TU->setAnonymousNamespace(ToNamespace);
2401      else
2402        cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2403    }
2404  }
2405  Importer.MapImported(D, ToNamespace);
2406
2407  if (Error Err = ImportDeclContext(D))
2408    return std::move(Err);
2409
2410  return ToNamespace;
2411}
2412
2413ExpectedDecl ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
2414  // Import the major distinguishing characteristics of this namespace.
2415  DeclContext *DC, *LexicalDC;
2416  DeclarationName Name;
2417  SourceLocation Loc;
2418  NamedDecl *LookupD;
2419  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
2420    return std::move(Err);
2421  if (LookupD)
2422    return LookupD;
2423
2424  // NOTE: No conflict resolution is done for namespace aliases now.
2425
2426  Error Err = Error::success();
2427  auto ToNamespaceLoc = importChecked(Err, D->getNamespaceLoc());
2428  auto ToAliasLoc = importChecked(Err, D->getAliasLoc());
2429  auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
2430  auto ToTargetNameLoc = importChecked(Err, D->getTargetNameLoc());
2431  auto ToNamespace = importChecked(Err, D->getNamespace());
2432  if (Err)
2433    return std::move(Err);
2434
2435  IdentifierInfo *ToIdentifier = Importer.Import(D->getIdentifier());
2436
2437  NamespaceAliasDecl *ToD;
2438  if (GetImportedOrCreateDecl(
2439      ToD, D, Importer.getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2440      ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2441    return ToD;
2442
2443  ToD->setLexicalDeclContext(LexicalDC);
2444  LexicalDC->addDeclInternal(ToD);
2445
2446  return ToD;
2447}
2448
2449ExpectedDecl
2450ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2451  // Import the major distinguishing characteristics of this typedef.
2452  DeclarationName Name;
2453  SourceLocation Loc;
2454  NamedDecl *ToD;
2455  // Do not import the DeclContext, we will import it once the TypedefNameDecl
2456  // is created.
2457  if (Error Err = ImportDeclParts(D, Name, ToD, Loc))
2458    return std::move(Err);
2459  if (ToD)
2460    return ToD;
2461
2462  DeclContext *DC = cast_or_null<DeclContext>(
2463      Importer.GetAlreadyImportedOrNull(cast<Decl>(D->getDeclContext())));
2464  DeclContext *LexicalDC =
2465      cast_or_null<DeclContext>(Importer.GetAlreadyImportedOrNull(
2466          cast<Decl>(D->getLexicalDeclContext())));
2467
2468  // If this typedef is not in block scope, determine whether we've
2469  // seen a typedef with the same name (that we can merge with) or any
2470  // other entity by that name (which name lookup could conflict with).
2471  // Note: Repeated typedefs are not valid in C99:
2472  // 'typedef int T; typedef int T;' is invalid
2473  // We do not care about this now.
2474  if (DC && !DC->isFunctionOrMethod()) {
2475    SmallVector<NamedDecl *, 4> ConflictingDecls;
2476    unsigned IDNS = Decl::IDNS_Ordinary;
2477    auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2478    for (auto *FoundDecl : FoundDecls) {
2479      if (!FoundDecl->isInIdentifierNamespace(IDNS))
2480        continue;
2481      if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2482        if (!hasSameVisibilityContextAndLinkage(FoundTypedef, D))
2483          continue;
2484
2485        QualType FromUT = D->getUnderlyingType();
2486        QualType FoundUT = FoundTypedef->getUnderlyingType();
2487        if (Importer.IsStructurallyEquivalent(FromUT, FoundUT)) {
2488          // If the "From" context has a complete underlying type but we
2489          // already have a complete underlying type then return with that.
2490          if (!FromUT->isIncompleteType() && !FoundUT->isIncompleteType())
2491            return Importer.MapImported(D, FoundTypedef);
2492          // FIXME Handle redecl chain. When you do that make consistent changes
2493          // in ASTImporterLookupTable too.
2494        } else {
2495          ConflictingDecls.push_back(FoundDecl);
2496        }
2497      }
2498    }
2499
2500    if (!ConflictingDecls.empty()) {
2501      ExpectedName NameOrErr = Importer.HandleNameConflict(
2502          Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2503      if (NameOrErr)
2504        Name = NameOrErr.get();
2505      else
2506        return NameOrErr.takeError();
2507    }
2508  }
2509
2510  Error Err = Error::success();
2511  auto ToUnderlyingType = importChecked(Err, D->getUnderlyingType());
2512  auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
2513  auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
2514  if (Err)
2515    return std::move(Err);
2516
2517  // Create the new typedef node.
2518  // FIXME: ToUnderlyingType is not used.
2519  (void)ToUnderlyingType;
2520  TypedefNameDecl *ToTypedef;
2521  if (IsAlias) {
2522    if (GetImportedOrCreateDecl<TypeAliasDecl>(
2523        ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
2524        Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2525      return ToTypedef;
2526  } else if (GetImportedOrCreateDecl<TypedefDecl>(
2527      ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
2528      Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2529    return ToTypedef;
2530
2531  // Import the DeclContext and set it to the Typedef.
2532  if ((Err = ImportDeclContext(D, DC, LexicalDC)))
2533    return std::move(Err);
2534  ToTypedef->setDeclContext(DC);
2535  ToTypedef->setLexicalDeclContext(LexicalDC);
2536  // Add to the lookupTable because we could not do that in MapImported.
2537  Importer.AddToLookupTable(ToTypedef);
2538
2539  ToTypedef->setAccess(D->getAccess());
2540
2541  // Templated declarations should not appear in DeclContext.
2542  TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr;
2543  if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
2544    LexicalDC->addDeclInternal(ToTypedef);
2545
2546  return ToTypedef;
2547}
2548
2549ExpectedDecl ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2550  return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2551}
2552
2553ExpectedDecl ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2554  return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2555}
2556
2557ExpectedDecl
2558ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2559  // Import the major distinguishing characteristics of this typedef.
2560  DeclContext *DC, *LexicalDC;
2561  DeclarationName Name;
2562  SourceLocation Loc;
2563  NamedDecl *FoundD;
2564  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
2565    return std::move(Err);
2566  if (FoundD)
2567    return FoundD;
2568
2569  // If this typedef is not in block scope, determine whether we've
2570  // seen a typedef with the same name (that we can merge with) or any
2571  // other entity by that name (which name lookup could conflict with).
2572  if (!DC->isFunctionOrMethod()) {
2573    SmallVector<NamedDecl *, 4> ConflictingDecls;
2574    unsigned IDNS = Decl::IDNS_Ordinary;
2575    auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2576    for (auto *FoundDecl : FoundDecls) {
2577      if (!FoundDecl->isInIdentifierNamespace(IDNS))
2578        continue;
2579      if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
2580        return Importer.MapImported(D, FoundAlias);
2581      ConflictingDecls.push_back(FoundDecl);
2582    }
2583
2584    if (!ConflictingDecls.empty()) {
2585      ExpectedName NameOrErr = Importer.HandleNameConflict(
2586          Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2587      if (NameOrErr)
2588        Name = NameOrErr.get();
2589      else
2590        return NameOrErr.takeError();
2591    }
2592  }
2593
2594  Error Err = Error::success();
2595  auto ToTemplateParameters = importChecked(Err, D->getTemplateParameters());
2596  auto ToTemplatedDecl = importChecked(Err, D->getTemplatedDecl());
2597  if (Err)
2598    return std::move(Err);
2599
2600  TypeAliasTemplateDecl *ToAlias;
2601  if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc,
2602                              Name, ToTemplateParameters, ToTemplatedDecl))
2603    return ToAlias;
2604
2605  ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2606
2607  ToAlias->setAccess(D->getAccess());
2608  ToAlias->setLexicalDeclContext(LexicalDC);
2609  LexicalDC->addDeclInternal(ToAlias);
2610  return ToAlias;
2611}
2612
2613ExpectedDecl ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2614  // Import the major distinguishing characteristics of this label.
2615  DeclContext *DC, *LexicalDC;
2616  DeclarationName Name;
2617  SourceLocation Loc;
2618  NamedDecl *ToD;
2619  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2620    return std::move(Err);
2621  if (ToD)
2622    return ToD;
2623
2624  assert(LexicalDC->isFunctionOrMethod());
2625
2626  LabelDecl *ToLabel;
2627  if (D->isGnuLocal()) {
2628    ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2629    if (!BeginLocOrErr)
2630      return BeginLocOrErr.takeError();
2631    if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc,
2632                                Name.getAsIdentifierInfo(), *BeginLocOrErr))
2633      return ToLabel;
2634
2635  } else {
2636    if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc,
2637                                Name.getAsIdentifierInfo()))
2638      return ToLabel;
2639
2640  }
2641
2642  Expected<LabelStmt *> ToStmtOrErr = import(D->getStmt());
2643  if (!ToStmtOrErr)
2644    return ToStmtOrErr.takeError();
2645
2646  ToLabel->setStmt(*ToStmtOrErr);
2647  ToLabel->setLexicalDeclContext(LexicalDC);
2648  LexicalDC->addDeclInternal(ToLabel);
2649  return ToLabel;
2650}
2651
2652ExpectedDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2653  // Import the major distinguishing characteristics of this enum.
2654  DeclContext *DC, *LexicalDC;
2655  DeclarationName Name;
2656  SourceLocation Loc;
2657  NamedDecl *ToD;
2658  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2659    return std::move(Err);
2660  if (ToD)
2661    return ToD;
2662
2663  // Figure out what enum name we're looking for.
2664  unsigned IDNS = Decl::IDNS_Tag;
2665  DeclarationName SearchName = Name;
2666  if (!SearchName && D->getTypedefNameForAnonDecl()) {
2667    if (Error Err = importInto(
2668        SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
2669      return std::move(Err);
2670    IDNS = Decl::IDNS_Ordinary;
2671  } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2672    IDNS |= Decl::IDNS_Ordinary;
2673
2674  // We may already have an enum of the same name; try to find and match it.
2675  EnumDecl *PrevDecl = nullptr;
2676  if (!DC->isFunctionOrMethod() && SearchName) {
2677    SmallVector<NamedDecl *, 4> ConflictingDecls;
2678    auto FoundDecls =
2679        Importer.findDeclsInToCtx(DC, SearchName);
2680    for (auto *FoundDecl : FoundDecls) {
2681      if (!FoundDecl->isInIdentifierNamespace(IDNS))
2682        continue;
2683
2684      if (auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2685        if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2686          FoundDecl = Tag->getDecl();
2687      }
2688
2689      if (auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
2690        if (!hasSameVisibilityContextAndLinkage(FoundEnum, D))
2691          continue;
2692        if (IsStructuralMatch(D, FoundEnum)) {
2693          EnumDecl *FoundDef = FoundEnum->getDefinition();
2694          if (D->isThisDeclarationADefinition() && FoundDef)
2695            return Importer.MapImported(D, FoundDef);
2696          PrevDecl = FoundEnum->getMostRecentDecl();
2697          break;
2698        }
2699        ConflictingDecls.push_back(FoundDecl);
2700      }
2701    }
2702
2703    if (!ConflictingDecls.empty()) {
2704      ExpectedName NameOrErr = Importer.HandleNameConflict(
2705          SearchName, DC, IDNS, ConflictingDecls.data(),
2706          ConflictingDecls.size());
2707      if (NameOrErr)
2708        Name = NameOrErr.get();
2709      else
2710        return NameOrErr.takeError();
2711    }
2712  }
2713
2714  Error Err = Error::success();
2715  auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
2716  auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
2717  auto ToIntegerType = importChecked(Err, D->getIntegerType());
2718  auto ToBraceRange = importChecked(Err, D->getBraceRange());
2719  if (Err)
2720    return std::move(Err);
2721
2722  // Create the enum declaration.
2723  EnumDecl *D2;
2724  if (GetImportedOrCreateDecl(
2725          D2, D, Importer.getToContext(), DC, ToBeginLoc,
2726          Loc, Name.getAsIdentifierInfo(), PrevDecl, D->isScoped(),
2727          D->isScopedUsingClassTag(), D->isFixed()))
2728    return D2;
2729
2730  D2->setQualifierInfo(ToQualifierLoc);
2731  D2->setIntegerType(ToIntegerType);
2732  D2->setBraceRange(ToBraceRange);
2733  D2->setAccess(D->getAccess());
2734  D2->setLexicalDeclContext(LexicalDC);
2735  addDeclToContexts(D, D2);
2736
2737  if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
2738    TemplateSpecializationKind SK = MemberInfo->getTemplateSpecializationKind();
2739    EnumDecl *FromInst = D->getInstantiatedFromMemberEnum();
2740    if (Expected<EnumDecl *> ToInstOrErr = import(FromInst))
2741      D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
2742    else
2743      return ToInstOrErr.takeError();
2744    if (ExpectedSLoc POIOrErr = import(MemberInfo->getPointOfInstantiation()))
2745      D2->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
2746    else
2747      return POIOrErr.takeError();
2748  }
2749
2750  // Import the definition
2751  if (D->isCompleteDefinition())
2752    if (Error Err = ImportDefinition(D, D2))
2753      return std::move(Err);
2754
2755  return D2;
2756}
2757
2758ExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2759  bool IsFriendTemplate = false;
2760  if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2761    IsFriendTemplate =
2762        DCXX->getDescribedClassTemplate() &&
2763        DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
2764            Decl::FOK_None;
2765  }
2766
2767  // Import the major distinguishing characteristics of this record.
2768  DeclContext *DC = nullptr, *LexicalDC = nullptr;
2769  DeclarationName Name;
2770  SourceLocation Loc;
2771  NamedDecl *ToD = nullptr;
2772  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2773    return std::move(Err);
2774  if (ToD)
2775    return ToD;
2776
2777  // Figure out what structure name we're looking for.
2778  unsigned IDNS = Decl::IDNS_Tag;
2779  DeclarationName SearchName = Name;
2780  if (!SearchName && D->getTypedefNameForAnonDecl()) {
2781    if (Error Err = importInto(
2782        SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
2783      return std::move(Err);
2784    IDNS = Decl::IDNS_Ordinary;
2785  } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2786    IDNS |= Decl::IDNS_Ordinary | Decl::IDNS_TagFriend;
2787
2788  // We may already have a record of the same name; try to find and match it.
2789  RecordDecl *PrevDecl = nullptr;
2790  if (!DC->isFunctionOrMethod() && !D->isLambda()) {
2791    SmallVector<NamedDecl *, 4> ConflictingDecls;
2792    auto FoundDecls =
2793        Importer.findDeclsInToCtx(DC, SearchName);
2794    if (!FoundDecls.empty()) {
2795      // We're going to have to compare D against potentially conflicting Decls,
2796      // so complete it.
2797      if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
2798        D->getASTContext().getExternalSource()->CompleteType(D);
2799    }
2800
2801    for (auto *FoundDecl : FoundDecls) {
2802      if (!FoundDecl->isInIdentifierNamespace(IDNS))
2803        continue;
2804
2805      Decl *Found = FoundDecl;
2806      if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2807        if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2808          Found = Tag->getDecl();
2809      }
2810
2811      if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2812        // Do not emit false positive diagnostic in case of unnamed
2813        // struct/union and in case of anonymous structs.  Would be false
2814        // because there may be several anonymous/unnamed structs in a class.
2815        // E.g. these are both valid:
2816        //  struct A { // unnamed structs
2817        //    struct { struct A *next; } entry0;
2818        //    struct { struct A *next; } entry1;
2819        //  };
2820        //  struct X { struct { int a; }; struct { int b; }; }; // anon structs
2821        if (!SearchName)
2822          if (!IsStructuralMatch(D, FoundRecord, false))
2823            continue;
2824
2825        if (!hasSameVisibilityContextAndLinkage(FoundRecord, D))
2826          continue;
2827
2828        if (IsStructuralMatch(D, FoundRecord)) {
2829          RecordDecl *FoundDef = FoundRecord->getDefinition();
2830          if (D->isThisDeclarationADefinition() && FoundDef) {
2831            // FIXME: Structural equivalence check should check for same
2832            // user-defined methods.
2833            Importer.MapImported(D, FoundDef);
2834            if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2835              auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
2836              assert(FoundCXX && "Record type mismatch");
2837
2838              if (!Importer.isMinimalImport())
2839                // FoundDef may not have every implicit method that D has
2840                // because implicit methods are created only if they are used.
2841                if (Error Err = ImportImplicitMethods(DCXX, FoundCXX))
2842                  return std::move(Err);
2843            }
2844          }
2845          PrevDecl = FoundRecord->getMostRecentDecl();
2846          break;
2847        }
2848        ConflictingDecls.push_back(FoundDecl);
2849      } // kind is RecordDecl
2850    } // for
2851
2852    if (!ConflictingDecls.empty() && SearchName) {
2853      ExpectedName NameOrErr = Importer.HandleNameConflict(
2854          SearchName, DC, IDNS, ConflictingDecls.data(),
2855          ConflictingDecls.size());
2856      if (NameOrErr)
2857        Name = NameOrErr.get();
2858      else
2859        return NameOrErr.takeError();
2860    }
2861  }
2862
2863  ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2864  if (!BeginLocOrErr)
2865    return BeginLocOrErr.takeError();
2866
2867  // Create the record declaration.
2868  RecordDecl *D2 = nullptr;
2869  CXXRecordDecl *D2CXX = nullptr;
2870  if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2871    if (DCXX->isLambda()) {
2872      auto TInfoOrErr = import(DCXX->getLambdaTypeInfo());
2873      if (!TInfoOrErr)
2874        return TInfoOrErr.takeError();
2875      if (GetImportedOrCreateSpecialDecl(
2876              D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
2877              DC, *TInfoOrErr, Loc, DCXX->isDependentLambda(),
2878              DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
2879        return D2CXX;
2880      ExpectedDecl CDeclOrErr = import(DCXX->getLambdaContextDecl());
2881      if (!CDeclOrErr)
2882        return CDeclOrErr.takeError();
2883      D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), *CDeclOrErr,
2884                               DCXX->hasKnownLambdaInternalLinkage());
2885      D2CXX->setDeviceLambdaManglingNumber(
2886          DCXX->getDeviceLambdaManglingNumber());
2887   } else if (DCXX->isInjectedClassName()) {
2888      // We have to be careful to do a similar dance to the one in
2889      // Sema::ActOnStartCXXMemberDeclarations
2890      const bool DelayTypeCreation = true;
2891      if (GetImportedOrCreateDecl(
2892              D2CXX, D, Importer.getToContext(), D->getTagKind(), DC,
2893              *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2894              cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
2895        return D2CXX;
2896      Importer.getToContext().getTypeDeclType(
2897          D2CXX, dyn_cast<CXXRecordDecl>(DC));
2898    } else {
2899      if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2900                                  D->getTagKind(), DC, *BeginLocOrErr, Loc,
2901                                  Name.getAsIdentifierInfo(),
2902                                  cast_or_null<CXXRecordDecl>(PrevDecl)))
2903        return D2CXX;
2904    }
2905
2906    D2 = D2CXX;
2907    D2->setAccess(D->getAccess());
2908    D2->setLexicalDeclContext(LexicalDC);
2909    addDeclToContexts(D, D2);
2910
2911    if (ClassTemplateDecl *FromDescribed =
2912        DCXX->getDescribedClassTemplate()) {
2913      ClassTemplateDecl *ToDescribed;
2914      if (Error Err = importInto(ToDescribed, FromDescribed))
2915        return std::move(Err);
2916      D2CXX->setDescribedClassTemplate(ToDescribed);
2917      if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
2918        // In a record describing a template the type should be an
2919        // InjectedClassNameType (see Sema::CheckClassTemplate). Update the
2920        // previously set type to the correct value here (ToDescribed is not
2921        // available at record create).
2922        // FIXME: The previous type is cleared but not removed from
2923        // ASTContext's internal storage.
2924        CXXRecordDecl *Injected = nullptr;
2925        for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
2926          auto *Record = dyn_cast<CXXRecordDecl>(Found);
2927          if (Record && Record->isInjectedClassName()) {
2928            Injected = Record;
2929            break;
2930          }
2931        }
2932        // Create an injected type for the whole redecl chain.
2933        SmallVector<Decl *, 2> Redecls =
2934            getCanonicalForwardRedeclChain(D2CXX);
2935        for (auto *R : Redecls) {
2936          auto *RI = cast<CXXRecordDecl>(R);
2937          RI->setTypeForDecl(nullptr);
2938          // Below we create a new injected type and assign that to the
2939          // canonical decl, subsequent declarations in the chain will reuse
2940          // that type.
2941          Importer.getToContext().getInjectedClassNameType(
2942              RI, ToDescribed->getInjectedClassNameSpecialization());
2943        }
2944        // Set the new type for the previous injected decl too.
2945        if (Injected) {
2946          Injected->setTypeForDecl(nullptr);
2947          Importer.getToContext().getTypeDeclType(Injected, D2CXX);
2948        }
2949      }
2950    } else if (MemberSpecializationInfo *MemberInfo =
2951                   DCXX->getMemberSpecializationInfo()) {
2952        TemplateSpecializationKind SK =
2953            MemberInfo->getTemplateSpecializationKind();
2954        CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
2955
2956        if (Expected<CXXRecordDecl *> ToInstOrErr = import(FromInst))
2957          D2CXX->setInstantiationOfMemberClass(*ToInstOrErr, SK);
2958        else
2959          return ToInstOrErr.takeError();
2960
2961        if (ExpectedSLoc POIOrErr =
2962            import(MemberInfo->getPointOfInstantiation()))
2963          D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
2964            *POIOrErr);
2965        else
2966          return POIOrErr.takeError();
2967    }
2968
2969  } else {
2970    if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
2971                                D->getTagKind(), DC, *BeginLocOrErr, Loc,
2972                                Name.getAsIdentifierInfo(), PrevDecl))
2973      return D2;
2974    D2->setLexicalDeclContext(LexicalDC);
2975    addDeclToContexts(D, D2);
2976  }
2977
2978  if (auto BraceRangeOrErr = import(D->getBraceRange()))
2979    D2->setBraceRange(*BraceRangeOrErr);
2980  else
2981    return BraceRangeOrErr.takeError();
2982  if (auto QualifierLocOrErr = import(D->getQualifierLoc()))
2983    D2->setQualifierInfo(*QualifierLocOrErr);
2984  else
2985    return QualifierLocOrErr.takeError();
2986
2987  if (D->isAnonymousStructOrUnion())
2988    D2->setAnonymousStructOrUnion(true);
2989
2990  if (D->isCompleteDefinition())
2991    if (Error Err = ImportDefinition(D, D2, IDK_Default))
2992      return std::move(Err);
2993
2994  return D2;
2995}
2996
2997ExpectedDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2998  // Import the major distinguishing characteristics of this enumerator.
2999  DeclContext *DC, *LexicalDC;
3000  DeclarationName Name;
3001  SourceLocation Loc;
3002  NamedDecl *ToD;
3003  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3004    return std::move(Err);
3005  if (ToD)
3006    return ToD;
3007
3008  // Determine whether there are any other declarations with the same name and
3009  // in the same context.
3010  if (!LexicalDC->isFunctionOrMethod()) {
3011    SmallVector<NamedDecl *, 4> ConflictingDecls;
3012    unsigned IDNS = Decl::IDNS_Ordinary;
3013    auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3014    for (auto *FoundDecl : FoundDecls) {
3015      if (!FoundDecl->isInIdentifierNamespace(IDNS))
3016        continue;
3017
3018      if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
3019        if (IsStructuralMatch(D, FoundEnumConstant))
3020          return Importer.MapImported(D, FoundEnumConstant);
3021        ConflictingDecls.push_back(FoundDecl);
3022      }
3023    }
3024
3025    if (!ConflictingDecls.empty()) {
3026      ExpectedName NameOrErr = Importer.HandleNameConflict(
3027          Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3028      if (NameOrErr)
3029        Name = NameOrErr.get();
3030      else
3031        return NameOrErr.takeError();
3032    }
3033  }
3034
3035  ExpectedType TypeOrErr = import(D->getType());
3036  if (!TypeOrErr)
3037    return TypeOrErr.takeError();
3038
3039  ExpectedExpr InitOrErr = import(D->getInitExpr());
3040  if (!InitOrErr)
3041    return InitOrErr.takeError();
3042
3043  EnumConstantDecl *ToEnumerator;
3044  if (GetImportedOrCreateDecl(
3045          ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc,
3046          Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->getInitVal()))
3047    return ToEnumerator;
3048
3049  ToEnumerator->setAccess(D->getAccess());
3050  ToEnumerator->setLexicalDeclContext(LexicalDC);
3051  LexicalDC->addDeclInternal(ToEnumerator);
3052  return ToEnumerator;
3053}
3054
3055Error ASTNodeImporter::ImportTemplateParameterLists(const DeclaratorDecl *FromD,
3056                                                    DeclaratorDecl *ToD) {
3057  unsigned int Num = FromD->getNumTemplateParameterLists();
3058  if (Num == 0)
3059    return Error::success();
3060  SmallVector<TemplateParameterList *, 2> ToTPLists(Num);
3061  for (unsigned int I = 0; I < Num; ++I)
3062    if (Expected<TemplateParameterList *> ToTPListOrErr =
3063            import(FromD->getTemplateParameterList(I)))
3064      ToTPLists[I] = *ToTPListOrErr;
3065    else
3066      return ToTPListOrErr.takeError();
3067  ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);
3068  return Error::success();
3069}
3070
3071Error ASTNodeImporter::ImportTemplateInformation(
3072    FunctionDecl *FromFD, FunctionDecl *ToFD) {
3073  switch (FromFD->getTemplatedKind()) {
3074  case FunctionDecl::TK_NonTemplate:
3075  case FunctionDecl::TK_FunctionTemplate:
3076    return Error::success();
3077
3078  case FunctionDecl::TK_MemberSpecialization: {
3079    TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
3080
3081    if (Expected<FunctionDecl *> InstFDOrErr =
3082        import(FromFD->getInstantiatedFromMemberFunction()))
3083      ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3084    else
3085      return InstFDOrErr.takeError();
3086
3087    if (ExpectedSLoc POIOrErr = import(
3088        FromFD->getMemberSpecializationInfo()->getPointOfInstantiation()))
3089      ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
3090    else
3091      return POIOrErr.takeError();
3092
3093    return Error::success();
3094  }
3095
3096  case FunctionDecl::TK_FunctionTemplateSpecialization: {
3097    auto FunctionAndArgsOrErr =
3098        ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
3099    if (!FunctionAndArgsOrErr)
3100      return FunctionAndArgsOrErr.takeError();
3101
3102    TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
3103          Importer.getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3104
3105    auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
3106    TemplateArgumentListInfo ToTAInfo;
3107    const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3108    if (FromTAArgsAsWritten)
3109      if (Error Err = ImportTemplateArgumentListInfo(
3110          *FromTAArgsAsWritten, ToTAInfo))
3111        return Err;
3112
3113    ExpectedSLoc POIOrErr = import(FTSInfo->getPointOfInstantiation());
3114    if (!POIOrErr)
3115      return POIOrErr.takeError();
3116
3117    if (Error Err = ImportTemplateParameterLists(FromFD, ToFD))
3118      return Err;
3119
3120    TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
3121    ToFD->setFunctionTemplateSpecialization(
3122        std::get<0>(*FunctionAndArgsOrErr), ToTAList, /* InsertPos= */ nullptr,
3123        TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, *POIOrErr);
3124    return Error::success();
3125  }
3126
3127  case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
3128    auto *FromInfo = FromFD->getDependentSpecializationInfo();
3129    UnresolvedSet<8> TemplDecls;
3130    unsigned NumTemplates = FromInfo->getNumTemplates();
3131    for (unsigned I = 0; I < NumTemplates; I++) {
3132      if (Expected<FunctionTemplateDecl *> ToFTDOrErr =
3133          import(FromInfo->getTemplate(I)))
3134        TemplDecls.addDecl(*ToFTDOrErr);
3135      else
3136        return ToFTDOrErr.takeError();
3137    }
3138
3139    // Import TemplateArgumentListInfo.
3140    TemplateArgumentListInfo ToTAInfo;
3141    if (Error Err = ImportTemplateArgumentListInfo(
3142        FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
3143        llvm::makeArrayRef(
3144            FromInfo->getTemplateArgs(), FromInfo->getNumTemplateArgs()),
3145        ToTAInfo))
3146      return Err;
3147
3148    ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
3149                                             TemplDecls, ToTAInfo);
3150    return Error::success();
3151  }
3152  }
3153  llvm_unreachable("All cases should be covered!");
3154}
3155
3156Expected<FunctionDecl *>
3157ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
3158  auto FunctionAndArgsOrErr =
3159      ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
3160  if (!FunctionAndArgsOrErr)
3161    return FunctionAndArgsOrErr.takeError();
3162
3163  FunctionTemplateDecl *Template;
3164  TemplateArgsTy ToTemplArgs;
3165  std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3166  void *InsertPos = nullptr;
3167  auto *FoundSpec = Template->findSpecialization(ToTemplArgs, InsertPos);
3168  return FoundSpec;
3169}
3170
3171Error ASTNodeImporter::ImportFunctionDeclBody(FunctionDecl *FromFD,
3172                                              FunctionDecl *ToFD) {
3173  if (Stmt *FromBody = FromFD->getBody()) {
3174    if (ExpectedStmt ToBodyOrErr = import(FromBody))
3175      ToFD->setBody(*ToBodyOrErr);
3176    else
3177      return ToBodyOrErr.takeError();
3178  }
3179  return Error::success();
3180}
3181
3182// Returns true if the given D has a DeclContext up to the TranslationUnitDecl
3183// which is equal to the given DC.
3184static bool isAncestorDeclContextOf(const DeclContext *DC, const Decl *D) {
3185  const DeclContext *DCi = D->getDeclContext();
3186  while (DCi != D->getTranslationUnitDecl()) {
3187    if (DCi == DC)
3188      return true;
3189    DCi = DCi->getParent();
3190  }
3191  return false;
3192}
3193
3194bool ASTNodeImporter::hasAutoReturnTypeDeclaredInside(FunctionDecl *D) {
3195  QualType FromTy = D->getType();
3196  const FunctionProtoType *FromFPT = FromTy->getAs<FunctionProtoType>();
3197  assert(FromFPT && "Must be called on FunctionProtoType");
3198  if (AutoType *AutoT = FromFPT->getReturnType()->getContainedAutoType()) {
3199    QualType DeducedT = AutoT->getDeducedType();
3200    if (const RecordType *RecordT =
3201            DeducedT.isNull() ? nullptr : dyn_cast<RecordType>(DeducedT)) {
3202      RecordDecl *RD = RecordT->getDecl();
3203      assert(RD);
3204      if (isAncestorDeclContextOf(D, RD)) {
3205        assert(RD->getLexicalDeclContext() == RD->getDeclContext());
3206        return true;
3207      }
3208    }
3209  }
3210  if (const TypedefType *TypedefT =
3211          dyn_cast<TypedefType>(FromFPT->getReturnType())) {
3212    TypedefNameDecl *TD = TypedefT->getDecl();
3213    assert(TD);
3214    if (isAncestorDeclContextOf(D, TD)) {
3215      assert(TD->getLexicalDeclContext() == TD->getDeclContext());
3216      return true;
3217    }
3218  }
3219  return false;
3220}
3221
3222ExplicitSpecifier
3223ASTNodeImporter::importExplicitSpecifier(Error &Err, ExplicitSpecifier ESpec) {
3224  Expr *ExplicitExpr = ESpec.getExpr();
3225  if (ExplicitExpr)
3226    ExplicitExpr = importChecked(Err, ESpec.getExpr());
3227  return ExplicitSpecifier(ExplicitExpr, ESpec.getKind());
3228}
3229
3230ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
3231
3232  SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D);
3233  auto RedeclIt = Redecls.begin();
3234  // Import the first part of the decl chain. I.e. import all previous
3235  // declarations starting from the canonical decl.
3236  for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3237    ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
3238    if (!ToRedeclOrErr)
3239      return ToRedeclOrErr.takeError();
3240  }
3241  assert(*RedeclIt == D);
3242
3243  // Import the major distinguishing characteristics of this function.
3244  DeclContext *DC, *LexicalDC;
3245  DeclarationName Name;
3246  SourceLocation Loc;
3247  NamedDecl *ToD;
3248  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3249    return std::move(Err);
3250  if (ToD)
3251    return ToD;
3252
3253  FunctionDecl *FoundByLookup = nullptr;
3254  FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
3255
3256  // If this is a function template specialization, then try to find the same
3257  // existing specialization in the "to" context. The lookup below will not
3258  // find any specialization, but would find the primary template; thus, we
3259  // have to skip normal lookup in case of specializations.
3260  // FIXME handle member function templates (TK_MemberSpecialization) similarly?
3261  if (D->getTemplatedKind() ==
3262      FunctionDecl::TK_FunctionTemplateSpecialization) {
3263    auto FoundFunctionOrErr = FindFunctionTemplateSpecialization(D);
3264    if (!FoundFunctionOrErr)
3265      return FoundFunctionOrErr.takeError();
3266    if (FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3267      if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
3268        return Def;
3269      FoundByLookup = FoundFunction;
3270    }
3271  }
3272  // Try to find a function in our own ("to") context with the same name, same
3273  // type, and in the same context as the function we're importing.
3274  else if (!LexicalDC->isFunctionOrMethod()) {
3275    SmallVector<NamedDecl *, 4> ConflictingDecls;
3276    unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
3277    auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3278    for (auto *FoundDecl : FoundDecls) {
3279      if (!FoundDecl->isInIdentifierNamespace(IDNS))
3280        continue;
3281
3282      if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3283        if (!hasSameVisibilityContextAndLinkage(FoundFunction, D))
3284          continue;
3285
3286        if (IsStructuralMatch(D, FoundFunction)) {
3287          if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
3288            return Def;
3289          FoundByLookup = FoundFunction;
3290          break;
3291        }
3292        // FIXME: Check for overloading more carefully, e.g., by boosting
3293        // Sema::IsOverload out to the AST library.
3294
3295        // Function overloading is okay in C++.
3296        if (Importer.getToContext().getLangOpts().CPlusPlus)
3297          continue;
3298
3299        // Complain about inconsistent function types.
3300        Importer.ToDiag(Loc, diag::warn_odr_function_type_inconsistent)
3301            << Name << D->getType() << FoundFunction->getType();
3302        Importer.ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3303            << FoundFunction->getType();
3304        ConflictingDecls.push_back(FoundDecl);
3305      }
3306    }
3307
3308    if (!ConflictingDecls.empty()) {
3309      ExpectedName NameOrErr = Importer.HandleNameConflict(
3310          Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3311      if (NameOrErr)
3312        Name = NameOrErr.get();
3313      else
3314        return NameOrErr.takeError();
3315    }
3316  }
3317
3318  // We do not allow more than one in-class declaration of a function. This is
3319  // because AST clients like VTableBuilder asserts on this. VTableBuilder
3320  // assumes there is only one in-class declaration. Building a redecl
3321  // chain would result in more than one in-class declaration for
3322  // overrides (even if they are part of the same redecl chain inside the
3323  // derived class.)
3324  if (FoundByLookup) {
3325    if (isa<CXXMethodDecl>(FoundByLookup)) {
3326      if (D->getLexicalDeclContext() == D->getDeclContext()) {
3327        if (!D->doesThisDeclarationHaveABody()) {
3328          if (FunctionTemplateDecl *DescribedD =
3329                  D->getDescribedFunctionTemplate()) {
3330            // Handle a "templated" function together with its described
3331            // template. This avoids need for a similar check at import of the
3332            // described template.
3333            assert(FoundByLookup->getDescribedFunctionTemplate() &&
3334                   "Templated function mapped to non-templated?");
3335            Importer.MapImported(DescribedD,
3336                                 FoundByLookup->getDescribedFunctionTemplate());
3337          }
3338          return Importer.MapImported(D, FoundByLookup);
3339        } else {
3340          // Let's continue and build up the redecl chain in this case.
3341          // FIXME Merge the functions into one decl.
3342        }
3343      }
3344    }
3345  }
3346
3347  DeclarationNameInfo NameInfo(Name, Loc);
3348  // Import additional name location/type info.
3349  if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
3350    return std::move(Err);
3351
3352  QualType FromTy = D->getType();
3353  // Set to true if we do not import the type of the function as is. There are
3354  // cases when the original type would result in an infinite recursion during
3355  // the import. To avoid an infinite recursion when importing, we create the
3356  // FunctionDecl with a simplified function type and update it only after the
3357  // relevant AST nodes are already imported.
3358  bool UsedDifferentProtoType = false;
3359  if (const auto *FromFPT = FromTy->getAs<FunctionProtoType>()) {
3360    QualType FromReturnTy = FromFPT->getReturnType();
3361    // Functions with auto return type may define a struct inside their body
3362    // and the return type could refer to that struct.
3363    // E.g.: auto foo() { struct X{}; return X(); }
3364    // To avoid an infinite recursion when importing, create the FunctionDecl
3365    // with a simplified return type.
3366    if (hasAutoReturnTypeDeclaredInside(D)) {
3367      FromReturnTy = Importer.getFromContext().VoidTy;
3368      UsedDifferentProtoType = true;
3369    }
3370    FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
3371    // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
3372    // FunctionDecl that we are importing the FunctionProtoType for.
3373    // To avoid an infinite recursion when importing, create the FunctionDecl
3374    // with a simplified function type.
3375    if (FromEPI.ExceptionSpec.SourceDecl ||
3376        FromEPI.ExceptionSpec.SourceTemplate ||
3377        FromEPI.ExceptionSpec.NoexceptExpr) {
3378      FunctionProtoType::ExtProtoInfo DefaultEPI;
3379      FromEPI = DefaultEPI;
3380      UsedDifferentProtoType = true;
3381    }
3382    FromTy = Importer.getFromContext().getFunctionType(
3383        FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3384  }
3385
3386  Error Err = Error::success();
3387  auto T = importChecked(Err, FromTy);
3388  auto TInfo = importChecked(Err, D->getTypeSourceInfo());
3389  auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
3390  auto ToEndLoc = importChecked(Err, D->getEndLoc());
3391  auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
3392  auto TrailingRequiresClause =
3393      importChecked(Err, D->getTrailingRequiresClause());
3394  if (Err)
3395    return std::move(Err);
3396
3397  // Import the function parameters.
3398  SmallVector<ParmVarDecl *, 8> Parameters;
3399  for (auto P : D->parameters()) {
3400    if (Expected<ParmVarDecl *> ToPOrErr = import(P))
3401      Parameters.push_back(*ToPOrErr);
3402    else
3403      return ToPOrErr.takeError();
3404  }
3405
3406  // Create the imported function.
3407  FunctionDecl *ToFunction = nullptr;
3408  if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3409    ExplicitSpecifier ESpec =
3410        importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3411    if (Err)
3412      return std::move(Err);
3413    if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3414            ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3415            ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->isInlineSpecified(),
3416            D->isImplicit(), D->getConstexprKind(),
3417            InheritedConstructor(), // FIXME: Properly import inherited
3418                                    // constructor info
3419            TrailingRequiresClause))
3420      return ToFunction;
3421  } else if (CXXDestructorDecl *FromDtor = dyn_cast<CXXDestructorDecl>(D)) {
3422
3423    Error Err = Error::success();
3424    auto ToOperatorDelete = importChecked(
3425        Err, const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()));
3426    auto ToThisArg = importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3427    if (Err)
3428      return std::move(Err);
3429
3430    if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3431        ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3432        ToInnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
3433        D->isImplicit(), D->getConstexprKind(), TrailingRequiresClause))
3434      return ToFunction;
3435
3436    CXXDestructorDecl *ToDtor = cast<CXXDestructorDecl>(ToFunction);
3437
3438    ToDtor->setOperatorDelete(ToOperatorDelete, ToThisArg);
3439  } else if (CXXConversionDecl *FromConversion =
3440                 dyn_cast<CXXConversionDecl>(D)) {
3441    ExplicitSpecifier ESpec =
3442        importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3443    if (Err)
3444      return std::move(Err);
3445    if (GetImportedOrCreateDecl<CXXConversionDecl>(
3446            ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3447            ToInnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(), ESpec,
3448            D->getConstexprKind(), SourceLocation(), TrailingRequiresClause))
3449      return ToFunction;
3450  } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
3451    if (GetImportedOrCreateDecl<CXXMethodDecl>(
3452            ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3453            ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
3454            Method->isInlineSpecified(), D->getConstexprKind(),
3455            SourceLocation(), TrailingRequiresClause))
3456      return ToFunction;
3457  } else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
3458    ExplicitSpecifier ESpec =
3459        importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
3460    CXXConstructorDecl *Ctor =
3461        importChecked(Err, Guide->getCorrespondingConstructor());
3462    if (Err)
3463      return std::move(Err);
3464    if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
3465            ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart, ESpec,
3466            NameInfo, T, TInfo, ToEndLoc, Ctor))
3467      return ToFunction;
3468    cast<CXXDeductionGuideDecl>(ToFunction)
3469        ->setIsCopyDeductionCandidate(Guide->isCopyDeductionCandidate());
3470  } else {
3471    if (GetImportedOrCreateDecl(
3472            ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart,
3473            NameInfo, T, TInfo, D->getStorageClass(), D->isInlineSpecified(),
3474            D->hasWrittenPrototype(), D->getConstexprKind(),
3475            TrailingRequiresClause))
3476      return ToFunction;
3477  }
3478
3479  // Connect the redecl chain.
3480  if (FoundByLookup) {
3481    auto *Recent = const_cast<FunctionDecl *>(
3482          FoundByLookup->getMostRecentDecl());
3483    ToFunction->setPreviousDecl(Recent);
3484    // FIXME Probably we should merge exception specifications.  E.g. In the
3485    // "To" context the existing function may have exception specification with
3486    // noexcept-unevaluated, while the newly imported function may have an
3487    // evaluated noexcept.  A call to adjustExceptionSpec() on the imported
3488    // decl and its redeclarations may be required.
3489  }
3490
3491  ToFunction->setQualifierInfo(ToQualifierLoc);
3492  ToFunction->setAccess(D->getAccess());
3493  ToFunction->setLexicalDeclContext(LexicalDC);
3494  ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
3495  ToFunction->setTrivial(D->isTrivial());
3496  ToFunction->setPure(D->isPure());
3497  ToFunction->setDefaulted(D->isDefaulted());
3498  ToFunction->setExplicitlyDefaulted(D->isExplicitlyDefaulted());
3499  ToFunction->setDeletedAsWritten(D->isDeletedAsWritten());
3500  ToFunction->setRangeEnd(ToEndLoc);
3501
3502  // Set the parameters.
3503  for (auto *Param : Parameters) {
3504    Param->setOwningFunction(ToFunction);
3505    ToFunction->addDeclInternal(Param);
3506  }
3507  ToFunction->setParams(Parameters);
3508
3509  // We need to complete creation of FunctionProtoTypeLoc manually with setting
3510  // params it refers to.
3511  if (TInfo) {
3512    if (auto ProtoLoc =
3513        TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
3514      for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
3515        ProtoLoc.setParam(I, Parameters[I]);
3516    }
3517  }
3518
3519  // Import the describing template function, if any.
3520  if (FromFT) {
3521    auto ToFTOrErr = import(FromFT);
3522    if (!ToFTOrErr)
3523      return ToFTOrErr.takeError();
3524  }
3525
3526  // Import Ctor initializers.
3527  if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3528    if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3529      SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers);
3530      // Import first, then allocate memory and copy if there was no error.
3531      if (Error Err = ImportContainerChecked(
3532          FromConstructor->inits(), CtorInitializers))
3533        return std::move(Err);
3534      auto **Memory =
3535          new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
3536      std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3537      auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
3538      ToCtor->setCtorInitializers(Memory);
3539      ToCtor->setNumCtorInitializers(NumInitializers);
3540    }
3541  }
3542
3543  if (D->doesThisDeclarationHaveABody()) {
3544    Error Err = ImportFunctionDeclBody(D, ToFunction);
3545
3546    if (Err)
3547      return std::move(Err);
3548  }
3549
3550  // Import and set the original type in case we used another type.
3551  if (UsedDifferentProtoType) {
3552    if (ExpectedType TyOrErr = import(D->getType()))
3553      ToFunction->setType(*TyOrErr);
3554    else
3555      return TyOrErr.takeError();
3556  }
3557
3558  // FIXME: Other bits to merge?
3559
3560  // If it is a template, import all related things.
3561  if (Error Err = ImportTemplateInformation(D, ToFunction))
3562    return std::move(Err);
3563
3564  addDeclToContexts(D, ToFunction);
3565
3566  if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
3567    if (Error Err = ImportOverriddenMethods(cast<CXXMethodDecl>(ToFunction),
3568                                            FromCXXMethod))
3569      return std::move(Err);
3570
3571  // Import the rest of the chain. I.e. import all subsequent declarations.
3572  for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
3573    ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
3574    if (!ToRedeclOrErr)
3575      return ToRedeclOrErr.takeError();
3576  }
3577
3578  return ToFunction;
3579}
3580
3581ExpectedDecl ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
3582  return VisitFunctionDecl(D);
3583}
3584
3585ExpectedDecl ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
3586  return VisitCXXMethodDecl(D);
3587}
3588
3589ExpectedDecl ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
3590  return VisitCXXMethodDecl(D);
3591}
3592
3593ExpectedDecl ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
3594  return VisitCXXMethodDecl(D);
3595}
3596
3597ExpectedDecl
3598ASTNodeImporter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
3599  return VisitFunctionDecl(D);
3600}
3601
3602ExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
3603  // Import the major distinguishing characteristics of a variable.
3604  DeclContext *DC, *LexicalDC;
3605  DeclarationName Name;
3606  SourceLocation Loc;
3607  NamedDecl *ToD;
3608  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3609    return std::move(Err);
3610  if (ToD)
3611    return ToD;
3612
3613  // Determine whether we've already imported this field.
3614  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3615  for (auto *FoundDecl : FoundDecls) {
3616    if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
3617      // For anonymous fields, match up by index.
3618      if (!Name &&
3619          ASTImporter::getFieldIndex(D) !=
3620          ASTImporter::getFieldIndex(FoundField))
3621        continue;
3622
3623      if (Importer.IsStructurallyEquivalent(D->getType(),
3624                                            FoundField->getType())) {
3625        Importer.MapImported(D, FoundField);
3626        // In case of a FieldDecl of a ClassTemplateSpecializationDecl, the
3627        // initializer of a FieldDecl might not had been instantiated in the
3628        // "To" context.  However, the "From" context might instantiated that,
3629        // thus we have to merge that.
3630        if (Expr *FromInitializer = D->getInClassInitializer()) {
3631          // We don't have yet the initializer set.
3632          if (FoundField->hasInClassInitializer() &&
3633              !FoundField->getInClassInitializer()) {
3634            if (ExpectedExpr ToInitializerOrErr = import(FromInitializer))
3635              FoundField->setInClassInitializer(*ToInitializerOrErr);
3636            else {
3637              // We can't return error here,
3638              // since we already mapped D as imported.
3639              // FIXME: warning message?
3640              consumeError(ToInitializerOrErr.takeError());
3641              return FoundField;
3642            }
3643          }
3644        }
3645        return FoundField;
3646      }
3647
3648      // FIXME: Why is this case not handled with calling HandleNameConflict?
3649      Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3650        << Name << D->getType() << FoundField->getType();
3651      Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3652        << FoundField->getType();
3653
3654      return make_error<ImportError>(ImportError::NameConflict);
3655    }
3656  }
3657
3658  Error Err = Error::success();
3659  auto ToType = importChecked(Err, D->getType());
3660  auto ToTInfo = importChecked(Err, D->getTypeSourceInfo());
3661  auto ToBitWidth = importChecked(Err, D->getBitWidth());
3662  auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
3663  auto ToInitializer = importChecked(Err, D->getInClassInitializer());
3664  if (Err)
3665    return std::move(Err);
3666  const Type *ToCapturedVLAType = nullptr;
3667  if (Error Err = Importer.importInto(
3668          ToCapturedVLAType, cast_or_null<Type>(D->getCapturedVLAType())))
3669    return std::move(Err);
3670
3671  FieldDecl *ToField;
3672  if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
3673                              ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
3674                              ToType, ToTInfo, ToBitWidth, D->isMutable(),
3675                              D->getInClassInitStyle()))
3676    return ToField;
3677
3678  ToField->setAccess(D->getAccess());
3679  ToField->setLexicalDeclContext(LexicalDC);
3680  if (ToInitializer)
3681    ToField->setInClassInitializer(ToInitializer);
3682  ToField->setImplicit(D->isImplicit());
3683  if (ToCapturedVLAType)
3684    ToField->setCapturedVLAType(cast<VariableArrayType>(ToCapturedVLAType));
3685  LexicalDC->addDeclInternal(ToField);
3686  return ToField;
3687}
3688
3689ExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
3690  // Import the major distinguishing characteristics of a variable.
3691  DeclContext *DC, *LexicalDC;
3692  DeclarationName Name;
3693  SourceLocation Loc;
3694  NamedDecl *ToD;
3695  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3696    return std::move(Err);
3697  if (ToD)
3698    return ToD;
3699
3700  // Determine whether we've already imported this field.
3701  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3702  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3703    if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3704      // For anonymous indirect fields, match up by index.
3705      if (!Name &&
3706          ASTImporter::getFieldIndex(D) !=
3707          ASTImporter::getFieldIndex(FoundField))
3708        continue;
3709
3710      if (Importer.IsStructurallyEquivalent(D->getType(),
3711                                            FoundField->getType(),
3712                                            !Name.isEmpty())) {
3713        Importer.MapImported(D, FoundField);
3714        return FoundField;
3715      }
3716
3717      // If there are more anonymous fields to check, continue.
3718      if (!Name && I < N-1)
3719        continue;
3720
3721      // FIXME: Why is this case not handled with calling HandleNameConflict?
3722      Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3723        << Name << D->getType() << FoundField->getType();
3724      Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3725        << FoundField->getType();
3726
3727      return make_error<ImportError>(ImportError::NameConflict);
3728    }
3729  }
3730
3731  // Import the type.
3732  auto TypeOrErr = import(D->getType());
3733  if (!TypeOrErr)
3734    return TypeOrErr.takeError();
3735
3736  auto **NamedChain =
3737    new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
3738
3739  unsigned i = 0;
3740  for (auto *PI : D->chain())
3741    if (Expected<NamedDecl *> ToD = import(PI))
3742      NamedChain[i++] = *ToD;
3743    else
3744      return ToD.takeError();
3745
3746  llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
3747  IndirectFieldDecl *ToIndirectField;
3748  if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC,
3749                              Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
3750    // FIXME here we leak `NamedChain` which is allocated before
3751    return ToIndirectField;
3752
3753  ToIndirectField->setAccess(D->getAccess());
3754  ToIndirectField->setLexicalDeclContext(LexicalDC);
3755  LexicalDC->addDeclInternal(ToIndirectField);
3756  return ToIndirectField;
3757}
3758
3759/// Used as return type of getFriendCountAndPosition.
3760struct FriendCountAndPosition {
3761  /// Number of similar looking friends.
3762  unsigned int TotalCount;
3763  /// Index of the specific FriendDecl.
3764  unsigned int IndexOfDecl;
3765};
3766
3767template <class T>
3768static FriendCountAndPosition getFriendCountAndPosition(
3769    const FriendDecl *FD,
3770    llvm::function_ref<T(const FriendDecl *)> GetCanTypeOrDecl) {
3771  unsigned int FriendCount = 0;
3772  llvm::Optional<unsigned int> FriendPosition;
3773  const auto *RD = cast<CXXRecordDecl>(FD->getLexicalDeclContext());
3774
3775  T TypeOrDecl = GetCanTypeOrDecl(FD);
3776
3777  for (const FriendDecl *FoundFriend : RD->friends()) {
3778    if (FoundFriend == FD) {
3779      FriendPosition = FriendCount;
3780      ++FriendCount;
3781    } else if (!FoundFriend->getFriendDecl() == !FD->getFriendDecl() &&
3782               GetCanTypeOrDecl(FoundFriend) == TypeOrDecl) {
3783      ++FriendCount;
3784    }
3785  }
3786
3787  assert(FriendPosition && "Friend decl not found in own parent.");
3788
3789  return {FriendCount, *FriendPosition};
3790}
3791
3792static FriendCountAndPosition getFriendCountAndPosition(const FriendDecl *FD) {
3793  if (FD->getFriendType())
3794    return getFriendCountAndPosition<QualType>(FD, [](const FriendDecl *F) {
3795      if (TypeSourceInfo *TSI = F->getFriendType())
3796        return TSI->getType().getCanonicalType();
3797      llvm_unreachable("Wrong friend object type.");
3798    });
3799  else
3800    return getFriendCountAndPosition<Decl *>(FD, [](const FriendDecl *F) {
3801      if (Decl *D = F->getFriendDecl())
3802        return D->getCanonicalDecl();
3803      llvm_unreachable("Wrong friend object type.");
3804    });
3805}
3806
3807ExpectedDecl ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
3808  // Import the major distinguishing characteristics of a declaration.
3809  DeclContext *DC, *LexicalDC;
3810  if (Error Err = ImportDeclContext(D, DC, LexicalDC))
3811    return std::move(Err);
3812
3813  // Determine whether we've already imported this decl.
3814  // FriendDecl is not a NamedDecl so we cannot use lookup.
3815  // We try to maintain order and count of redundant friend declarations.
3816  const auto *RD = cast<CXXRecordDecl>(DC);
3817  FriendDecl *ImportedFriend = RD->getFirstFriend();
3818  SmallVector<FriendDecl *, 2> ImportedEquivalentFriends;
3819
3820  while (ImportedFriend) {
3821    bool Match = false;
3822    if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
3823      Match =
3824          IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(),
3825                            /*Complain=*/false);
3826    } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
3827      Match = Importer.IsStructurallyEquivalent(
3828          D->getFriendType()->getType(),
3829          ImportedFriend->getFriendType()->getType(), /*Complain=*/false);
3830    }
3831    if (Match)
3832      ImportedEquivalentFriends.push_back(ImportedFriend);
3833
3834    ImportedFriend = ImportedFriend->getNextFriend();
3835  }
3836  FriendCountAndPosition CountAndPosition = getFriendCountAndPosition(D);
3837
3838  assert(ImportedEquivalentFriends.size() <= CountAndPosition.TotalCount &&
3839         "Class with non-matching friends is imported, ODR check wrong?");
3840  if (ImportedEquivalentFriends.size() == CountAndPosition.TotalCount)
3841    return Importer.MapImported(
3842        D, ImportedEquivalentFriends[CountAndPosition.IndexOfDecl]);
3843
3844  // Not found. Create it.
3845  // The declarations will be put into order later by ImportDeclContext.
3846  FriendDecl::FriendUnion ToFU;
3847  if (NamedDecl *FriendD = D->getFriendDecl()) {
3848    NamedDecl *ToFriendD;
3849    if (Error Err = importInto(ToFriendD, FriendD))
3850      return std::move(Err);
3851
3852    if (FriendD->getFriendObjectKind() != Decl::FOK_None &&
3853        !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
3854      ToFriendD->setObjectOfFriendDecl(false);
3855
3856    ToFU = ToFriendD;
3857  } else { // The friend is a type, not a decl.
3858    if (auto TSIOrErr = import(D->getFriendType()))
3859      ToFU = *TSIOrErr;
3860    else
3861      return TSIOrErr.takeError();
3862  }
3863
3864  SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
3865  auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
3866  for (unsigned I = 0; I < D->NumTPLists; I++) {
3867    if (auto ListOrErr = import(FromTPLists[I]))
3868      ToTPLists[I] = *ListOrErr;
3869    else
3870      return ListOrErr.takeError();
3871  }
3872
3873  auto LocationOrErr = import(D->getLocation());
3874  if (!LocationOrErr)
3875    return LocationOrErr.takeError();
3876  auto FriendLocOrErr = import(D->getFriendLoc());
3877  if (!FriendLocOrErr)
3878    return FriendLocOrErr.takeError();
3879
3880  FriendDecl *FrD;
3881  if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
3882                              *LocationOrErr, ToFU,
3883                              *FriendLocOrErr, ToTPLists))
3884    return FrD;
3885
3886  FrD->setAccess(D->getAccess());
3887  FrD->setLexicalDeclContext(LexicalDC);
3888  LexicalDC->addDeclInternal(FrD);
3889  return FrD;
3890}
3891
3892ExpectedDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3893  // Import the major distinguishing characteristics of an ivar.
3894  DeclContext *DC, *LexicalDC;
3895  DeclarationName Name;
3896  SourceLocation Loc;
3897  NamedDecl *ToD;
3898  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3899    return std::move(Err);
3900  if (ToD)
3901    return ToD;
3902
3903  // Determine whether we've already imported this ivar
3904  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3905  for (auto *FoundDecl : FoundDecls) {
3906    if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
3907      if (Importer.IsStructurallyEquivalent(D->getType(),
3908                                            FoundIvar->getType())) {
3909        Importer.MapImported(D, FoundIvar);
3910        return FoundIvar;
3911      }
3912
3913      Importer.ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
3914        << Name << D->getType() << FoundIvar->getType();
3915      Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3916        << FoundIvar->getType();
3917
3918      return make_error<ImportError>(ImportError::NameConflict);
3919    }
3920  }
3921
3922  Error Err = Error::success();
3923  auto ToType = importChecked(Err, D->getType());
3924  auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
3925  auto ToBitWidth = importChecked(Err, D->getBitWidth());
3926  auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
3927  if (Err)
3928    return std::move(Err);
3929
3930  ObjCIvarDecl *ToIvar;
3931  if (GetImportedOrCreateDecl(
3932          ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
3933          ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
3934          ToType, ToTypeSourceInfo,
3935          D->getAccessControl(),ToBitWidth, D->getSynthesize()))
3936    return ToIvar;
3937
3938  ToIvar->setLexicalDeclContext(LexicalDC);
3939  LexicalDC->addDeclInternal(ToIvar);
3940  return ToIvar;
3941}
3942
3943ExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3944
3945  SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
3946  auto RedeclIt = Redecls.begin();
3947  // Import the first part of the decl chain. I.e. import all previous
3948  // declarations starting from the canonical decl.
3949  for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3950    ExpectedDecl RedeclOrErr = import(*RedeclIt);
3951    if (!RedeclOrErr)
3952      return RedeclOrErr.takeError();
3953  }
3954  assert(*RedeclIt == D);
3955
3956  // Import the major distinguishing characteristics of a variable.
3957  DeclContext *DC, *LexicalDC;
3958  DeclarationName Name;
3959  SourceLocation Loc;
3960  NamedDecl *ToD;
3961  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3962    return std::move(Err);
3963  if (ToD)
3964    return ToD;
3965
3966  // Try to find a variable in our own ("to") context with the same name and
3967  // in the same context as the variable we're importing.
3968  VarDecl *FoundByLookup = nullptr;
3969  if (D->isFileVarDecl()) {
3970    SmallVector<NamedDecl *, 4> ConflictingDecls;
3971    unsigned IDNS = Decl::IDNS_Ordinary;
3972    auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3973    for (auto *FoundDecl : FoundDecls) {
3974      if (!FoundDecl->isInIdentifierNamespace(IDNS))
3975        continue;
3976
3977      if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
3978        if (!hasSameVisibilityContextAndLinkage(FoundVar, D))
3979          continue;
3980        if (Importer.IsStructurallyEquivalent(D->getType(),
3981                                              FoundVar->getType())) {
3982
3983          // The VarDecl in the "From" context has a definition, but in the
3984          // "To" context we already have a definition.
3985          VarDecl *FoundDef = FoundVar->getDefinition();
3986          if (D->isThisDeclarationADefinition() && FoundDef)
3987            // FIXME Check for ODR error if the two definitions have
3988            // different initializers?
3989            return Importer.MapImported(D, FoundDef);
3990
3991          // The VarDecl in the "From" context has an initializer, but in the
3992          // "To" context we already have an initializer.
3993          const VarDecl *FoundDInit = nullptr;
3994          if (D->getInit() && FoundVar->getAnyInitializer(FoundDInit))
3995            // FIXME Diagnose ODR error if the two initializers are different?
3996            return Importer.MapImported(D, const_cast<VarDecl*>(FoundDInit));
3997
3998          FoundByLookup = FoundVar;
3999          break;
4000        }
4001
4002        const ArrayType *FoundArray
4003          = Importer.getToContext().getAsArrayType(FoundVar->getType());
4004        const ArrayType *TArray
4005          = Importer.getToContext().getAsArrayType(D->getType());
4006        if (FoundArray && TArray) {
4007          if (isa<IncompleteArrayType>(FoundArray) &&
4008              isa<ConstantArrayType>(TArray)) {
4009            // Import the type.
4010            if (auto TyOrErr = import(D->getType()))
4011              FoundVar->setType(*TyOrErr);
4012            else
4013              return TyOrErr.takeError();
4014
4015            FoundByLookup = FoundVar;
4016            break;
4017          } else if (isa<IncompleteArrayType>(TArray) &&
4018                     isa<ConstantArrayType>(FoundArray)) {
4019            FoundByLookup = FoundVar;
4020            break;
4021          }
4022        }
4023
4024        Importer.ToDiag(Loc, diag::warn_odr_variable_type_inconsistent)
4025          << Name << D->getType() << FoundVar->getType();
4026        Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
4027          << FoundVar->getType();
4028        ConflictingDecls.push_back(FoundDecl);
4029      }
4030    }
4031
4032    if (!ConflictingDecls.empty()) {
4033      ExpectedName NameOrErr = Importer.HandleNameConflict(
4034          Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
4035      if (NameOrErr)
4036        Name = NameOrErr.get();
4037      else
4038        return NameOrErr.takeError();
4039    }
4040  }
4041
4042  Error Err = Error::success();
4043  auto ToType = importChecked(Err, D->getType());
4044  auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4045  auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4046  auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4047  if (Err)
4048    return std::move(Err);
4049
4050  // Create the imported variable.
4051  VarDecl *ToVar;
4052  if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC,
4053                              ToInnerLocStart, Loc,
4054                              Name.getAsIdentifierInfo(),
4055                              ToType, ToTypeSourceInfo,
4056                              D->getStorageClass()))
4057    return ToVar;
4058
4059  ToVar->setTSCSpec(D->getTSCSpec());
4060  ToVar->setQualifierInfo(ToQualifierLoc);
4061  ToVar->setAccess(D->getAccess());
4062  ToVar->setLexicalDeclContext(LexicalDC);
4063
4064  if (FoundByLookup) {
4065    auto *Recent = const_cast<VarDecl *>(FoundByLookup->getMostRecentDecl());
4066    ToVar->setPreviousDecl(Recent);
4067  }
4068
4069  // Import the described template, if any.
4070  if (D->getDescribedVarTemplate()) {
4071    auto ToVTOrErr = import(D->getDescribedVarTemplate());
4072    if (!ToVTOrErr)
4073      return ToVTOrErr.takeError();
4074  }
4075
4076  if (Error Err = ImportInitializer(D, ToVar))
4077    return std::move(Err);
4078
4079  if (D->isConstexpr())
4080    ToVar->setConstexpr(true);
4081
4082  addDeclToContexts(D, ToVar);
4083
4084  // Import the rest of the chain. I.e. import all subsequent declarations.
4085  for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4086    ExpectedDecl RedeclOrErr = import(*RedeclIt);
4087    if (!RedeclOrErr)
4088      return RedeclOrErr.takeError();
4089  }
4090
4091  return ToVar;
4092}
4093
4094ExpectedDecl ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
4095  // Parameters are created in the translation unit's context, then moved
4096  // into the function declaration's context afterward.
4097  DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
4098
4099  Error Err = Error::success();
4100  auto ToDeclName = importChecked(Err, D->getDeclName());
4101  auto ToLocation = importChecked(Err, D->getLocation());
4102  auto ToType = importChecked(Err, D->getType());
4103  if (Err)
4104    return std::move(Err);
4105
4106  // Create the imported parameter.
4107  ImplicitParamDecl *ToParm = nullptr;
4108  if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
4109                              ToLocation, ToDeclName.getAsIdentifierInfo(),
4110                              ToType, D->getParameterKind()))
4111    return ToParm;
4112  return ToParm;
4113}
4114
4115Error ASTNodeImporter::ImportDefaultArgOfParmVarDecl(
4116    const ParmVarDecl *FromParam, ParmVarDecl *ToParam) {
4117  ToParam->setHasInheritedDefaultArg(FromParam->hasInheritedDefaultArg());
4118  ToParam->setKNRPromoted(FromParam->isKNRPromoted());
4119
4120  if (FromParam->hasUninstantiatedDefaultArg()) {
4121    if (auto ToDefArgOrErr = import(FromParam->getUninstantiatedDefaultArg()))
4122      ToParam->setUninstantiatedDefaultArg(*ToDefArgOrErr);
4123    else
4124      return ToDefArgOrErr.takeError();
4125  } else if (FromParam->hasUnparsedDefaultArg()) {
4126    ToParam->setUnparsedDefaultArg();
4127  } else if (FromParam->hasDefaultArg()) {
4128    if (auto ToDefArgOrErr = import(FromParam->getDefaultArg()))
4129      ToParam->setDefaultArg(*ToDefArgOrErr);
4130    else
4131      return ToDefArgOrErr.takeError();
4132  }
4133
4134  return Error::success();
4135}
4136
4137ExpectedDecl ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
4138  // Parameters are created in the translation unit's context, then moved
4139  // into the function declaration's context afterward.
4140  DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
4141
4142  Error Err = Error::success();
4143  auto ToDeclName = importChecked(Err, D->getDeclName());
4144  auto ToLocation = importChecked(Err, D->getLocation());
4145  auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4146  auto ToType = importChecked(Err, D->getType());
4147  auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4148  if (Err)
4149    return std::move(Err);
4150
4151  ParmVarDecl *ToParm;
4152  if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
4153                              ToInnerLocStart, ToLocation,
4154                              ToDeclName.getAsIdentifierInfo(), ToType,
4155                              ToTypeSourceInfo, D->getStorageClass(),
4156                              /*DefaultArg*/ nullptr))
4157    return ToParm;
4158
4159  // Set the default argument. It should be no problem if it was already done.
4160  // Do not import the default expression before GetImportedOrCreateDecl call
4161  // to avoid possible infinite import loop because circular dependency.
4162  if (Error Err = ImportDefaultArgOfParmVarDecl(D, ToParm))
4163    return std::move(Err);
4164
4165  if (D->isObjCMethodParameter()) {
4166    ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
4167    ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
4168  } else {
4169    ToParm->setScopeInfo(D->getFunctionScopeDepth(),
4170                         D->getFunctionScopeIndex());
4171  }
4172
4173  return ToParm;
4174}
4175
4176ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
4177  // Import the major distinguishing characteristics of a method.
4178  DeclContext *DC, *LexicalDC;
4179  DeclarationName Name;
4180  SourceLocation Loc;
4181  NamedDecl *ToD;
4182  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4183    return std::move(Err);
4184  if (ToD)
4185    return ToD;
4186
4187  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4188  for (auto *FoundDecl : FoundDecls) {
4189    if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
4190      if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
4191        continue;
4192
4193      // Check return types.
4194      if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
4195                                             FoundMethod->getReturnType())) {
4196        Importer.ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent)
4197            << D->isInstanceMethod() << Name << D->getReturnType()
4198            << FoundMethod->getReturnType();
4199        Importer.ToDiag(FoundMethod->getLocation(),
4200                        diag::note_odr_objc_method_here)
4201          << D->isInstanceMethod() << Name;
4202
4203        return make_error<ImportError>(ImportError::NameConflict);
4204      }
4205
4206      // Check the number of parameters.
4207      if (D->param_size() != FoundMethod->param_size()) {
4208        Importer.ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent)
4209          << D->isInstanceMethod() << Name
4210          << D->param_size() << FoundMethod->param_size();
4211        Importer.ToDiag(FoundMethod->getLocation(),
4212                        diag::note_odr_objc_method_here)
4213          << D->isInstanceMethod() << Name;
4214
4215        return make_error<ImportError>(ImportError::NameConflict);
4216      }
4217
4218      // Check parameter types.
4219      for (ObjCMethodDecl::param_iterator P = D->param_begin(),
4220             PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
4221           P != PEnd; ++P, ++FoundP) {
4222        if (!Importer.IsStructurallyEquivalent((*P)->getType(),
4223                                               (*FoundP)->getType())) {
4224          Importer.FromDiag((*P)->getLocation(),
4225                            diag::warn_odr_objc_method_param_type_inconsistent)
4226            << D->isInstanceMethod() << Name
4227            << (*P)->getType() << (*FoundP)->getType();
4228          Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4229            << (*FoundP)->getType();
4230
4231          return make_error<ImportError>(ImportError::NameConflict);
4232        }
4233      }
4234
4235      // Check variadic/non-variadic.
4236      // Check the number of parameters.
4237      if (D->isVariadic() != FoundMethod->isVariadic()) {
4238        Importer.ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent)
4239          << D->isInstanceMethod() << Name;
4240        Importer.ToDiag(FoundMethod->getLocation(),
4241                        diag::note_odr_objc_method_here)
4242          << D->isInstanceMethod() << Name;
4243
4244        return make_error<ImportError>(ImportError::NameConflict);
4245      }
4246
4247      // FIXME: Any other bits we need to merge?
4248      return Importer.MapImported(D, FoundMethod);
4249    }
4250  }
4251
4252  Error Err = Error::success();
4253  auto ToEndLoc = importChecked(Err, D->getEndLoc());
4254  auto ToReturnType = importChecked(Err, D->getReturnType());
4255  auto ToReturnTypeSourceInfo =
4256      importChecked(Err, D->getReturnTypeSourceInfo());
4257  if (Err)
4258    return std::move(Err);
4259
4260  ObjCMethodDecl *ToMethod;
4261  if (GetImportedOrCreateDecl(
4262          ToMethod, D, Importer.getToContext(), Loc, ToEndLoc,
4263          Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
4264          D->isInstanceMethod(), D->isVariadic(), D->isPropertyAccessor(),
4265          D->isSynthesizedAccessorStub(), D->isImplicit(), D->isDefined(),
4266          D->getImplementationControl(), D->hasRelatedResultType()))
4267    return ToMethod;
4268
4269  // FIXME: When we decide to merge method definitions, we'll need to
4270  // deal with implicit parameters.
4271
4272  // Import the parameters
4273  SmallVector<ParmVarDecl *, 5> ToParams;
4274  for (auto *FromP : D->parameters()) {
4275    if (Expected<ParmVarDecl *> ToPOrErr = import(FromP))
4276      ToParams.push_back(*ToPOrErr);
4277    else
4278      return ToPOrErr.takeError();
4279  }
4280
4281  // Set the parameters.
4282  for (auto *ToParam : ToParams) {
4283    ToParam->setOwningFunction(ToMethod);
4284    ToMethod->addDeclInternal(ToParam);
4285  }
4286
4287  SmallVector<SourceLocation, 12> FromSelLocs;
4288  D->getSelectorLocs(FromSelLocs);
4289  SmallVector<SourceLocation, 12> ToSelLocs(FromSelLocs.size());
4290  if (Error Err = ImportContainerChecked(FromSelLocs, ToSelLocs))
4291    return std::move(Err);
4292
4293  ToMethod->setMethodParams(Importer.getToContext(), ToParams, ToSelLocs);
4294
4295  ToMethod->setLexicalDeclContext(LexicalDC);
4296  LexicalDC->addDeclInternal(ToMethod);
4297
4298  // Implicit params are declared when Sema encounters the definition but this
4299  // never happens when the method is imported. Manually declare the implicit
4300  // params now that the MethodDecl knows its class interface.
4301  if (D->getSelfDecl())
4302    ToMethod->createImplicitParams(Importer.getToContext(),
4303                                   ToMethod->getClassInterface());
4304
4305  return ToMethod;
4306}
4307
4308ExpectedDecl ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
4309  // Import the major distinguishing characteristics of a category.
4310  DeclContext *DC, *LexicalDC;
4311  DeclarationName Name;
4312  SourceLocation Loc;
4313  NamedDecl *ToD;
4314  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4315    return std::move(Err);
4316  if (ToD)
4317    return ToD;
4318
4319  Error Err = Error::success();
4320  auto ToVarianceLoc = importChecked(Err, D->getVarianceLoc());
4321  auto ToLocation = importChecked(Err, D->getLocation());
4322  auto ToColonLoc = importChecked(Err, D->getColonLoc());
4323  auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4324  if (Err)
4325    return std::move(Err);
4326
4327  ObjCTypeParamDecl *Result;
4328  if (GetImportedOrCreateDecl(
4329          Result, D, Importer.getToContext(), DC, D->getVariance(),
4330          ToVarianceLoc, D->getIndex(),
4331          ToLocation, Name.getAsIdentifierInfo(),
4332          ToColonLoc, ToTypeSourceInfo))
4333    return Result;
4334
4335  Result->setLexicalDeclContext(LexicalDC);
4336  return Result;
4337}
4338
4339ExpectedDecl ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
4340  // Import the major distinguishing characteristics of a category.
4341  DeclContext *DC, *LexicalDC;
4342  DeclarationName Name;
4343  SourceLocation Loc;
4344  NamedDecl *ToD;
4345  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4346    return std::move(Err);
4347  if (ToD)
4348    return ToD;
4349
4350  ObjCInterfaceDecl *ToInterface;
4351  if (Error Err = importInto(ToInterface, D->getClassInterface()))
4352    return std::move(Err);
4353
4354  // Determine if we've already encountered this category.
4355  ObjCCategoryDecl *MergeWithCategory
4356    = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
4357  ObjCCategoryDecl *ToCategory = MergeWithCategory;
4358  if (!ToCategory) {
4359
4360    Error Err = Error::success();
4361    auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
4362    auto ToCategoryNameLoc = importChecked(Err, D->getCategoryNameLoc());
4363    auto ToIvarLBraceLoc = importChecked(Err, D->getIvarLBraceLoc());
4364    auto ToIvarRBraceLoc = importChecked(Err, D->getIvarRBraceLoc());
4365    if (Err)
4366      return std::move(Err);
4367
4368    if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
4369                                ToAtStartLoc, Loc,
4370                                ToCategoryNameLoc,
4371                                Name.getAsIdentifierInfo(), ToInterface,
4372                                /*TypeParamList=*/nullptr,
4373                                ToIvarLBraceLoc,
4374                                ToIvarRBraceLoc))
4375      return ToCategory;
4376
4377    ToCategory->setLexicalDeclContext(LexicalDC);
4378    LexicalDC->addDeclInternal(ToCategory);
4379    // Import the type parameter list after MapImported, to avoid
4380    // loops when bringing in their DeclContext.
4381    if (auto PListOrErr = ImportObjCTypeParamList(D->getTypeParamList()))
4382      ToCategory->setTypeParamList(*PListOrErr);
4383    else
4384      return PListOrErr.takeError();
4385
4386    // Import protocols
4387    SmallVector<ObjCProtocolDecl *, 4> Protocols;
4388    SmallVector<SourceLocation, 4> ProtocolLocs;
4389    ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
4390      = D->protocol_loc_begin();
4391    for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
4392                                          FromProtoEnd = D->protocol_end();
4393         FromProto != FromProtoEnd;
4394         ++FromProto, ++FromProtoLoc) {
4395      if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
4396        Protocols.push_back(*ToProtoOrErr);
4397      else
4398        return ToProtoOrErr.takeError();
4399
4400      if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
4401        ProtocolLocs.push_back(*ToProtoLocOrErr);
4402      else
4403        return ToProtoLocOrErr.takeError();
4404    }
4405
4406    // FIXME: If we're merging, make sure that the protocol list is the same.
4407    ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
4408                                ProtocolLocs.data(), Importer.getToContext());
4409
4410  } else {
4411    Importer.MapImported(D, ToCategory);
4412  }
4413
4414  // Import all of the members of this category.
4415  if (Error Err = ImportDeclContext(D))
4416    return std::move(Err);
4417
4418  // If we have an implementation, import it as well.
4419  if (D->getImplementation()) {
4420    if (Expected<ObjCCategoryImplDecl *> ToImplOrErr =
4421        import(D->getImplementation()))
4422      ToCategory->setImplementation(*ToImplOrErr);
4423    else
4424      return ToImplOrErr.takeError();
4425  }
4426
4427  return ToCategory;
4428}
4429
4430Error ASTNodeImporter::ImportDefinition(
4431    ObjCProtocolDecl *From, ObjCProtocolDecl *To, ImportDefinitionKind Kind) {
4432  if (To->getDefinition()) {
4433    if (shouldForceImportDeclContext(Kind))
4434      if (Error Err = ImportDeclContext(From))
4435        return Err;
4436    return Error::success();
4437  }
4438
4439  // Start the protocol definition
4440  To->startDefinition();
4441
4442  // Import protocols
4443  SmallVector<ObjCProtocolDecl *, 4> Protocols;
4444  SmallVector<SourceLocation, 4> ProtocolLocs;
4445  ObjCProtocolDecl::protocol_loc_iterator FromProtoLoc =
4446      From->protocol_loc_begin();
4447  for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
4448                                        FromProtoEnd = From->protocol_end();
4449       FromProto != FromProtoEnd;
4450       ++FromProto, ++FromProtoLoc) {
4451    if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
4452      Protocols.push_back(*ToProtoOrErr);
4453    else
4454      return ToProtoOrErr.takeError();
4455
4456    if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
4457      ProtocolLocs.push_back(*ToProtoLocOrErr);
4458    else
4459      return ToProtoLocOrErr.takeError();
4460
4461  }
4462
4463  // FIXME: If we're merging, make sure that the protocol list is the same.
4464  To->setProtocolList(Protocols.data(), Protocols.size(),
4465                      ProtocolLocs.data(), Importer.getToContext());
4466
4467  if (shouldForceImportDeclContext(Kind)) {
4468    // Import all of the members of this protocol.
4469    if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
4470      return Err;
4471  }
4472  return Error::success();
4473}
4474
4475ExpectedDecl ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
4476  // If this protocol has a definition in the translation unit we're coming
4477  // from, but this particular declaration is not that definition, import the
4478  // definition and map to that.
4479  ObjCProtocolDecl *Definition = D->getDefinition();
4480  if (Definition && Definition != D) {
4481    if (ExpectedDecl ImportedDefOrErr = import(Definition))
4482      return Importer.MapImported(D, *ImportedDefOrErr);
4483    else
4484      return ImportedDefOrErr.takeError();
4485  }
4486
4487  // Import the major distinguishing characteristics of a protocol.
4488  DeclContext *DC, *LexicalDC;
4489  DeclarationName Name;
4490  SourceLocation Loc;
4491  NamedDecl *ToD;
4492  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4493    return std::move(Err);
4494  if (ToD)
4495    return ToD;
4496
4497  ObjCProtocolDecl *MergeWithProtocol = nullptr;
4498  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4499  for (auto *FoundDecl : FoundDecls) {
4500    if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
4501      continue;
4502
4503    if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
4504      break;
4505  }
4506
4507  ObjCProtocolDecl *ToProto = MergeWithProtocol;
4508  if (!ToProto) {
4509    auto ToAtBeginLocOrErr = import(D->getAtStartLoc());
4510    if (!ToAtBeginLocOrErr)
4511      return ToAtBeginLocOrErr.takeError();
4512
4513    if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC,
4514                                Name.getAsIdentifierInfo(), Loc,
4515                                *ToAtBeginLocOrErr,
4516                                /*PrevDecl=*/nullptr))
4517      return ToProto;
4518    ToProto->setLexicalDeclContext(LexicalDC);
4519    LexicalDC->addDeclInternal(ToProto);
4520  }
4521
4522  Importer.MapImported(D, ToProto);
4523
4524  if (D->isThisDeclarationADefinition())
4525    if (Error Err = ImportDefinition(D, ToProto))
4526      return std::move(Err);
4527
4528  return ToProto;
4529}
4530
4531ExpectedDecl ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
4532  DeclContext *DC, *LexicalDC;
4533  if (Error Err = ImportDeclContext(D, DC, LexicalDC))
4534    return std::move(Err);
4535
4536  ExpectedSLoc ExternLocOrErr = import(D->getExternLoc());
4537  if (!ExternLocOrErr)
4538    return ExternLocOrErr.takeError();
4539
4540  ExpectedSLoc LangLocOrErr = import(D->getLocation());
4541  if (!LangLocOrErr)
4542    return LangLocOrErr.takeError();
4543
4544  bool HasBraces = D->hasBraces();
4545
4546  LinkageSpecDecl *ToLinkageSpec;
4547  if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC,
4548                              *ExternLocOrErr, *LangLocOrErr,
4549                              D->getLanguage(), HasBraces))
4550    return ToLinkageSpec;
4551
4552  if (HasBraces) {
4553    ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
4554    if (!RBraceLocOrErr)
4555      return RBraceLocOrErr.takeError();
4556    ToLinkageSpec->setRBraceLoc(*RBraceLocOrErr);
4557  }
4558
4559  ToLinkageSpec->setLexicalDeclContext(LexicalDC);
4560  LexicalDC->addDeclInternal(ToLinkageSpec);
4561
4562  return ToLinkageSpec;
4563}
4564
4565ExpectedDecl ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
4566  DeclContext *DC, *LexicalDC;
4567  DeclarationName Name;
4568  SourceLocation Loc;
4569  NamedDecl *ToD = nullptr;
4570  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4571    return std::move(Err);
4572  if (ToD)
4573    return ToD;
4574
4575  Error Err = Error::success();
4576  auto ToLoc = importChecked(Err, D->getNameInfo().getLoc());
4577  auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4578  auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4579  if (Err)
4580    return std::move(Err);
4581
4582  DeclarationNameInfo NameInfo(Name, ToLoc);
4583  if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
4584    return std::move(Err);
4585
4586  UsingDecl *ToUsing;
4587  if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
4588                              ToUsingLoc, ToQualifierLoc, NameInfo,
4589                              D->hasTypename()))
4590    return ToUsing;
4591
4592  ToUsing->setLexicalDeclContext(LexicalDC);
4593  LexicalDC->addDeclInternal(ToUsing);
4594
4595  if (NamedDecl *FromPattern =
4596      Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
4597    if (Expected<NamedDecl *> ToPatternOrErr = import(FromPattern))
4598      Importer.getToContext().setInstantiatedFromUsingDecl(
4599          ToUsing, *ToPatternOrErr);
4600    else
4601      return ToPatternOrErr.takeError();
4602  }
4603
4604  for (UsingShadowDecl *FromShadow : D->shadows()) {
4605    if (Expected<UsingShadowDecl *> ToShadowOrErr = import(FromShadow))
4606      ToUsing->addShadowDecl(*ToShadowOrErr);
4607    else
4608      // FIXME: We return error here but the definition is already created
4609      // and available with lookups. How to fix this?..
4610      return ToShadowOrErr.takeError();
4611  }
4612  return ToUsing;
4613}
4614
4615ExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
4616  DeclContext *DC, *LexicalDC;
4617  DeclarationName Name;
4618  SourceLocation Loc;
4619  NamedDecl *ToD = nullptr;
4620  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4621    return std::move(Err);
4622  if (ToD)
4623    return ToD;
4624
4625  Expected<UsingDecl *> ToUsingOrErr = import(D->getUsingDecl());
4626  if (!ToUsingOrErr)
4627    return ToUsingOrErr.takeError();
4628
4629  Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl());
4630  if (!ToTargetOrErr)
4631    return ToTargetOrErr.takeError();
4632
4633  UsingShadowDecl *ToShadow;
4634  if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
4635                              *ToUsingOrErr, *ToTargetOrErr))
4636    return ToShadow;
4637
4638  ToShadow->setLexicalDeclContext(LexicalDC);
4639  ToShadow->setAccess(D->getAccess());
4640
4641  if (UsingShadowDecl *FromPattern =
4642      Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
4643    if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern))
4644      Importer.getToContext().setInstantiatedFromUsingShadowDecl(
4645          ToShadow, *ToPatternOrErr);
4646    else
4647      // FIXME: We return error here but the definition is already created
4648      // and available with lookups. How to fix this?..
4649      return ToPatternOrErr.takeError();
4650  }
4651
4652  LexicalDC->addDeclInternal(ToShadow);
4653
4654  return ToShadow;
4655}
4656
4657ExpectedDecl ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
4658  DeclContext *DC, *LexicalDC;
4659  DeclarationName Name;
4660  SourceLocation Loc;
4661  NamedDecl *ToD = nullptr;
4662  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4663    return std::move(Err);
4664  if (ToD)
4665    return ToD;
4666
4667  auto ToComAncestorOrErr = Importer.ImportContext(D->getCommonAncestor());
4668  if (!ToComAncestorOrErr)
4669    return ToComAncestorOrErr.takeError();
4670
4671  Error Err = Error::success();
4672  auto ToNominatedNamespace = importChecked(Err, D->getNominatedNamespace());
4673  auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4674  auto ToNamespaceKeyLocation =
4675      importChecked(Err, D->getNamespaceKeyLocation());
4676  auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4677  auto ToIdentLocation = importChecked(Err, D->getIdentLocation());
4678  if (Err)
4679    return std::move(Err);
4680
4681  UsingDirectiveDecl *ToUsingDir;
4682  if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
4683                              ToUsingLoc,
4684                              ToNamespaceKeyLocation,
4685                              ToQualifierLoc,
4686                              ToIdentLocation,
4687                              ToNominatedNamespace, *ToComAncestorOrErr))
4688    return ToUsingDir;
4689
4690  ToUsingDir->setLexicalDeclContext(LexicalDC);
4691  LexicalDC->addDeclInternal(ToUsingDir);
4692
4693  return ToUsingDir;
4694}
4695
4696ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingValueDecl(
4697    UnresolvedUsingValueDecl *D) {
4698  DeclContext *DC, *LexicalDC;
4699  DeclarationName Name;
4700  SourceLocation Loc;
4701  NamedDecl *ToD = nullptr;
4702  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4703    return std::move(Err);
4704  if (ToD)
4705    return ToD;
4706
4707  Error Err = Error::success();
4708  auto ToLoc = importChecked(Err, D->getNameInfo().getLoc());
4709  auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4710  auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4711  auto ToEllipsisLoc = importChecked(Err, D->getEllipsisLoc());
4712  if (Err)
4713    return std::move(Err);
4714
4715  DeclarationNameInfo NameInfo(Name, ToLoc);
4716  if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
4717    return std::move(Err);
4718
4719  UnresolvedUsingValueDecl *ToUsingValue;
4720  if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
4721                              ToUsingLoc, ToQualifierLoc, NameInfo,
4722                              ToEllipsisLoc))
4723    return ToUsingValue;
4724
4725  ToUsingValue->setAccess(D->getAccess());
4726  ToUsingValue->setLexicalDeclContext(LexicalDC);
4727  LexicalDC->addDeclInternal(ToUsingValue);
4728
4729  return ToUsingValue;
4730}
4731
4732ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
4733    UnresolvedUsingTypenameDecl *D) {
4734  DeclContext *DC, *LexicalDC;
4735  DeclarationName Name;
4736  SourceLocation Loc;
4737  NamedDecl *ToD = nullptr;
4738  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4739    return std::move(Err);
4740  if (ToD)
4741    return ToD;
4742
4743  Error Err = Error::success();
4744  auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4745  auto ToTypenameLoc = importChecked(Err, D->getTypenameLoc());
4746  auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4747  auto ToEllipsisLoc = importChecked(Err, D->getEllipsisLoc());
4748  if (Err)
4749    return std::move(Err);
4750
4751  UnresolvedUsingTypenameDecl *ToUsing;
4752  if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
4753                              ToUsingLoc, ToTypenameLoc,
4754                              ToQualifierLoc, Loc, Name, ToEllipsisLoc))
4755    return ToUsing;
4756
4757  ToUsing->setAccess(D->getAccess());
4758  ToUsing->setLexicalDeclContext(LexicalDC);
4759  LexicalDC->addDeclInternal(ToUsing);
4760
4761  return ToUsing;
4762}
4763
4764ExpectedDecl ASTNodeImporter::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
4765  Decl* ToD = nullptr;
4766  switch (D->getBuiltinTemplateKind()) {
4767  case BuiltinTemplateKind::BTK__make_integer_seq:
4768    ToD = Importer.getToContext().getMakeIntegerSeqDecl();
4769    break;
4770  case BuiltinTemplateKind::BTK__type_pack_element:
4771    ToD = Importer.getToContext().getTypePackElementDecl();
4772    break;
4773  }
4774  assert(ToD && "BuiltinTemplateDecl of unsupported kind!");
4775  Importer.MapImported(D, ToD);
4776  return ToD;
4777}
4778
4779Error ASTNodeImporter::ImportDefinition(
4780    ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) {
4781  if (To->getDefinition()) {
4782    // Check consistency of superclass.
4783    ObjCInterfaceDecl *FromSuper = From->getSuperClass();
4784    if (FromSuper) {
4785      if (auto FromSuperOrErr = import(FromSuper))
4786        FromSuper = *FromSuperOrErr;
4787      else
4788        return FromSuperOrErr.takeError();
4789    }
4790
4791    ObjCInterfaceDecl *ToSuper = To->getSuperClass();
4792    if ((bool)FromSuper != (bool)ToSuper ||
4793        (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
4794      Importer.ToDiag(To->getLocation(),
4795                      diag::warn_odr_objc_superclass_inconsistent)
4796        << To->getDeclName();
4797      if (ToSuper)
4798        Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
4799          << To->getSuperClass()->getDeclName();
4800      else
4801        Importer.ToDiag(To->getLocation(),
4802                        diag::note_odr_objc_missing_superclass);
4803      if (From->getSuperClass())
4804        Importer.FromDiag(From->getSuperClassLoc(),
4805                          diag::note_odr_objc_superclass)
4806        << From->getSuperClass()->getDeclName();
4807      else
4808        Importer.FromDiag(From->getLocation(),
4809                          diag::note_odr_objc_missing_superclass);
4810    }
4811
4812    if (shouldForceImportDeclContext(Kind))
4813      if (Error Err = ImportDeclContext(From))
4814        return Err;
4815    return Error::success();
4816  }
4817
4818  // Start the definition.
4819  To->startDefinition();
4820
4821  // If this class has a superclass, import it.
4822  if (From->getSuperClass()) {
4823    if (auto SuperTInfoOrErr = import(From->getSuperClassTInfo()))
4824      To->setSuperClass(*SuperTInfoOrErr);
4825    else
4826      return SuperTInfoOrErr.takeError();
4827  }
4828
4829  // Import protocols
4830  SmallVector<ObjCProtocolDecl *, 4> Protocols;
4831  SmallVector<SourceLocation, 4> ProtocolLocs;
4832  ObjCInterfaceDecl::protocol_loc_iterator FromProtoLoc =
4833      From->protocol_loc_begin();
4834
4835  for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
4836                                         FromProtoEnd = From->protocol_end();
4837       FromProto != FromProtoEnd;
4838       ++FromProto, ++FromProtoLoc) {
4839    if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
4840      Protocols.push_back(*ToProtoOrErr);
4841    else
4842      return ToProtoOrErr.takeError();
4843
4844    if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
4845      ProtocolLocs.push_back(*ToProtoLocOrErr);
4846    else
4847      return ToProtoLocOrErr.takeError();
4848
4849  }
4850
4851  // FIXME: If we're merging, make sure that the protocol list is the same.
4852  To->setProtocolList(Protocols.data(), Protocols.size(),
4853                      ProtocolLocs.data(), Importer.getToContext());
4854
4855  // Import categories. When the categories themselves are imported, they'll
4856  // hook themselves into this interface.
4857  for (auto *Cat : From->known_categories()) {
4858    auto ToCatOrErr = import(Cat);
4859    if (!ToCatOrErr)
4860      return ToCatOrErr.takeError();
4861  }
4862
4863  // If we have an @implementation, import it as well.
4864  if (From->getImplementation()) {
4865    if (Expected<ObjCImplementationDecl *> ToImplOrErr =
4866        import(From->getImplementation()))
4867      To->setImplementation(*ToImplOrErr);
4868    else
4869      return ToImplOrErr.takeError();
4870  }
4871
4872  // Import all of the members of this class.
4873  if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
4874    return Err;
4875
4876  return Error::success();
4877}
4878
4879Expected<ObjCTypeParamList *>
4880ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
4881  if (!list)
4882    return nullptr;
4883
4884  SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
4885  for (auto *fromTypeParam : *list) {
4886    if (auto toTypeParamOrErr = import(fromTypeParam))
4887      toTypeParams.push_back(*toTypeParamOrErr);
4888    else
4889      return toTypeParamOrErr.takeError();
4890  }
4891
4892  auto LAngleLocOrErr = import(list->getLAngleLoc());
4893  if (!LAngleLocOrErr)
4894    return LAngleLocOrErr.takeError();
4895
4896  auto RAngleLocOrErr = import(list->getRAngleLoc());
4897  if (!RAngleLocOrErr)
4898    return RAngleLocOrErr.takeError();
4899
4900  return ObjCTypeParamList::create(Importer.getToContext(),
4901                                   *LAngleLocOrErr,
4902                                   toTypeParams,
4903                                   *RAngleLocOrErr);
4904}
4905
4906ExpectedDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
4907  // If this class has a definition in the translation unit we're coming from,
4908  // but this particular declaration is not that definition, import the
4909  // definition and map to that.
4910  ObjCInterfaceDecl *Definition = D->getDefinition();
4911  if (Definition && Definition != D) {
4912    if (ExpectedDecl ImportedDefOrErr = import(Definition))
4913      return Importer.MapImported(D, *ImportedDefOrErr);
4914    else
4915      return ImportedDefOrErr.takeError();
4916  }
4917
4918  // Import the major distinguishing characteristics of an @interface.
4919  DeclContext *DC, *LexicalDC;
4920  DeclarationName Name;
4921  SourceLocation Loc;
4922  NamedDecl *ToD;
4923  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4924    return std::move(Err);
4925  if (ToD)
4926    return ToD;
4927
4928  // Look for an existing interface with the same name.
4929  ObjCInterfaceDecl *MergeWithIface = nullptr;
4930  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4931  for (auto *FoundDecl : FoundDecls) {
4932    if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4933      continue;
4934
4935    if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
4936      break;
4937  }
4938
4939  // Create an interface declaration, if one does not already exist.
4940  ObjCInterfaceDecl *ToIface = MergeWithIface;
4941  if (!ToIface) {
4942    ExpectedSLoc AtBeginLocOrErr = import(D->getAtStartLoc());
4943    if (!AtBeginLocOrErr)
4944      return AtBeginLocOrErr.takeError();
4945
4946    if (GetImportedOrCreateDecl(
4947            ToIface, D, Importer.getToContext(), DC,
4948            *AtBeginLocOrErr, Name.getAsIdentifierInfo(),
4949            /*TypeParamList=*/nullptr,
4950            /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl()))
4951      return ToIface;
4952    ToIface->setLexicalDeclContext(LexicalDC);
4953    LexicalDC->addDeclInternal(ToIface);
4954  }
4955  Importer.MapImported(D, ToIface);
4956  // Import the type parameter list after MapImported, to avoid
4957  // loops when bringing in their DeclContext.
4958  if (auto ToPListOrErr =
4959      ImportObjCTypeParamList(D->getTypeParamListAsWritten()))
4960    ToIface->setTypeParamList(*ToPListOrErr);
4961  else
4962    return ToPListOrErr.takeError();
4963
4964  if (D->isThisDeclarationADefinition())
4965    if (Error Err = ImportDefinition(D, ToIface))
4966      return std::move(Err);
4967
4968  return ToIface;
4969}
4970
4971ExpectedDecl
4972ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
4973  ObjCCategoryDecl *Category;
4974  if (Error Err = importInto(Category, D->getCategoryDecl()))
4975    return std::move(Err);
4976
4977  ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4978  if (!ToImpl) {
4979    DeclContext *DC, *LexicalDC;
4980    if (Error Err = ImportDeclContext(D, DC, LexicalDC))
4981      return std::move(Err);
4982
4983    Error Err = Error::success();
4984    auto ToLocation = importChecked(Err, D->getLocation());
4985    auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
4986    auto ToCategoryNameLoc = importChecked(Err, D->getCategoryNameLoc());
4987    if (Err)
4988      return std::move(Err);
4989
4990    if (GetImportedOrCreateDecl(
4991            ToImpl, D, Importer.getToContext(), DC,
4992            Importer.Import(D->getIdentifier()), Category->getClassInterface(),
4993            ToLocation, ToAtStartLoc, ToCategoryNameLoc))
4994      return ToImpl;
4995
4996    ToImpl->setLexicalDeclContext(LexicalDC);
4997    LexicalDC->addDeclInternal(ToImpl);
4998    Category->setImplementation(ToImpl);
4999  }
5000
5001  Importer.MapImported(D, ToImpl);
5002  if (Error Err = ImportDeclContext(D))
5003    return std::move(Err);
5004
5005  return ToImpl;
5006}
5007
5008ExpectedDecl
5009ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
5010  // Find the corresponding interface.
5011  ObjCInterfaceDecl *Iface;
5012  if (Error Err = importInto(Iface, D->getClassInterface()))
5013    return std::move(Err);
5014
5015  // Import the superclass, if any.
5016  ObjCInterfaceDecl *Super;
5017  if (Error Err = importInto(Super, D->getSuperClass()))
5018    return std::move(Err);
5019
5020  ObjCImplementationDecl *Impl = Iface->getImplementation();
5021  if (!Impl) {
5022    // We haven't imported an implementation yet. Create a new @implementation
5023    // now.
5024    DeclContext *DC, *LexicalDC;
5025    if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5026      return std::move(Err);
5027
5028    Error Err = Error::success();
5029    auto ToLocation = importChecked(Err, D->getLocation());
5030    auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
5031    auto ToSuperClassLoc = importChecked(Err, D->getSuperClassLoc());
5032    auto ToIvarLBraceLoc = importChecked(Err, D->getIvarLBraceLoc());
5033    auto ToIvarRBraceLoc = importChecked(Err, D->getIvarRBraceLoc());
5034    if (Err)
5035      return std::move(Err);
5036
5037    if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
5038                                DC, Iface, Super,
5039                                ToLocation,
5040                                ToAtStartLoc,
5041                                ToSuperClassLoc,
5042                                ToIvarLBraceLoc,
5043                                ToIvarRBraceLoc))
5044      return Impl;
5045
5046    Impl->setLexicalDeclContext(LexicalDC);
5047
5048    // Associate the implementation with the class it implements.
5049    Iface->setImplementation(Impl);
5050    Importer.MapImported(D, Iface->getImplementation());
5051  } else {
5052    Importer.MapImported(D, Iface->getImplementation());
5053
5054    // Verify that the existing @implementation has the same superclass.
5055    if ((Super && !Impl->getSuperClass()) ||
5056        (!Super && Impl->getSuperClass()) ||
5057        (Super && Impl->getSuperClass() &&
5058         !declaresSameEntity(Super->getCanonicalDecl(),
5059                             Impl->getSuperClass()))) {
5060      Importer.ToDiag(Impl->getLocation(),
5061                      diag::warn_odr_objc_superclass_inconsistent)
5062        << Iface->getDeclName();
5063      // FIXME: It would be nice to have the location of the superclass
5064      // below.
5065      if (Impl->getSuperClass())
5066        Importer.ToDiag(Impl->getLocation(),
5067                        diag::note_odr_objc_superclass)
5068        << Impl->getSuperClass()->getDeclName();
5069      else
5070        Importer.ToDiag(Impl->getLocation(),
5071                        diag::note_odr_objc_missing_superclass);
5072      if (D->getSuperClass())
5073        Importer.FromDiag(D->getLocation(),
5074                          diag::note_odr_objc_superclass)
5075        << D->getSuperClass()->getDeclName();
5076      else
5077        Importer.FromDiag(D->getLocation(),
5078                          diag::note_odr_objc_missing_superclass);
5079
5080      return make_error<ImportError>(ImportError::NameConflict);
5081    }
5082  }
5083
5084  // Import all of the members of this @implementation.
5085  if (Error Err = ImportDeclContext(D))
5086    return std::move(Err);
5087
5088  return Impl;
5089}
5090
5091ExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
5092  // Import the major distinguishing characteristics of an @property.
5093  DeclContext *DC, *LexicalDC;
5094  DeclarationName Name;
5095  SourceLocation Loc;
5096  NamedDecl *ToD;
5097  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5098    return std::move(Err);
5099  if (ToD)
5100    return ToD;
5101
5102  // Check whether we have already imported this property.
5103  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5104  for (auto *FoundDecl : FoundDecls) {
5105    if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
5106      // Instance and class properties can share the same name but are different
5107      // declarations.
5108      if (FoundProp->isInstanceProperty() != D->isInstanceProperty())
5109        continue;
5110
5111      // Check property types.
5112      if (!Importer.IsStructurallyEquivalent(D->getType(),
5113                                             FoundProp->getType())) {
5114        Importer.ToDiag(Loc, diag::warn_odr_objc_property_type_inconsistent)
5115          << Name << D->getType() << FoundProp->getType();
5116        Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
5117          << FoundProp->getType();
5118
5119        return make_error<ImportError>(ImportError::NameConflict);
5120      }
5121
5122      // FIXME: Check property attributes, getters, setters, etc.?
5123
5124      // Consider these properties to be equivalent.
5125      Importer.MapImported(D, FoundProp);
5126      return FoundProp;
5127    }
5128  }
5129
5130  Error Err = Error::success();
5131  auto ToType = importChecked(Err, D->getType());
5132  auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
5133  auto ToAtLoc = importChecked(Err, D->getAtLoc());
5134  auto ToLParenLoc = importChecked(Err, D->getLParenLoc());
5135  if (Err)
5136    return std::move(Err);
5137
5138  // Create the new property.
5139  ObjCPropertyDecl *ToProperty;
5140  if (GetImportedOrCreateDecl(
5141          ToProperty, D, Importer.getToContext(), DC, Loc,
5142          Name.getAsIdentifierInfo(), ToAtLoc,
5143          ToLParenLoc, ToType,
5144          ToTypeSourceInfo, D->getPropertyImplementation()))
5145    return ToProperty;
5146
5147  auto ToGetterName = importChecked(Err, D->getGetterName());
5148  auto ToSetterName = importChecked(Err, D->getSetterName());
5149  auto ToGetterNameLoc = importChecked(Err, D->getGetterNameLoc());
5150  auto ToSetterNameLoc = importChecked(Err, D->getSetterNameLoc());
5151  auto ToGetterMethodDecl = importChecked(Err, D->getGetterMethodDecl());
5152  auto ToSetterMethodDecl = importChecked(Err, D->getSetterMethodDecl());
5153  auto ToPropertyIvarDecl = importChecked(Err, D->getPropertyIvarDecl());
5154  if (Err)
5155    return std::move(Err);
5156
5157  ToProperty->setLexicalDeclContext(LexicalDC);
5158  LexicalDC->addDeclInternal(ToProperty);
5159
5160  ToProperty->setPropertyAttributes(D->getPropertyAttributes());
5161  ToProperty->setPropertyAttributesAsWritten(
5162                                      D->getPropertyAttributesAsWritten());
5163  ToProperty->setGetterName(ToGetterName, ToGetterNameLoc);
5164  ToProperty->setSetterName(ToSetterName, ToSetterNameLoc);
5165  ToProperty->setGetterMethodDecl(ToGetterMethodDecl);
5166  ToProperty->setSetterMethodDecl(ToSetterMethodDecl);
5167  ToProperty->setPropertyIvarDecl(ToPropertyIvarDecl);
5168  return ToProperty;
5169}
5170
5171ExpectedDecl
5172ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
5173  ObjCPropertyDecl *Property;
5174  if (Error Err = importInto(Property, D->getPropertyDecl()))
5175    return std::move(Err);
5176
5177  DeclContext *DC, *LexicalDC;
5178  if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5179    return std::move(Err);
5180
5181  auto *InImpl = cast<ObjCImplDecl>(LexicalDC);
5182
5183  // Import the ivar (for an @synthesize).
5184  ObjCIvarDecl *Ivar = nullptr;
5185  if (Error Err = importInto(Ivar, D->getPropertyIvarDecl()))
5186    return std::move(Err);
5187
5188  ObjCPropertyImplDecl *ToImpl
5189    = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
5190                                   Property->getQueryKind());
5191  if (!ToImpl) {
5192
5193    Error Err = Error::success();
5194    auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
5195    auto ToLocation = importChecked(Err, D->getLocation());
5196    auto ToPropertyIvarDeclLoc =
5197        importChecked(Err, D->getPropertyIvarDeclLoc());
5198    if (Err)
5199      return std::move(Err);
5200
5201    if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
5202                                ToBeginLoc,
5203                                ToLocation, Property,
5204                                D->getPropertyImplementation(), Ivar,
5205                                ToPropertyIvarDeclLoc))
5206      return ToImpl;
5207
5208    ToImpl->setLexicalDeclContext(LexicalDC);
5209    LexicalDC->addDeclInternal(ToImpl);
5210  } else {
5211    // Check that we have the same kind of property implementation (@synthesize
5212    // vs. @dynamic).
5213    if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
5214      Importer.ToDiag(ToImpl->getLocation(),
5215                      diag::warn_odr_objc_property_impl_kind_inconsistent)
5216        << Property->getDeclName()
5217        << (ToImpl->getPropertyImplementation()
5218                                              == ObjCPropertyImplDecl::Dynamic);
5219      Importer.FromDiag(D->getLocation(),
5220                        diag::note_odr_objc_property_impl_kind)
5221        << D->getPropertyDecl()->getDeclName()
5222        << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
5223
5224      return make_error<ImportError>(ImportError::NameConflict);
5225    }
5226
5227    // For @synthesize, check that we have the same
5228    if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
5229        Ivar != ToImpl->getPropertyIvarDecl()) {
5230      Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
5231                      diag::warn_odr_objc_synthesize_ivar_inconsistent)
5232        << Property->getDeclName()
5233        << ToImpl->getPropertyIvarDecl()->getDeclName()
5234        << Ivar->getDeclName();
5235      Importer.FromDiag(D->getPropertyIvarDeclLoc(),
5236                        diag::note_odr_objc_synthesize_ivar_here)
5237        << D->getPropertyIvarDecl()->getDeclName();
5238
5239      return make_error<ImportError>(ImportError::NameConflict);
5240    }
5241
5242    // Merge the existing implementation with the new implementation.
5243    Importer.MapImported(D, ToImpl);
5244  }
5245
5246  return ToImpl;
5247}
5248
5249ExpectedDecl
5250ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
5251  // For template arguments, we adopt the translation unit as our declaration
5252  // context. This context will be fixed when the actual template declaration
5253  // is created.
5254
5255  ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5256  if (!BeginLocOrErr)
5257    return BeginLocOrErr.takeError();
5258
5259  ExpectedSLoc LocationOrErr = import(D->getLocation());
5260  if (!LocationOrErr)
5261    return LocationOrErr.takeError();
5262
5263  TemplateTypeParmDecl *ToD = nullptr;
5264  if (GetImportedOrCreateDecl(
5265      ToD, D, Importer.getToContext(),
5266      Importer.getToContext().getTranslationUnitDecl(),
5267      *BeginLocOrErr, *LocationOrErr,
5268      D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
5269      D->wasDeclaredWithTypename(), D->isParameterPack(),
5270      D->hasTypeConstraint()))
5271    return ToD;
5272
5273  // Import the type-constraint
5274  if (const TypeConstraint *TC = D->getTypeConstraint()) {
5275
5276    Error Err = Error::success();
5277    auto ToNNS = importChecked(Err, TC->getNestedNameSpecifierLoc());
5278    auto ToName = importChecked(Err, TC->getConceptNameInfo().getName());
5279    auto ToNameLoc = importChecked(Err, TC->getConceptNameInfo().getLoc());
5280    auto ToFoundDecl = importChecked(Err, TC->getFoundDecl());
5281    auto ToNamedConcept = importChecked(Err, TC->getNamedConcept());
5282    auto ToIDC = importChecked(Err, TC->getImmediatelyDeclaredConstraint());
5283    if (Err)
5284      return std::move(Err);
5285
5286    TemplateArgumentListInfo ToTAInfo;
5287    const auto *ASTTemplateArgs = TC->getTemplateArgsAsWritten();
5288    if (ASTTemplateArgs)
5289      if (Error Err = ImportTemplateArgumentListInfo(*ASTTemplateArgs,
5290                                                     ToTAInfo))
5291        return std::move(Err);
5292
5293    ToD->setTypeConstraint(ToNNS, DeclarationNameInfo(ToName, ToNameLoc),
5294        ToFoundDecl, ToNamedConcept,
5295        ASTTemplateArgs ?
5296            ASTTemplateArgumentListInfo::Create(Importer.getToContext(),
5297                                                ToTAInfo) : nullptr,
5298        ToIDC);
5299  }
5300
5301  if (D->hasDefaultArgument()) {
5302    Expected<TypeSourceInfo *> ToDefaultArgOrErr =
5303        import(D->getDefaultArgumentInfo());
5304    if (!ToDefaultArgOrErr)
5305      return ToDefaultArgOrErr.takeError();
5306    ToD->setDefaultArgument(*ToDefaultArgOrErr);
5307  }
5308
5309  return ToD;
5310}
5311
5312ExpectedDecl
5313ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
5314
5315  Error Err = Error::success();
5316  auto ToDeclName = importChecked(Err, D->getDeclName());
5317  auto ToLocation = importChecked(Err, D->getLocation());
5318  auto ToType = importChecked(Err, D->getType());
5319  auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
5320  auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
5321  if (Err)
5322    return std::move(Err);
5323
5324  NonTypeTemplateParmDecl *ToD = nullptr;
5325  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(),
5326                              Importer.getToContext().getTranslationUnitDecl(),
5327                              ToInnerLocStart, ToLocation, D->getDepth(),
5328                              D->getPosition(),
5329                              ToDeclName.getAsIdentifierInfo(), ToType,
5330                              D->isParameterPack(), ToTypeSourceInfo))
5331    return ToD;
5332
5333  if (D->hasDefaultArgument()) {
5334    ExpectedExpr ToDefaultArgOrErr = import(D->getDefaultArgument());
5335    if (!ToDefaultArgOrErr)
5336      return ToDefaultArgOrErr.takeError();
5337    ToD->setDefaultArgument(*ToDefaultArgOrErr);
5338  }
5339
5340  return ToD;
5341}
5342
5343ExpectedDecl
5344ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
5345  // Import the name of this declaration.
5346  auto NameOrErr = import(D->getDeclName());
5347  if (!NameOrErr)
5348    return NameOrErr.takeError();
5349
5350  // Import the location of this declaration.
5351  ExpectedSLoc LocationOrErr = import(D->getLocation());
5352  if (!LocationOrErr)
5353    return LocationOrErr.takeError();
5354
5355  // Import template parameters.
5356  auto TemplateParamsOrErr = import(D->getTemplateParameters());
5357  if (!TemplateParamsOrErr)
5358    return TemplateParamsOrErr.takeError();
5359
5360  TemplateTemplateParmDecl *ToD = nullptr;
5361  if (GetImportedOrCreateDecl(
5362          ToD, D, Importer.getToContext(),
5363          Importer.getToContext().getTranslationUnitDecl(), *LocationOrErr,
5364          D->getDepth(), D->getPosition(), D->isParameterPack(),
5365          (*NameOrErr).getAsIdentifierInfo(), *TemplateParamsOrErr))
5366    return ToD;
5367
5368  if (D->hasDefaultArgument()) {
5369    Expected<TemplateArgumentLoc> ToDefaultArgOrErr =
5370        import(D->getDefaultArgument());
5371    if (!ToDefaultArgOrErr)
5372      return ToDefaultArgOrErr.takeError();
5373    ToD->setDefaultArgument(Importer.getToContext(), *ToDefaultArgOrErr);
5374  }
5375
5376  return ToD;
5377}
5378
5379// Returns the definition for a (forward) declaration of a TemplateDecl, if
5380// it has any definition in the redecl chain.
5381template <typename T> static auto getTemplateDefinition(T *D) -> T * {
5382  assert(D->getTemplatedDecl() && "Should be called on templates only");
5383  auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
5384  if (!ToTemplatedDef)
5385    return nullptr;
5386  auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate();
5387  return cast_or_null<T>(TemplateWithDef);
5388}
5389
5390ExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
5391
5392  // Import the major distinguishing characteristics of this class template.
5393  DeclContext *DC, *LexicalDC;
5394  DeclarationName Name;
5395  SourceLocation Loc;
5396  NamedDecl *ToD;
5397  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5398    return std::move(Err);
5399  if (ToD)
5400    return ToD;
5401
5402  ClassTemplateDecl *FoundByLookup = nullptr;
5403
5404  // We may already have a template of the same name; try to find and match it.
5405  if (!DC->isFunctionOrMethod()) {
5406    SmallVector<NamedDecl *, 4> ConflictingDecls;
5407    auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5408    for (auto *FoundDecl : FoundDecls) {
5409      if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary |
5410                                              Decl::IDNS_TagFriend))
5411        continue;
5412
5413      Decl *Found = FoundDecl;
5414      auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found);
5415      if (FoundTemplate) {
5416        if (!hasSameVisibilityContextAndLinkage(FoundTemplate, D))
5417          continue;
5418
5419        if (IsStructuralMatch(D, FoundTemplate)) {
5420          ClassTemplateDecl *TemplateWithDef =
5421              getTemplateDefinition(FoundTemplate);
5422          if (D->isThisDeclarationADefinition() && TemplateWithDef)
5423            return Importer.MapImported(D, TemplateWithDef);
5424          if (!FoundByLookup)
5425            FoundByLookup = FoundTemplate;
5426          // Search in all matches because there may be multiple decl chains,
5427          // see ASTTests test ImportExistingFriendClassTemplateDef.
5428          continue;
5429        }
5430        ConflictingDecls.push_back(FoundDecl);
5431      }
5432    }
5433
5434    if (!ConflictingDecls.empty()) {
5435      ExpectedName NameOrErr = Importer.HandleNameConflict(
5436          Name, DC, Decl::IDNS_Ordinary, ConflictingDecls.data(),
5437          ConflictingDecls.size());
5438      if (NameOrErr)
5439        Name = NameOrErr.get();
5440      else
5441        return NameOrErr.takeError();
5442    }
5443  }
5444
5445  CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
5446
5447  auto TemplateParamsOrErr = import(D->getTemplateParameters());
5448  if (!TemplateParamsOrErr)
5449    return TemplateParamsOrErr.takeError();
5450
5451  // Create the declaration that is being templated.
5452  CXXRecordDecl *ToTemplated;
5453  if (Error Err = importInto(ToTemplated, FromTemplated))
5454    return std::move(Err);
5455
5456  // Create the class template declaration itself.
5457  ClassTemplateDecl *D2;
5458  if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
5459                              *TemplateParamsOrErr, ToTemplated))
5460    return D2;
5461
5462  ToTemplated->setDescribedClassTemplate(D2);
5463
5464  D2->setAccess(D->getAccess());
5465  D2->setLexicalDeclContext(LexicalDC);
5466
5467  addDeclToContexts(D, D2);
5468
5469  if (FoundByLookup) {
5470    auto *Recent =
5471        const_cast<ClassTemplateDecl *>(FoundByLookup->getMostRecentDecl());
5472
5473    // It is possible that during the import of the class template definition
5474    // we start the import of a fwd friend decl of the very same class template
5475    // and we add the fwd friend decl to the lookup table. But the ToTemplated
5476    // had been created earlier and by that time the lookup could not find
5477    // anything existing, so it has no previous decl. Later, (still during the
5478    // import of the fwd friend decl) we start to import the definition again
5479    // and this time the lookup finds the previous fwd friend class template.
5480    // In this case we must set up the previous decl for the templated decl.
5481    if (!ToTemplated->getPreviousDecl()) {
5482      assert(FoundByLookup->getTemplatedDecl() &&
5483             "Found decl must have its templated decl set");
5484      CXXRecordDecl *PrevTemplated =
5485          FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
5486      if (ToTemplated != PrevTemplated)
5487        ToTemplated->setPreviousDecl(PrevTemplated);
5488    }
5489
5490    D2->setPreviousDecl(Recent);
5491  }
5492
5493  if (FromTemplated->isCompleteDefinition() &&
5494      !ToTemplated->isCompleteDefinition()) {
5495    // FIXME: Import definition!
5496  }
5497
5498  return D2;
5499}
5500
5501ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
5502                                          ClassTemplateSpecializationDecl *D) {
5503  ClassTemplateDecl *ClassTemplate;
5504  if (Error Err = importInto(ClassTemplate, D->getSpecializedTemplate()))
5505    return std::move(Err);
5506
5507  // Import the context of this declaration.
5508  DeclContext *DC, *LexicalDC;
5509  if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5510    return std::move(Err);
5511
5512  // Import template arguments.
5513  SmallVector<TemplateArgument, 2> TemplateArgs;
5514  if (Error Err = ImportTemplateArguments(
5515      D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
5516    return std::move(Err);
5517  // Try to find an existing specialization with these template arguments and
5518  // template parameter list.
5519  void *InsertPos = nullptr;
5520  ClassTemplateSpecializationDecl *PrevDecl = nullptr;
5521  ClassTemplatePartialSpecializationDecl *PartialSpec =
5522            dyn_cast<ClassTemplatePartialSpecializationDecl>(D);
5523
5524  // Import template parameters.
5525  TemplateParameterList *ToTPList = nullptr;
5526
5527  if (PartialSpec) {
5528    auto ToTPListOrErr = import(PartialSpec->getTemplateParameters());
5529    if (!ToTPListOrErr)
5530      return ToTPListOrErr.takeError();
5531    ToTPList = *ToTPListOrErr;
5532    PrevDecl = ClassTemplate->findPartialSpecialization(TemplateArgs,
5533                                                        *ToTPListOrErr,
5534                                                        InsertPos);
5535  } else
5536    PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
5537
5538  if (PrevDecl) {
5539    if (IsStructuralMatch(D, PrevDecl)) {
5540      CXXRecordDecl *PrevDefinition = PrevDecl->getDefinition();
5541      if (D->isThisDeclarationADefinition() && PrevDefinition) {
5542        Importer.MapImported(D, PrevDefinition);
5543        // Import those default field initializers which have been
5544        // instantiated in the "From" context, but not in the "To" context.
5545        for (auto *FromField : D->fields()) {
5546          auto ToOrErr = import(FromField);
5547          if (!ToOrErr)
5548            return ToOrErr.takeError();
5549        }
5550
5551        // Import those methods which have been instantiated in the
5552        // "From" context, but not in the "To" context.
5553        for (CXXMethodDecl *FromM : D->methods()) {
5554          auto ToOrErr = import(FromM);
5555          if (!ToOrErr)
5556            return ToOrErr.takeError();
5557        }
5558
5559        // TODO Import instantiated default arguments.
5560        // TODO Import instantiated exception specifications.
5561        //
5562        // Generally, ASTCommon.h/DeclUpdateKind enum gives a very good hint
5563        // what else could be fused during an AST merge.
5564        return PrevDefinition;
5565      }
5566    } else { // ODR violation.
5567      // FIXME HandleNameConflict
5568      return make_error<ImportError>(ImportError::NameConflict);
5569    }
5570  }
5571
5572  // Import the location of this declaration.
5573  ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5574  if (!BeginLocOrErr)
5575    return BeginLocOrErr.takeError();
5576  ExpectedSLoc IdLocOrErr = import(D->getLocation());
5577  if (!IdLocOrErr)
5578    return IdLocOrErr.takeError();
5579
5580  // Create the specialization.
5581  ClassTemplateSpecializationDecl *D2 = nullptr;
5582  if (PartialSpec) {
5583    // Import TemplateArgumentListInfo.
5584    TemplateArgumentListInfo ToTAInfo;
5585    const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
5586    if (Error Err = ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
5587      return std::move(Err);
5588
5589    QualType CanonInjType;
5590    if (Error Err = importInto(
5591        CanonInjType, PartialSpec->getInjectedSpecializationType()))
5592      return std::move(Err);
5593    CanonInjType = CanonInjType.getCanonicalType();
5594
5595    if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
5596            D2, D, Importer.getToContext(), D->getTagKind(), DC,
5597            *BeginLocOrErr, *IdLocOrErr, ToTPList, ClassTemplate,
5598            llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
5599            ToTAInfo, CanonInjType,
5600            cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))
5601      return D2;
5602
5603    // Update InsertPos, because preceding import calls may have invalidated
5604    // it by adding new specializations.
5605    auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(D2);
5606    if (!ClassTemplate->findPartialSpecialization(TemplateArgs, ToTPList,
5607                                                  InsertPos))
5608      // Add this partial specialization to the class template.
5609      ClassTemplate->AddPartialSpecialization(PartSpec2, InsertPos);
5610
5611  } else { // Not a partial specialization.
5612    if (GetImportedOrCreateDecl(
5613            D2, D, Importer.getToContext(), D->getTagKind(), DC,
5614            *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,
5615            PrevDecl))
5616      return D2;
5617
5618    // Update InsertPos, because preceding import calls may have invalidated
5619    // it by adding new specializations.
5620    if (!ClassTemplate->findSpecialization(TemplateArgs, InsertPos))
5621      // Add this specialization to the class template.
5622      ClassTemplate->AddSpecialization(D2, InsertPos);
5623  }
5624
5625  D2->setSpecializationKind(D->getSpecializationKind());
5626
5627  // Set the context of this specialization/instantiation.
5628  D2->setLexicalDeclContext(LexicalDC);
5629
5630  // Add to the DC only if it was an explicit specialization/instantiation.
5631  if (D2->isExplicitInstantiationOrSpecialization()) {
5632    LexicalDC->addDeclInternal(D2);
5633  }
5634
5635  if (auto BraceRangeOrErr = import(D->getBraceRange()))
5636    D2->setBraceRange(*BraceRangeOrErr);
5637  else
5638    return BraceRangeOrErr.takeError();
5639
5640  // Import the qualifier, if any.
5641  if (auto LocOrErr = import(D->getQualifierLoc()))
5642    D2->setQualifierInfo(*LocOrErr);
5643  else
5644    return LocOrErr.takeError();
5645
5646  if (auto *TSI = D->getTypeAsWritten()) {
5647    if (auto TInfoOrErr = import(TSI))
5648      D2->setTypeAsWritten(*TInfoOrErr);
5649    else
5650      return TInfoOrErr.takeError();
5651
5652    if (auto LocOrErr = import(D->getTemplateKeywordLoc()))
5653      D2->setTemplateKeywordLoc(*LocOrErr);
5654    else
5655      return LocOrErr.takeError();
5656
5657    if (auto LocOrErr = import(D->getExternLoc()))
5658      D2->setExternLoc(*LocOrErr);
5659    else
5660      return LocOrErr.takeError();
5661  }
5662
5663  if (D->getPointOfInstantiation().isValid()) {
5664    if (auto POIOrErr = import(D->getPointOfInstantiation()))
5665      D2->setPointOfInstantiation(*POIOrErr);
5666    else
5667      return POIOrErr.takeError();
5668  }
5669
5670  D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
5671
5672  if (D->isCompleteDefinition())
5673    if (Error Err = ImportDefinition(D, D2))
5674      return std::move(Err);
5675
5676  return D2;
5677}
5678
5679ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
5680  // Import the major distinguishing characteristics of this variable template.
5681  DeclContext *DC, *LexicalDC;
5682  DeclarationName Name;
5683  SourceLocation Loc;
5684  NamedDecl *ToD;
5685  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5686    return std::move(Err);
5687  if (ToD)
5688    return ToD;
5689
5690  // We may already have a template of the same name; try to find and match it.
5691  assert(!DC->isFunctionOrMethod() &&
5692         "Variable templates cannot be declared at function scope");
5693
5694  SmallVector<NamedDecl *, 4> ConflictingDecls;
5695  auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5696  VarTemplateDecl *FoundByLookup = nullptr;
5697  for (auto *FoundDecl : FoundDecls) {
5698    if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
5699      continue;
5700
5701    if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(FoundDecl)) {
5702      // Use the templated decl, some linkage flags are set only there.
5703      if (!hasSameVisibilityContextAndLinkage(FoundTemplate->getTemplatedDecl(),
5704                                              D->getTemplatedDecl()))
5705        continue;
5706      if (IsStructuralMatch(D, FoundTemplate)) {
5707        // The Decl in the "From" context has a definition, but in the
5708        // "To" context we already have a definition.
5709        VarTemplateDecl *FoundDef = getTemplateDefinition(FoundTemplate);
5710        if (D->isThisDeclarationADefinition() && FoundDef)
5711          // FIXME Check for ODR error if the two definitions have
5712          // different initializers?
5713          return Importer.MapImported(D, FoundDef);
5714
5715        FoundByLookup = FoundTemplate;
5716        break;
5717      }
5718      ConflictingDecls.push_back(FoundDecl);
5719    }
5720  }
5721
5722  if (!ConflictingDecls.empty()) {
5723    ExpectedName NameOrErr = Importer.HandleNameConflict(
5724        Name, DC, Decl::IDNS_Ordinary, ConflictingDecls.data(),
5725        ConflictingDecls.size());
5726    if (NameOrErr)
5727      Name = NameOrErr.get();
5728    else
5729      return NameOrErr.takeError();
5730  }
5731
5732  VarDecl *DTemplated = D->getTemplatedDecl();
5733
5734  // Import the type.
5735  // FIXME: Value not used?
5736  ExpectedType TypeOrErr = import(DTemplated->getType());
5737  if (!TypeOrErr)
5738    return TypeOrErr.takeError();
5739
5740  // Create the declaration that is being templated.
5741  VarDecl *ToTemplated;
5742  if (Error Err = importInto(ToTemplated, DTemplated))
5743    return std::move(Err);
5744
5745  // Create the variable template declaration itself.
5746  auto TemplateParamsOrErr = import(D->getTemplateParameters());
5747  if (!TemplateParamsOrErr)
5748    return TemplateParamsOrErr.takeError();
5749
5750  VarTemplateDecl *ToVarTD;
5751  if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc,
5752                              Name, *TemplateParamsOrErr, ToTemplated))
5753    return ToVarTD;
5754
5755  ToTemplated->setDescribedVarTemplate(ToVarTD);
5756
5757  ToVarTD->setAccess(D->getAccess());
5758  ToVarTD->setLexicalDeclContext(LexicalDC);
5759  LexicalDC->addDeclInternal(ToVarTD);
5760
5761  if (FoundByLookup) {
5762    auto *Recent =
5763        const_cast<VarTemplateDecl *>(FoundByLookup->getMostRecentDecl());
5764    if (!ToTemplated->getPreviousDecl()) {
5765      auto *PrevTemplated =
5766          FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
5767      if (ToTemplated != PrevTemplated)
5768        ToTemplated->setPreviousDecl(PrevTemplated);
5769    }
5770    ToVarTD->setPreviousDecl(Recent);
5771  }
5772
5773  if (DTemplated->isThisDeclarationADefinition() &&
5774      !ToTemplated->isThisDeclarationADefinition()) {
5775    // FIXME: Import definition!
5776  }
5777
5778  return ToVarTD;
5779}
5780
5781ExpectedDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl(
5782    VarTemplateSpecializationDecl *D) {
5783  // If this record has a definition in the translation unit we're coming from,
5784  // but this particular declaration is not that definition, import the
5785  // definition and map to that.
5786  VarDecl *Definition = D->getDefinition();
5787  if (Definition && Definition != D) {
5788    if (ExpectedDecl ImportedDefOrErr = import(Definition))
5789      return Importer.MapImported(D, *ImportedDefOrErr);
5790    else
5791      return ImportedDefOrErr.takeError();
5792  }
5793
5794  VarTemplateDecl *VarTemplate = nullptr;
5795  if (Error Err = importInto(VarTemplate, D->getSpecializedTemplate()))
5796    return std::move(Err);
5797
5798  // Import the context of this declaration.
5799  DeclContext *DC, *LexicalDC;
5800  if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5801    return std::move(Err);
5802
5803  // Import the location of this declaration.
5804  ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5805  if (!BeginLocOrErr)
5806    return BeginLocOrErr.takeError();
5807
5808  auto IdLocOrErr = import(D->getLocation());
5809  if (!IdLocOrErr)
5810    return IdLocOrErr.takeError();
5811
5812  // Import template arguments.
5813  SmallVector<TemplateArgument, 2> TemplateArgs;
5814  if (Error Err = ImportTemplateArguments(
5815      D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
5816    return std::move(Err);
5817
5818  // Try to find an existing specialization with these template arguments.
5819  void *InsertPos = nullptr;
5820  VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
5821      TemplateArgs, InsertPos);
5822  if (D2) {
5823    // We already have a variable template specialization with these template
5824    // arguments.
5825
5826    // FIXME: Check for specialization vs. instantiation errors.
5827
5828    if (VarDecl *FoundDef = D2->getDefinition()) {
5829      if (!D->isThisDeclarationADefinition() ||
5830          IsStructuralMatch(D, FoundDef)) {
5831        // The record types structurally match, or the "from" translation
5832        // unit only had a forward declaration anyway; call it the same
5833        // variable.
5834        return Importer.MapImported(D, FoundDef);
5835      }
5836    }
5837  } else {
5838    // Import the type.
5839    QualType T;
5840    if (Error Err = importInto(T, D->getType()))
5841      return std::move(Err);
5842
5843    auto TInfoOrErr = import(D->getTypeSourceInfo());
5844    if (!TInfoOrErr)
5845      return TInfoOrErr.takeError();
5846
5847    TemplateArgumentListInfo ToTAInfo;
5848    if (Error Err = ImportTemplateArgumentListInfo(
5849        D->getTemplateArgsInfo(), ToTAInfo))
5850      return std::move(Err);
5851
5852    using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
5853    // Create a new specialization.
5854    if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
5855      // Import TemplateArgumentListInfo
5856      TemplateArgumentListInfo ArgInfos;
5857      const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
5858      // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
5859      if (Error Err = ImportTemplateArgumentListInfo(
5860          *FromTAArgsAsWritten, ArgInfos))
5861        return std::move(Err);
5862
5863      auto ToTPListOrErr = import(FromPartial->getTemplateParameters());
5864      if (!ToTPListOrErr)
5865        return ToTPListOrErr.takeError();
5866
5867      PartVarSpecDecl *ToPartial;
5868      if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
5869                                  *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
5870                                  VarTemplate, T, *TInfoOrErr,
5871                                  D->getStorageClass(), TemplateArgs, ArgInfos))
5872        return ToPartial;
5873
5874      if (Expected<PartVarSpecDecl *> ToInstOrErr = import(
5875          FromPartial->getInstantiatedFromMember()))
5876        ToPartial->setInstantiatedFromMember(*ToInstOrErr);
5877      else
5878        return ToInstOrErr.takeError();
5879
5880      if (FromPartial->isMemberSpecialization())
5881        ToPartial->setMemberSpecialization();
5882
5883      D2 = ToPartial;
5884
5885    } else { // Full specialization
5886      if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC,
5887                                  *BeginLocOrErr, *IdLocOrErr, VarTemplate,
5888                                  T, *TInfoOrErr,
5889                                  D->getStorageClass(), TemplateArgs))
5890        return D2;
5891    }
5892
5893    if (D->getPointOfInstantiation().isValid()) {
5894      if (ExpectedSLoc POIOrErr = import(D->getPointOfInstantiation()))
5895        D2->setPointOfInstantiation(*POIOrErr);
5896      else
5897        return POIOrErr.takeError();
5898    }
5899
5900    D2->setSpecializationKind(D->getSpecializationKind());
5901    D2->setTemplateArgsInfo(ToTAInfo);
5902
5903    // Add this specialization to the class template.
5904    VarTemplate->AddSpecialization(D2, InsertPos);
5905
5906    // Import the qualifier, if any.
5907    if (auto LocOrErr = import(D->getQualifierLoc()))
5908      D2->setQualifierInfo(*LocOrErr);
5909    else
5910      return LocOrErr.takeError();
5911
5912    if (D->isConstexpr())
5913      D2->setConstexpr(true);
5914
5915    // Add the specialization to this context.
5916    D2->setLexicalDeclContext(LexicalDC);
5917    LexicalDC->addDeclInternal(D2);
5918
5919    D2->setAccess(D->getAccess());
5920  }
5921
5922  if (Error Err = ImportInitializer(D, D2))
5923    return std::move(Err);
5924
5925  return D2;
5926}
5927
5928ExpectedDecl
5929ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
5930  DeclContext *DC, *LexicalDC;
5931  DeclarationName Name;
5932  SourceLocation Loc;
5933  NamedDecl *ToD;
5934
5935  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5936    return std::move(Err);
5937
5938  if (ToD)
5939    return ToD;
5940
5941  const FunctionTemplateDecl *FoundByLookup = nullptr;
5942
5943  // Try to find a function in our own ("to") context with the same name, same
5944  // type, and in the same context as the function we're importing.
5945  // FIXME Split this into a separate function.
5946  if (!LexicalDC->isFunctionOrMethod()) {
5947    unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
5948    auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5949    for (auto *FoundDecl : FoundDecls) {
5950      if (!FoundDecl->isInIdentifierNamespace(IDNS))
5951        continue;
5952
5953      if (auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
5954        if (!hasSameVisibilityContextAndLinkage(FoundTemplate, D))
5955          continue;
5956        if (IsStructuralMatch(D, FoundTemplate)) {
5957          FunctionTemplateDecl *TemplateWithDef =
5958              getTemplateDefinition(FoundTemplate);
5959          if (D->isThisDeclarationADefinition() && TemplateWithDef)
5960            return Importer.MapImported(D, TemplateWithDef);
5961
5962          FoundByLookup = FoundTemplate;
5963          break;
5964          // TODO: handle conflicting names
5965        }
5966      }
5967    }
5968  }
5969
5970  auto ParamsOrErr = import(D->getTemplateParameters());
5971  if (!ParamsOrErr)
5972    return ParamsOrErr.takeError();
5973
5974  FunctionDecl *TemplatedFD;
5975  if (Error Err = importInto(TemplatedFD, D->getTemplatedDecl()))
5976    return std::move(Err);
5977
5978  FunctionTemplateDecl *ToFunc;
5979  if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
5980                              *ParamsOrErr, TemplatedFD))
5981    return ToFunc;
5982
5983  TemplatedFD->setDescribedFunctionTemplate(ToFunc);
5984
5985  ToFunc->setAccess(D->getAccess());
5986  ToFunc->setLexicalDeclContext(LexicalDC);
5987  LexicalDC->addDeclInternal(ToFunc);
5988
5989  if (FoundByLookup) {
5990    auto *Recent =
5991        const_cast<FunctionTemplateDecl *>(FoundByLookup->getMostRecentDecl());
5992    if (!TemplatedFD->getPreviousDecl()) {
5993      assert(FoundByLookup->getTemplatedDecl() &&
5994             "Found decl must have its templated decl set");
5995      auto *PrevTemplated =
5996          FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
5997      if (TemplatedFD != PrevTemplated)
5998        TemplatedFD->setPreviousDecl(PrevTemplated);
5999    }
6000    ToFunc->setPreviousDecl(Recent);
6001  }
6002
6003  return ToFunc;
6004}
6005
6006//----------------------------------------------------------------------------
6007// Import Statements
6008//----------------------------------------------------------------------------
6009
6010ExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) {
6011  Importer.FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
6012      << S->getStmtClassName();
6013  return make_error<ImportError>(ImportError::UnsupportedConstruct);
6014}
6015
6016
6017ExpectedStmt ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
6018  if (Importer.returnWithErrorInTest())
6019    return make_error<ImportError>(ImportError::UnsupportedConstruct);
6020  SmallVector<IdentifierInfo *, 4> Names;
6021  for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
6022    IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
6023    // ToII is nullptr when no symbolic name is given for output operand
6024    // see ParseStmtAsm::ParseAsmOperandsOpt
6025    Names.push_back(ToII);
6026  }
6027
6028  for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
6029    IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
6030    // ToII is nullptr when no symbolic name is given for input operand
6031    // see ParseStmtAsm::ParseAsmOperandsOpt
6032    Names.push_back(ToII);
6033  }
6034
6035  SmallVector<StringLiteral *, 4> Clobbers;
6036  for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
6037    if (auto ClobberOrErr = import(S->getClobberStringLiteral(I)))
6038      Clobbers.push_back(*ClobberOrErr);
6039    else
6040      return ClobberOrErr.takeError();
6041
6042  }
6043
6044  SmallVector<StringLiteral *, 4> Constraints;
6045  for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
6046    if (auto OutputOrErr = import(S->getOutputConstraintLiteral(I)))
6047      Constraints.push_back(*OutputOrErr);
6048    else
6049      return OutputOrErr.takeError();
6050  }
6051
6052  for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
6053    if (auto InputOrErr = import(S->getInputConstraintLiteral(I)))
6054      Constraints.push_back(*InputOrErr);
6055    else
6056      return InputOrErr.takeError();
6057  }
6058
6059  SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() +
6060                               S->getNumLabels());
6061  if (Error Err = ImportContainerChecked(S->outputs(), Exprs))
6062    return std::move(Err);
6063
6064  if (Error Err =
6065          ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
6066    return std::move(Err);
6067
6068  if (Error Err = ImportArrayChecked(
6069          S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
6070    return std::move(Err);
6071
6072  ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc());
6073  if (!AsmLocOrErr)
6074    return AsmLocOrErr.takeError();
6075  auto AsmStrOrErr = import(S->getAsmString());
6076  if (!AsmStrOrErr)
6077    return AsmStrOrErr.takeError();
6078  ExpectedSLoc RParenLocOrErr = import(S->getRParenLoc());
6079  if (!RParenLocOrErr)
6080    return RParenLocOrErr.takeError();
6081
6082  return new (Importer.getToContext()) GCCAsmStmt(
6083      Importer.getToContext(),
6084      *AsmLocOrErr,
6085      S->isSimple(),
6086      S->isVolatile(),
6087      S->getNumOutputs(),
6088      S->getNumInputs(),
6089      Names.data(),
6090      Constraints.data(),
6091      Exprs.data(),
6092      *AsmStrOrErr,
6093      S->getNumClobbers(),
6094      Clobbers.data(),
6095      S->getNumLabels(),
6096      *RParenLocOrErr);
6097}
6098
6099ExpectedStmt ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
6100
6101  Error Err = Error::success();
6102  auto ToDG = importChecked(Err, S->getDeclGroup());
6103  auto ToBeginLoc = importChecked(Err, S->getBeginLoc());
6104  auto ToEndLoc = importChecked(Err, S->getEndLoc());
6105  if (Err)
6106    return std::move(Err);
6107  return new (Importer.getToContext()) DeclStmt(ToDG, ToBeginLoc, ToEndLoc);
6108}
6109
6110ExpectedStmt ASTNodeImporter::VisitNullStmt(NullStmt *S) {
6111  ExpectedSLoc ToSemiLocOrErr = import(S->getSemiLoc());
6112  if (!ToSemiLocOrErr)
6113    return ToSemiLocOrErr.takeError();
6114  return new (Importer.getToContext()) NullStmt(
6115      *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
6116}
6117
6118ExpectedStmt ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
6119  SmallVector<Stmt *, 8> ToStmts(S->size());
6120
6121  if (Error Err = ImportContainerChecked(S->body(), ToStmts))
6122    return std::move(Err);
6123
6124  ExpectedSLoc ToLBracLocOrErr = import(S->getLBracLoc());
6125  if (!ToLBracLocOrErr)
6126    return ToLBracLocOrErr.takeError();
6127
6128  ExpectedSLoc ToRBracLocOrErr = import(S->getRBracLoc());
6129  if (!ToRBracLocOrErr)
6130    return ToRBracLocOrErr.takeError();
6131
6132  return CompoundStmt::Create(
6133      Importer.getToContext(), ToStmts,
6134      *ToLBracLocOrErr, *ToRBracLocOrErr);
6135}
6136
6137ExpectedStmt ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
6138
6139  Error Err = Error::success();
6140  auto ToLHS = importChecked(Err, S->getLHS());
6141  auto ToRHS = importChecked(Err, S->getRHS());
6142  auto ToSubStmt = importChecked(Err, S->getSubStmt());
6143  auto ToCaseLoc = importChecked(Err, S->getCaseLoc());
6144  auto ToEllipsisLoc = importChecked(Err, S->getEllipsisLoc());
6145  auto ToColonLoc = importChecked(Err, S->getColonLoc());
6146  if (Err)
6147    return std::move(Err);
6148
6149  auto *ToStmt = CaseStmt::Create(Importer.getToContext(), ToLHS, ToRHS,
6150                                  ToCaseLoc, ToEllipsisLoc, ToColonLoc);
6151  ToStmt->setSubStmt(ToSubStmt);
6152
6153  return ToStmt;
6154}
6155
6156ExpectedStmt ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
6157
6158  Error Err = Error::success();
6159  auto ToDefaultLoc = importChecked(Err, S->getDefaultLoc());
6160  auto ToColonLoc = importChecked(Err, S->getColonLoc());
6161  auto ToSubStmt = importChecked(Err, S->getSubStmt());
6162  if (Err)
6163    return std::move(Err);
6164
6165  return new (Importer.getToContext()) DefaultStmt(
6166    ToDefaultLoc, ToColonLoc, ToSubStmt);
6167}
6168
6169ExpectedStmt ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
6170
6171  Error Err = Error::success();
6172  auto ToIdentLoc = importChecked(Err, S->getIdentLoc());
6173  auto ToLabelDecl = importChecked(Err, S->getDecl());
6174  auto ToSubStmt = importChecked(Err, S->getSubStmt());
6175  if (Err)
6176    return std::move(Err);
6177
6178  return new (Importer.getToContext()) LabelStmt(
6179      ToIdentLoc, ToLabelDecl, ToSubStmt);
6180}
6181
6182ExpectedStmt ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
6183  ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc());
6184  if (!ToAttrLocOrErr)
6185    return ToAttrLocOrErr.takeError();
6186  ArrayRef<const Attr*> FromAttrs(S->getAttrs());
6187  SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
6188  if (Error Err = ImportContainerChecked(FromAttrs, ToAttrs))
6189    return std::move(Err);
6190  ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
6191  if (!ToSubStmtOrErr)
6192    return ToSubStmtOrErr.takeError();
6193
6194  return AttributedStmt::Create(
6195      Importer.getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
6196}
6197
6198ExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) {
6199
6200  Error Err = Error::success();
6201  auto ToIfLoc = importChecked(Err, S->getIfLoc());
6202  auto ToInit = importChecked(Err, S->getInit());
6203  auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6204  auto ToCond = importChecked(Err, S->getCond());
6205  auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6206  auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6207  auto ToThen = importChecked(Err, S->getThen());
6208  auto ToElseLoc = importChecked(Err, S->getElseLoc());
6209  auto ToElse = importChecked(Err, S->getElse());
6210  if (Err)
6211    return std::move(Err);
6212
6213  return IfStmt::Create(Importer.getToContext(), ToIfLoc, S->isConstexpr(),
6214                        ToInit, ToConditionVariable, ToCond, ToLParenLoc,
6215                        ToRParenLoc, ToThen, ToElseLoc, ToElse);
6216}
6217
6218ExpectedStmt ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
6219
6220  Error Err = Error::success();
6221  auto ToInit = importChecked(Err, S->getInit());
6222  auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6223  auto ToCond = importChecked(Err, S->getCond());
6224  auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6225  auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6226  auto ToBody = importChecked(Err, S->getBody());
6227  auto ToSwitchLoc = importChecked(Err, S->getSwitchLoc());
6228  if (Err)
6229    return std::move(Err);
6230
6231  auto *ToStmt =
6232      SwitchStmt::Create(Importer.getToContext(), ToInit, ToConditionVariable,
6233                         ToCond, ToLParenLoc, ToRParenLoc);
6234  ToStmt->setBody(ToBody);
6235  ToStmt->setSwitchLoc(ToSwitchLoc);
6236
6237  // Now we have to re-chain the cases.
6238  SwitchCase *LastChainedSwitchCase = nullptr;
6239  for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
6240       SC = SC->getNextSwitchCase()) {
6241    Expected<SwitchCase *> ToSCOrErr = import(SC);
6242    if (!ToSCOrErr)
6243      return ToSCOrErr.takeError();
6244    if (LastChainedSwitchCase)
6245      LastChainedSwitchCase->setNextSwitchCase(*ToSCOrErr);
6246    else
6247      ToStmt->setSwitchCaseList(*ToSCOrErr);
6248    LastChainedSwitchCase = *ToSCOrErr;
6249  }
6250
6251  return ToStmt;
6252}
6253
6254ExpectedStmt ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
6255
6256  Error Err = Error::success();
6257  auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6258  auto ToCond = importChecked(Err, S->getCond());
6259  auto ToBody = importChecked(Err, S->getBody());
6260  auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
6261  auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6262  auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6263  if (Err)
6264    return std::move(Err);
6265
6266  return WhileStmt::Create(Importer.getToContext(), ToConditionVariable, ToCond,
6267                           ToBody, ToWhileLoc, ToLParenLoc, ToRParenLoc);
6268}
6269
6270ExpectedStmt ASTNodeImporter::VisitDoStmt(DoStmt *S) {
6271
6272  Error Err = Error::success();
6273  auto ToBody = importChecked(Err, S->getBody());
6274  auto ToCond = importChecked(Err, S->getCond());
6275  auto ToDoLoc = importChecked(Err, S->getDoLoc());
6276  auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
6277  auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6278  if (Err)
6279    return std::move(Err);
6280
6281  return new (Importer.getToContext()) DoStmt(
6282      ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
6283}
6284
6285ExpectedStmt ASTNodeImporter::VisitForStmt(ForStmt *S) {
6286
6287  Error Err = Error::success();
6288  auto ToInit = importChecked(Err, S->getInit());
6289  auto ToCond = importChecked(Err, S->getCond());
6290  auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6291  auto ToInc = importChecked(Err, S->getInc());
6292  auto ToBody = importChecked(Err, S->getBody());
6293  auto ToForLoc = importChecked(Err, S->getForLoc());
6294  auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6295  auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6296  if (Err)
6297    return std::move(Err);
6298
6299  return new (Importer.getToContext()) ForStmt(
6300      Importer.getToContext(),
6301      ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
6302      ToRParenLoc);
6303}
6304
6305ExpectedStmt ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
6306
6307  Error Err = Error::success();
6308  auto ToLabel = importChecked(Err, S->getLabel());
6309  auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
6310  auto ToLabelLoc = importChecked(Err, S->getLabelLoc());
6311  if (Err)
6312    return std::move(Err);
6313
6314  return new (Importer.getToContext()) GotoStmt(
6315      ToLabel, ToGotoLoc, ToLabelLoc);
6316}
6317
6318ExpectedStmt ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
6319
6320  Error Err = Error::success();
6321  auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
6322  auto ToStarLoc = importChecked(Err, S->getStarLoc());
6323  auto ToTarget = importChecked(Err, S->getTarget());
6324  if (Err)
6325    return std::move(Err);
6326
6327  return new (Importer.getToContext()) IndirectGotoStmt(
6328      ToGotoLoc, ToStarLoc, ToTarget);
6329}
6330
6331ExpectedStmt ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
6332  ExpectedSLoc ToContinueLocOrErr = import(S->getContinueLoc());
6333  if (!ToContinueLocOrErr)
6334    return ToContinueLocOrErr.takeError();
6335  return new (Importer.getToContext()) ContinueStmt(*ToContinueLocOrErr);
6336}
6337
6338ExpectedStmt ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
6339  auto ToBreakLocOrErr = import(S->getBreakLoc());
6340  if (!ToBreakLocOrErr)
6341    return ToBreakLocOrErr.takeError();
6342  return new (Importer.getToContext()) BreakStmt(*ToBreakLocOrErr);
6343}
6344
6345ExpectedStmt ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
6346
6347  Error Err = Error::success();
6348  auto ToReturnLoc = importChecked(Err, S->getReturnLoc());
6349  auto ToRetValue = importChecked(Err, S->getRetValue());
6350  auto ToNRVOCandidate = importChecked(Err, S->getNRVOCandidate());
6351  if (Err)
6352    return std::move(Err);
6353
6354  return ReturnStmt::Create(Importer.getToContext(), ToReturnLoc, ToRetValue,
6355                            ToNRVOCandidate);
6356}
6357
6358ExpectedStmt ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
6359
6360  Error Err = Error::success();
6361  auto ToCatchLoc = importChecked(Err, S->getCatchLoc());
6362  auto ToExceptionDecl = importChecked(Err, S->getExceptionDecl());
6363  auto ToHandlerBlock = importChecked(Err, S->getHandlerBlock());
6364  if (Err)
6365    return std::move(Err);
6366
6367  return new (Importer.getToContext()) CXXCatchStmt (
6368      ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
6369}
6370
6371ExpectedStmt ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
6372  ExpectedSLoc ToTryLocOrErr = import(S->getTryLoc());
6373  if (!ToTryLocOrErr)
6374    return ToTryLocOrErr.takeError();
6375
6376  ExpectedStmt ToTryBlockOrErr = import(S->getTryBlock());
6377  if (!ToTryBlockOrErr)
6378    return ToTryBlockOrErr.takeError();
6379
6380  SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
6381  for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
6382    CXXCatchStmt *FromHandler = S->getHandler(HI);
6383    if (auto ToHandlerOrErr = import(FromHandler))
6384      ToHandlers[HI] = *ToHandlerOrErr;
6385    else
6386      return ToHandlerOrErr.takeError();
6387  }
6388
6389  return CXXTryStmt::Create(
6390      Importer.getToContext(), *ToTryLocOrErr,*ToTryBlockOrErr, ToHandlers);
6391}
6392
6393ExpectedStmt ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
6394
6395  Error Err = Error::success();
6396  auto ToInit = importChecked(Err, S->getInit());
6397  auto ToRangeStmt = importChecked(Err, S->getRangeStmt());
6398  auto ToBeginStmt = importChecked(Err, S->getBeginStmt());
6399  auto ToEndStmt = importChecked(Err, S->getEndStmt());
6400  auto ToCond = importChecked(Err, S->getCond());
6401  auto ToInc = importChecked(Err, S->getInc());
6402  auto ToLoopVarStmt = importChecked(Err, S->getLoopVarStmt());
6403  auto ToBody = importChecked(Err, S->getBody());
6404  auto ToForLoc = importChecked(Err, S->getForLoc());
6405  auto ToCoawaitLoc = importChecked(Err, S->getCoawaitLoc());
6406  auto ToColonLoc = importChecked(Err, S->getColonLoc());
6407  auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6408  if (Err)
6409    return std::move(Err);
6410
6411  return new (Importer.getToContext()) CXXForRangeStmt(
6412      ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt,
6413      ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc);
6414}
6415
6416ExpectedStmt
6417ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
6418  Error Err = Error::success();
6419  auto ToElement = importChecked(Err, S->getElement());
6420  auto ToCollection = importChecked(Err, S->getCollection());
6421  auto ToBody = importChecked(Err, S->getBody());
6422  auto ToForLoc = importChecked(Err, S->getForLoc());
6423  auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6424  if (Err)
6425    return std::move(Err);
6426
6427  return new (Importer.getToContext()) ObjCForCollectionStmt(ToElement,
6428                                                             ToCollection,
6429                                                             ToBody,
6430                                                             ToForLoc,
6431                                                             ToRParenLoc);
6432}
6433
6434ExpectedStmt ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
6435
6436  Error Err = Error::success();
6437  auto ToAtCatchLoc = importChecked(Err, S->getAtCatchLoc());
6438  auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6439  auto ToCatchParamDecl = importChecked(Err, S->getCatchParamDecl());
6440  auto ToCatchBody = importChecked(Err, S->getCatchBody());
6441  if (Err)
6442    return std::move(Err);
6443
6444  return new (Importer.getToContext()) ObjCAtCatchStmt (
6445      ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
6446}
6447
6448ExpectedStmt ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
6449  ExpectedSLoc ToAtFinallyLocOrErr = import(S->getAtFinallyLoc());
6450  if (!ToAtFinallyLocOrErr)
6451    return ToAtFinallyLocOrErr.takeError();
6452  ExpectedStmt ToAtFinallyStmtOrErr = import(S->getFinallyBody());
6453  if (!ToAtFinallyStmtOrErr)
6454    return ToAtFinallyStmtOrErr.takeError();
6455  return new (Importer.getToContext()) ObjCAtFinallyStmt(*ToAtFinallyLocOrErr,
6456                                                         *ToAtFinallyStmtOrErr);
6457}
6458
6459ExpectedStmt ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
6460
6461  Error Err = Error::success();
6462  auto ToAtTryLoc = importChecked(Err, S->getAtTryLoc());
6463  auto ToTryBody = importChecked(Err, S->getTryBody());
6464  auto ToFinallyStmt = importChecked(Err, S->getFinallyStmt());
6465  if (Err)
6466    return std::move(Err);
6467
6468  SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
6469  for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
6470    ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
6471    if (ExpectedStmt ToCatchStmtOrErr = import(FromCatchStmt))
6472      ToCatchStmts[CI] = *ToCatchStmtOrErr;
6473    else
6474      return ToCatchStmtOrErr.takeError();
6475  }
6476
6477  return ObjCAtTryStmt::Create(Importer.getToContext(),
6478                               ToAtTryLoc, ToTryBody,
6479                               ToCatchStmts.begin(), ToCatchStmts.size(),
6480                               ToFinallyStmt);
6481}
6482
6483ExpectedStmt
6484ASTNodeImporter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
6485
6486  Error Err = Error::success();
6487  auto ToAtSynchronizedLoc = importChecked(Err, S->getAtSynchronizedLoc());
6488  auto ToSynchExpr = importChecked(Err, S->getSynchExpr());
6489  auto ToSynchBody = importChecked(Err, S->getSynchBody());
6490  if (Err)
6491    return std::move(Err);
6492
6493  return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
6494    ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
6495}
6496
6497ExpectedStmt ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
6498  ExpectedSLoc ToThrowLocOrErr = import(S->getThrowLoc());
6499  if (!ToThrowLocOrErr)
6500    return ToThrowLocOrErr.takeError();
6501  ExpectedExpr ToThrowExprOrErr = import(S->getThrowExpr());
6502  if (!ToThrowExprOrErr)
6503    return ToThrowExprOrErr.takeError();
6504  return new (Importer.getToContext()) ObjCAtThrowStmt(
6505      *ToThrowLocOrErr, *ToThrowExprOrErr);
6506}
6507
6508ExpectedStmt ASTNodeImporter::VisitObjCAutoreleasePoolStmt(
6509    ObjCAutoreleasePoolStmt *S) {
6510  ExpectedSLoc ToAtLocOrErr = import(S->getAtLoc());
6511  if (!ToAtLocOrErr)
6512    return ToAtLocOrErr.takeError();
6513  ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
6514  if (!ToSubStmtOrErr)
6515    return ToSubStmtOrErr.takeError();
6516  return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(*ToAtLocOrErr,
6517                                                               *ToSubStmtOrErr);
6518}
6519
6520//----------------------------------------------------------------------------
6521// Import Expressions
6522//----------------------------------------------------------------------------
6523ExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) {
6524  Importer.FromDiag(E->getBeginLoc(), diag::err_unsupported_ast_node)
6525      << E->getStmtClassName();
6526  return make_error<ImportError>(ImportError::UnsupportedConstruct);
6527}
6528
6529ExpectedStmt ASTNodeImporter::VisitSourceLocExpr(SourceLocExpr *E) {
6530  Error Err = Error::success();
6531  auto BLoc = importChecked(Err, E->getBeginLoc());
6532  auto RParenLoc = importChecked(Err, E->getEndLoc());
6533  if (Err)
6534    return std::move(Err);
6535  auto ParentContextOrErr = Importer.ImportContext(E->getParentContext());
6536  if (!ParentContextOrErr)
6537    return ParentContextOrErr.takeError();
6538
6539  return new (Importer.getToContext())
6540      SourceLocExpr(Importer.getToContext(), E->getIdentKind(), BLoc, RParenLoc,
6541                    *ParentContextOrErr);
6542}
6543
6544ExpectedStmt ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
6545
6546  Error Err = Error::success();
6547  auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
6548  auto ToSubExpr = importChecked(Err, E->getSubExpr());
6549  auto ToWrittenTypeInfo = importChecked(Err, E->getWrittenTypeInfo());
6550  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6551  auto ToType = importChecked(Err, E->getType());
6552  if (Err)
6553    return std::move(Err);
6554
6555  return new (Importer.getToContext()) VAArgExpr(
6556      ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
6557      E->isMicrosoftABI());
6558}
6559
6560ExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) {
6561
6562  Error Err = Error::success();
6563  auto ToCond = importChecked(Err, E->getCond());
6564  auto ToLHS = importChecked(Err, E->getLHS());
6565  auto ToRHS = importChecked(Err, E->getRHS());
6566  auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
6567  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6568  auto ToType = importChecked(Err, E->getType());
6569  if (Err)
6570    return std::move(Err);
6571
6572  ExprValueKind VK = E->getValueKind();
6573  ExprObjectKind OK = E->getObjectKind();
6574
6575  // The value of CondIsTrue only matters if the value is not
6576  // condition-dependent.
6577  bool CondIsTrue = !E->isConditionDependent() && E->isConditionTrue();
6578
6579  return new (Importer.getToContext())
6580      ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK,
6581                 ToRParenLoc, CondIsTrue);
6582}
6583
6584ExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
6585  ExpectedType TypeOrErr = import(E->getType());
6586  if (!TypeOrErr)
6587    return TypeOrErr.takeError();
6588
6589  ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc());
6590  if (!BeginLocOrErr)
6591    return BeginLocOrErr.takeError();
6592
6593  return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr);
6594}
6595
6596ExpectedStmt
6597ASTNodeImporter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
6598  Error Err = Error::success();
6599  auto ToGenericLoc = importChecked(Err, E->getGenericLoc());
6600  auto *ToControllingExpr = importChecked(Err, E->getControllingExpr());
6601  auto ToDefaultLoc = importChecked(Err, E->getDefaultLoc());
6602  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6603  if (Err)
6604    return std::move(Err);
6605
6606  ArrayRef<const TypeSourceInfo *> FromAssocTypes(E->getAssocTypeSourceInfos());
6607  SmallVector<TypeSourceInfo *, 1> ToAssocTypes(FromAssocTypes.size());
6608  if (Error Err = ImportContainerChecked(FromAssocTypes, ToAssocTypes))
6609    return std::move(Err);
6610
6611  ArrayRef<const Expr *> FromAssocExprs(E->getAssocExprs());
6612  SmallVector<Expr *, 1> ToAssocExprs(FromAssocExprs.size());
6613  if (Error Err = ImportContainerChecked(FromAssocExprs, ToAssocExprs))
6614    return std::move(Err);
6615
6616  const ASTContext &ToCtx = Importer.getToContext();
6617  if (E->isResultDependent()) {
6618    return GenericSelectionExpr::Create(
6619        ToCtx, ToGenericLoc, ToControllingExpr,
6620        llvm::makeArrayRef(ToAssocTypes), llvm::makeArrayRef(ToAssocExprs),
6621        ToDefaultLoc, ToRParenLoc, E->containsUnexpandedParameterPack());
6622  }
6623
6624  return GenericSelectionExpr::Create(
6625      ToCtx, ToGenericLoc, ToControllingExpr, llvm::makeArrayRef(ToAssocTypes),
6626      llvm::makeArrayRef(ToAssocExprs), ToDefaultLoc, ToRParenLoc,
6627      E->containsUnexpandedParameterPack(), E->getResultIndex());
6628}
6629
6630ExpectedStmt ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
6631
6632  Error Err = Error::success();
6633  auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
6634  auto ToType = importChecked(Err, E->getType());
6635  auto ToFunctionName = importChecked(Err, E->getFunctionName());
6636  if (Err)
6637    return std::move(Err);
6638
6639  return PredefinedExpr::Create(Importer.getToContext(), ToBeginLoc, ToType,
6640                                E->getIdentKind(), ToFunctionName);
6641}
6642
6643ExpectedStmt ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
6644
6645  Error Err = Error::success();
6646  auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
6647  auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
6648  auto ToDecl = importChecked(Err, E->getDecl());
6649  auto ToLocation = importChecked(Err, E->getLocation());
6650  auto ToType = importChecked(Err, E->getType());
6651  if (Err)
6652    return std::move(Err);
6653
6654  NamedDecl *ToFoundD = nullptr;
6655  if (E->getDecl() != E->getFoundDecl()) {
6656    auto FoundDOrErr = import(E->getFoundDecl());
6657    if (!FoundDOrErr)
6658      return FoundDOrErr.takeError();
6659    ToFoundD = *FoundDOrErr;
6660  }
6661
6662  TemplateArgumentListInfo ToTAInfo;
6663  TemplateArgumentListInfo *ToResInfo = nullptr;
6664  if (E->hasExplicitTemplateArgs()) {
6665    if (Error Err =
6666            ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
6667                                           E->template_arguments(), ToTAInfo))
6668      return std::move(Err);
6669    ToResInfo = &ToTAInfo;
6670  }
6671
6672  auto *ToE = DeclRefExpr::Create(
6673      Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl,
6674      E->refersToEnclosingVariableOrCapture(), ToLocation, ToType,
6675      E->getValueKind(), ToFoundD, ToResInfo, E->isNonOdrUse());
6676  if (E->hadMultipleCandidates())
6677    ToE->setHadMultipleCandidates(true);
6678  return ToE;
6679}
6680
6681ExpectedStmt ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
6682  ExpectedType TypeOrErr = import(E->getType());
6683  if (!TypeOrErr)
6684    return TypeOrErr.takeError();
6685
6686  return new (Importer.getToContext()) ImplicitValueInitExpr(*TypeOrErr);
6687}
6688
6689ExpectedStmt ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
6690  ExpectedExpr ToInitOrErr = import(E->getInit());
6691  if (!ToInitOrErr)
6692    return ToInitOrErr.takeError();
6693
6694  ExpectedSLoc ToEqualOrColonLocOrErr = import(E->getEqualOrColonLoc());
6695  if (!ToEqualOrColonLocOrErr)
6696    return ToEqualOrColonLocOrErr.takeError();
6697
6698  SmallVector<Expr *, 4> ToIndexExprs(E->getNumSubExprs() - 1);
6699  // List elements from the second, the first is Init itself
6700  for (unsigned I = 1, N = E->getNumSubExprs(); I < N; I++) {
6701    if (ExpectedExpr ToArgOrErr = import(E->getSubExpr(I)))
6702      ToIndexExprs[I - 1] = *ToArgOrErr;
6703    else
6704      return ToArgOrErr.takeError();
6705  }
6706
6707  SmallVector<Designator, 4> ToDesignators(E->size());
6708  if (Error Err = ImportContainerChecked(E->designators(), ToDesignators))
6709    return std::move(Err);
6710
6711  return DesignatedInitExpr::Create(
6712        Importer.getToContext(), ToDesignators,
6713        ToIndexExprs, *ToEqualOrColonLocOrErr,
6714        E->usesGNUSyntax(), *ToInitOrErr);
6715}
6716
6717ExpectedStmt
6718ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
6719  ExpectedType ToTypeOrErr = import(E->getType());
6720  if (!ToTypeOrErr)
6721    return ToTypeOrErr.takeError();
6722
6723  ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6724  if (!ToLocationOrErr)
6725    return ToLocationOrErr.takeError();
6726
6727  return new (Importer.getToContext()) CXXNullPtrLiteralExpr(
6728      *ToTypeOrErr, *ToLocationOrErr);
6729}
6730
6731ExpectedStmt ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
6732  ExpectedType ToTypeOrErr = import(E->getType());
6733  if (!ToTypeOrErr)
6734    return ToTypeOrErr.takeError();
6735
6736  ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6737  if (!ToLocationOrErr)
6738    return ToLocationOrErr.takeError();
6739
6740  return IntegerLiteral::Create(
6741      Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
6742}
6743
6744
6745ExpectedStmt ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
6746  ExpectedType ToTypeOrErr = import(E->getType());
6747  if (!ToTypeOrErr)
6748    return ToTypeOrErr.takeError();
6749
6750  ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6751  if (!ToLocationOrErr)
6752    return ToLocationOrErr.takeError();
6753
6754  return FloatingLiteral::Create(
6755      Importer.getToContext(), E->getValue(), E->isExact(),
6756      *ToTypeOrErr, *ToLocationOrErr);
6757}
6758
6759ExpectedStmt ASTNodeImporter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
6760  auto ToTypeOrErr = import(E->getType());
6761  if (!ToTypeOrErr)
6762    return ToTypeOrErr.takeError();
6763
6764  ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
6765  if (!ToSubExprOrErr)
6766    return ToSubExprOrErr.takeError();
6767
6768  return new (Importer.getToContext()) ImaginaryLiteral(
6769      *ToSubExprOrErr, *ToTypeOrErr);
6770}
6771
6772ExpectedStmt ASTNodeImporter::VisitFixedPointLiteral(FixedPointLiteral *E) {
6773  auto ToTypeOrErr = import(E->getType());
6774  if (!ToTypeOrErr)
6775    return ToTypeOrErr.takeError();
6776
6777  ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6778  if (!ToLocationOrErr)
6779    return ToLocationOrErr.takeError();
6780
6781  return new (Importer.getToContext()) FixedPointLiteral(
6782      Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr,
6783      Importer.getToContext().getFixedPointScale(*ToTypeOrErr));
6784}
6785
6786ExpectedStmt ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
6787  ExpectedType ToTypeOrErr = import(E->getType());
6788  if (!ToTypeOrErr)
6789    return ToTypeOrErr.takeError();
6790
6791  ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6792  if (!ToLocationOrErr)
6793    return ToLocationOrErr.takeError();
6794
6795  return new (Importer.getToContext()) CharacterLiteral(
6796      E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
6797}
6798
6799ExpectedStmt ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
6800  ExpectedType ToTypeOrErr = import(E->getType());
6801  if (!ToTypeOrErr)
6802    return ToTypeOrErr.takeError();
6803
6804  SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated());
6805  if (Error Err = ImportArrayChecked(
6806      E->tokloc_begin(), E->tokloc_end(), ToLocations.begin()))
6807    return std::move(Err);
6808
6809  return StringLiteral::Create(
6810      Importer.getToContext(), E->getBytes(), E->getKind(), E->isPascal(),
6811      *ToTypeOrErr, ToLocations.data(), ToLocations.size());
6812}
6813
6814ExpectedStmt ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
6815
6816  Error Err = Error::success();
6817  auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
6818  auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
6819  auto ToType = importChecked(Err, E->getType());
6820  auto ToInitializer = importChecked(Err, E->getInitializer());
6821  if (Err)
6822    return std::move(Err);
6823
6824  return new (Importer.getToContext()) CompoundLiteralExpr(
6825        ToLParenLoc, ToTypeSourceInfo, ToType, E->getValueKind(),
6826        ToInitializer, E->isFileScope());
6827}
6828
6829ExpectedStmt ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
6830
6831  Error Err = Error::success();
6832  auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
6833  auto ToType = importChecked(Err, E->getType());
6834  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6835  if (Err)
6836    return std::move(Err);
6837
6838  SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs());
6839  if (Error Err = ImportArrayChecked(
6840      E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
6841      ToExprs.begin()))
6842    return std::move(Err);
6843
6844  return new (Importer.getToContext()) AtomicExpr(
6845
6846      ToBuiltinLoc, ToExprs, ToType, E->getOp(), ToRParenLoc);
6847}
6848
6849ExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
6850  Error Err = Error::success();
6851  auto ToAmpAmpLoc = importChecked(Err, E->getAmpAmpLoc());
6852  auto ToLabelLoc = importChecked(Err, E->getLabelLoc());
6853  auto ToLabel = importChecked(Err, E->getLabel());
6854  auto ToType = importChecked(Err, E->getType());
6855  if (Err)
6856    return std::move(Err);
6857
6858  return new (Importer.getToContext()) AddrLabelExpr(
6859      ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
6860}
6861ExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) {
6862  Error Err = Error::success();
6863  auto ToSubExpr = importChecked(Err, E->getSubExpr());
6864  auto ToResult = importChecked(Err, E->getAPValueResult());
6865  if (Err)
6866    return std::move(Err);
6867
6868  return ConstantExpr::Create(Importer.getToContext(), ToSubExpr, ToResult);
6869}
6870ExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
6871  Error Err = Error::success();
6872  auto ToLParen = importChecked(Err, E->getLParen());
6873  auto ToRParen = importChecked(Err, E->getRParen());
6874  auto ToSubExpr = importChecked(Err, E->getSubExpr());
6875  if (Err)
6876    return std::move(Err);
6877
6878  return new (Importer.getToContext())
6879      ParenExpr(ToLParen, ToRParen, ToSubExpr);
6880}
6881
6882ExpectedStmt ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
6883  SmallVector<Expr *, 4> ToExprs(E->getNumExprs());
6884  if (Error Err = ImportContainerChecked(E->exprs(), ToExprs))
6885    return std::move(Err);
6886
6887  ExpectedSLoc ToLParenLocOrErr = import(E->getLParenLoc());
6888  if (!ToLParenLocOrErr)
6889    return ToLParenLocOrErr.takeError();
6890
6891  ExpectedSLoc ToRParenLocOrErr = import(E->getRParenLoc());
6892  if (!ToRParenLocOrErr)
6893    return ToRParenLocOrErr.takeError();
6894
6895  return ParenListExpr::Create(Importer.getToContext(), *ToLParenLocOrErr,
6896                               ToExprs, *ToRParenLocOrErr);
6897}
6898
6899ExpectedStmt ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
6900  Error Err = Error::success();
6901  auto ToSubStmt = importChecked(Err, E->getSubStmt());
6902  auto ToType = importChecked(Err, E->getType());
6903  auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
6904  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6905  if (Err)
6906    return std::move(Err);
6907
6908  return new (Importer.getToContext())
6909      StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
6910               E->getTemplateDepth());
6911}
6912
6913ExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
6914  Error Err = Error::success();
6915  auto ToSubExpr = importChecked(Err, E->getSubExpr());
6916  auto ToType = importChecked(Err, E->getType());
6917  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
6918  if (Err)
6919    return std::move(Err);
6920
6921  return UnaryOperator::Create(
6922      Importer.getToContext(), ToSubExpr, E->getOpcode(), ToType,
6923      E->getValueKind(), E->getObjectKind(), ToOperatorLoc, E->canOverflow(),
6924      E->getFPOptionsOverride());
6925}
6926
6927ExpectedStmt
6928
6929ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
6930  Error Err = Error::success();
6931  auto ToType = importChecked(Err, E->getType());
6932  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
6933  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6934  if (Err)
6935    return std::move(Err);
6936
6937  if (E->isArgumentType()) {
6938    Expected<TypeSourceInfo *> ToArgumentTypeInfoOrErr =
6939        import(E->getArgumentTypeInfo());
6940    if (!ToArgumentTypeInfoOrErr)
6941      return ToArgumentTypeInfoOrErr.takeError();
6942
6943    return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
6944        E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
6945        ToRParenLoc);
6946  }
6947
6948  ExpectedExpr ToArgumentExprOrErr = import(E->getArgumentExpr());
6949  if (!ToArgumentExprOrErr)
6950    return ToArgumentExprOrErr.takeError();
6951
6952  return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
6953      E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
6954}
6955
6956ExpectedStmt ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
6957  Error Err = Error::success();
6958  auto ToLHS = importChecked(Err, E->getLHS());
6959  auto ToRHS = importChecked(Err, E->getRHS());
6960  auto ToType = importChecked(Err, E->getType());
6961  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
6962  if (Err)
6963    return std::move(Err);
6964
6965  return BinaryOperator::Create(
6966      Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
6967      E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
6968      E->getFPFeatures(Importer.getFromContext().getLangOpts()));
6969}
6970
6971ExpectedStmt ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
6972  Error Err = Error::success();
6973  auto ToCond = importChecked(Err, E->getCond());
6974  auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
6975  auto ToLHS = importChecked(Err, E->getLHS());
6976  auto ToColonLoc = importChecked(Err, E->getColonLoc());
6977  auto ToRHS = importChecked(Err, E->getRHS());
6978  auto ToType = importChecked(Err, E->getType());
6979  if (Err)
6980    return std::move(Err);
6981
6982  return new (Importer.getToContext()) ConditionalOperator(
6983      ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
6984      E->getValueKind(), E->getObjectKind());
6985}
6986
6987ExpectedStmt
6988ASTNodeImporter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
6989  Error Err = Error::success();
6990  auto ToCommon = importChecked(Err, E->getCommon());
6991  auto ToOpaqueValue = importChecked(Err, E->getOpaqueValue());
6992  auto ToCond = importChecked(Err, E->getCond());
6993  auto ToTrueExpr = importChecked(Err, E->getTrueExpr());
6994  auto ToFalseExpr = importChecked(Err, E->getFalseExpr());
6995  auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
6996  auto ToColonLoc = importChecked(Err, E->getColonLoc());
6997  auto ToType = importChecked(Err, E->getType());
6998  if (Err)
6999    return std::move(Err);
7000
7001  return new (Importer.getToContext()) BinaryConditionalOperator(
7002      ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
7003      ToQuestionLoc, ToColonLoc, ToType, E->getValueKind(),
7004      E->getObjectKind());
7005}
7006
7007ExpectedStmt ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
7008  Error Err = Error::success();
7009  auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7010  auto ToQueriedTypeSourceInfo =
7011      importChecked(Err, E->getQueriedTypeSourceInfo());
7012  auto ToDimensionExpression = importChecked(Err, E->getDimensionExpression());
7013  auto ToEndLoc = importChecked(Err, E->getEndLoc());
7014  auto ToType = importChecked(Err, E->getType());
7015  if (Err)
7016    return std::move(Err);
7017
7018  return new (Importer.getToContext()) ArrayTypeTraitExpr(
7019      ToBeginLoc, E->getTrait(), ToQueriedTypeSourceInfo, E->getValue(),
7020      ToDimensionExpression, ToEndLoc, ToType);
7021}
7022
7023ExpectedStmt ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
7024  Error Err = Error::success();
7025  auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7026  auto ToQueriedExpression = importChecked(Err, E->getQueriedExpression());
7027  auto ToEndLoc = importChecked(Err, E->getEndLoc());
7028  auto ToType = importChecked(Err, E->getType());
7029  if (Err)
7030    return std::move(Err);
7031
7032  return new (Importer.getToContext()) ExpressionTraitExpr(
7033      ToBeginLoc, E->getTrait(), ToQueriedExpression, E->getValue(),
7034      ToEndLoc, ToType);
7035}
7036
7037ExpectedStmt ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
7038  Error Err = Error::success();
7039  auto ToLocation = importChecked(Err, E->getLocation());
7040  auto ToType = importChecked(Err, E->getType());
7041  auto ToSourceExpr = importChecked(Err, E->getSourceExpr());
7042  if (Err)
7043    return std::move(Err);
7044
7045  return new (Importer.getToContext()) OpaqueValueExpr(
7046      ToLocation, ToType, E->getValueKind(), E->getObjectKind(), ToSourceExpr);
7047}
7048
7049ExpectedStmt ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
7050  Error Err = Error::success();
7051  auto ToLHS = importChecked(Err, E->getLHS());
7052  auto ToRHS = importChecked(Err, E->getRHS());
7053  auto ToType = importChecked(Err, E->getType());
7054  auto ToRBracketLoc = importChecked(Err, E->getRBracketLoc());
7055  if (Err)
7056    return std::move(Err);
7057
7058  return new (Importer.getToContext()) ArraySubscriptExpr(
7059      ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(),
7060      ToRBracketLoc);
7061}
7062
7063ExpectedStmt
7064ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
7065  Error Err = Error::success();
7066  auto ToLHS = importChecked(Err, E->getLHS());
7067  auto ToRHS = importChecked(Err, E->getRHS());
7068  auto ToType = importChecked(Err, E->getType());
7069  auto ToComputationLHSType = importChecked(Err, E->getComputationLHSType());
7070  auto ToComputationResultType =
7071      importChecked(Err, E->getComputationResultType());
7072  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7073  if (Err)
7074    return std::move(Err);
7075
7076  return CompoundAssignOperator::Create(
7077      Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
7078      E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
7079      E->getFPFeatures(Importer.getFromContext().getLangOpts()),
7080      ToComputationLHSType, ToComputationResultType);
7081}
7082
7083Expected<CXXCastPath>
7084ASTNodeImporter::ImportCastPath(CastExpr *CE) {
7085  CXXCastPath Path;
7086  for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
7087    if (auto SpecOrErr = import(*I))
7088      Path.push_back(*SpecOrErr);
7089    else
7090      return SpecOrErr.takeError();
7091  }
7092  return Path;
7093}
7094
7095ExpectedStmt ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
7096  ExpectedType ToTypeOrErr = import(E->getType());
7097  if (!ToTypeOrErr)
7098    return ToTypeOrErr.takeError();
7099
7100  ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7101  if (!ToSubExprOrErr)
7102    return ToSubExprOrErr.takeError();
7103
7104  Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E);
7105  if (!ToBasePathOrErr)
7106    return ToBasePathOrErr.takeError();
7107
7108  return ImplicitCastExpr::Create(
7109      Importer.getToContext(), *ToTypeOrErr, E->getCastKind(), *ToSubExprOrErr,
7110      &(*ToBasePathOrErr), E->getValueKind(), E->getFPFeatures());
7111}
7112
7113ExpectedStmt ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
7114  Error Err = Error::success();
7115  auto ToType = importChecked(Err, E->getType());
7116  auto ToSubExpr = importChecked(Err, E->getSubExpr());
7117  auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
7118  if (Err)
7119    return std::move(Err);
7120
7121  Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E);
7122  if (!ToBasePathOrErr)
7123    return ToBasePathOrErr.takeError();
7124  CXXCastPath *ToBasePath = &(*ToBasePathOrErr);
7125
7126  switch (E->getStmtClass()) {
7127  case Stmt::CStyleCastExprClass: {
7128    auto *CCE = cast<CStyleCastExpr>(E);
7129    ExpectedSLoc ToLParenLocOrErr = import(CCE->getLParenLoc());
7130    if (!ToLParenLocOrErr)
7131      return ToLParenLocOrErr.takeError();
7132    ExpectedSLoc ToRParenLocOrErr = import(CCE->getRParenLoc());
7133    if (!ToRParenLocOrErr)
7134      return ToRParenLocOrErr.takeError();
7135    return CStyleCastExpr::Create(
7136        Importer.getToContext(), ToType, E->getValueKind(), E->getCastKind(),
7137        ToSubExpr, ToBasePath, CCE->getFPFeatures(), ToTypeInfoAsWritten,
7138        *ToLParenLocOrErr, *ToRParenLocOrErr);
7139  }
7140
7141  case Stmt::CXXFunctionalCastExprClass: {
7142    auto *FCE = cast<CXXFunctionalCastExpr>(E);
7143    ExpectedSLoc ToLParenLocOrErr = import(FCE->getLParenLoc());
7144    if (!ToLParenLocOrErr)
7145      return ToLParenLocOrErr.takeError();
7146    ExpectedSLoc ToRParenLocOrErr = import(FCE->getRParenLoc());
7147    if (!ToRParenLocOrErr)
7148      return ToRParenLocOrErr.takeError();
7149    return CXXFunctionalCastExpr::Create(
7150        Importer.getToContext(), ToType, E->getValueKind(), ToTypeInfoAsWritten,
7151        E->getCastKind(), ToSubExpr, ToBasePath, FCE->getFPFeatures(),
7152        *ToLParenLocOrErr, *ToRParenLocOrErr);
7153  }
7154
7155  case Stmt::ObjCBridgedCastExprClass: {
7156    auto *OCE = cast<ObjCBridgedCastExpr>(E);
7157    ExpectedSLoc ToLParenLocOrErr = import(OCE->getLParenLoc());
7158    if (!ToLParenLocOrErr)
7159      return ToLParenLocOrErr.takeError();
7160    ExpectedSLoc ToBridgeKeywordLocOrErr = import(OCE->getBridgeKeywordLoc());
7161    if (!ToBridgeKeywordLocOrErr)
7162      return ToBridgeKeywordLocOrErr.takeError();
7163    return new (Importer.getToContext()) ObjCBridgedCastExpr(
7164        *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(),
7165        *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
7166  }
7167  default:
7168    llvm_unreachable("Cast expression of unsupported type!");
7169    return make_error<ImportError>(ImportError::UnsupportedConstruct);
7170  }
7171}
7172
7173ExpectedStmt ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) {
7174  SmallVector<OffsetOfNode, 4> ToNodes;
7175  for (int I = 0, N = E->getNumComponents(); I < N; ++I) {
7176    const OffsetOfNode &FromNode = E->getComponent(I);
7177
7178    SourceLocation ToBeginLoc, ToEndLoc;
7179
7180    if (FromNode.getKind() != OffsetOfNode::Base) {
7181      Error Err = Error::success();
7182      ToBeginLoc = importChecked(Err, FromNode.getBeginLoc());
7183      ToEndLoc = importChecked(Err, FromNode.getEndLoc());
7184      if (Err)
7185        return std::move(Err);
7186    }
7187
7188    switch (FromNode.getKind()) {
7189    case OffsetOfNode::Array:
7190      ToNodes.push_back(
7191          OffsetOfNode(ToBeginLoc, FromNode.getArrayExprIndex(), ToEndLoc));
7192      break;
7193    case OffsetOfNode::Base: {
7194      auto ToBSOrErr = import(FromNode.getBase());
7195      if (!ToBSOrErr)
7196        return ToBSOrErr.takeError();
7197      ToNodes.push_back(OffsetOfNode(*ToBSOrErr));
7198      break;
7199    }
7200    case OffsetOfNode::Field: {
7201      auto ToFieldOrErr = import(FromNode.getField());
7202      if (!ToFieldOrErr)
7203        return ToFieldOrErr.takeError();
7204      ToNodes.push_back(OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
7205      break;
7206    }
7207    case OffsetOfNode::Identifier: {
7208      IdentifierInfo *ToII = Importer.Import(FromNode.getFieldName());
7209      ToNodes.push_back(OffsetOfNode(ToBeginLoc, ToII, ToEndLoc));
7210      break;
7211    }
7212    }
7213  }
7214
7215  SmallVector<Expr *, 4> ToExprs(E->getNumExpressions());
7216  for (int I = 0, N = E->getNumExpressions(); I < N; ++I) {
7217    ExpectedExpr ToIndexExprOrErr = import(E->getIndexExpr(I));
7218    if (!ToIndexExprOrErr)
7219      return ToIndexExprOrErr.takeError();
7220    ToExprs[I] = *ToIndexExprOrErr;
7221  }
7222
7223  Error Err = Error::success();
7224  auto ToType = importChecked(Err, E->getType());
7225  auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7226  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7227  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7228  if (Err)
7229    return std::move(Err);
7230
7231  return OffsetOfExpr::Create(
7232      Importer.getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes,
7233      ToExprs, ToRParenLoc);
7234}
7235
7236ExpectedStmt ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
7237  Error Err = Error::success();
7238  auto ToType = importChecked(Err, E->getType());
7239  auto ToOperand = importChecked(Err, E->getOperand());
7240  auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7241  auto ToEndLoc = importChecked(Err, E->getEndLoc());
7242  if (Err)
7243    return std::move(Err);
7244
7245  CanThrowResult ToCanThrow;
7246  if (E->isValueDependent())
7247    ToCanThrow = CT_Dependent;
7248  else
7249    ToCanThrow = E->getValue() ? CT_Can : CT_Cannot;
7250
7251  return new (Importer.getToContext()) CXXNoexceptExpr(
7252      ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
7253}
7254
7255ExpectedStmt ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
7256  Error Err = Error::success();
7257  auto ToSubExpr = importChecked(Err, E->getSubExpr());
7258  auto ToType = importChecked(Err, E->getType());
7259  auto ToThrowLoc = importChecked(Err, E->getThrowLoc());
7260  if (Err)
7261    return std::move(Err);
7262
7263  return new (Importer.getToContext()) CXXThrowExpr(
7264      ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope());
7265}
7266
7267ExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
7268  ExpectedSLoc ToUsedLocOrErr = import(E->getUsedLocation());
7269  if (!ToUsedLocOrErr)
7270    return ToUsedLocOrErr.takeError();
7271
7272  auto ToParamOrErr = import(E->getParam());
7273  if (!ToParamOrErr)
7274    return ToParamOrErr.takeError();
7275
7276  auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext());
7277  if (!UsedContextOrErr)
7278    return UsedContextOrErr.takeError();
7279
7280  // Import the default arg if it was not imported yet.
7281  // This is needed because it can happen that during the import of the
7282  // default expression (from VisitParmVarDecl) the same ParmVarDecl is
7283  // encountered here. The default argument for a ParmVarDecl is set in the
7284  // ParmVarDecl only after it is imported (set in VisitParmVarDecl if not here,
7285  // see VisitParmVarDecl).
7286  ParmVarDecl *ToParam = *ToParamOrErr;
7287  if (!ToParam->getDefaultArg()) {
7288    Optional<ParmVarDecl *> FromParam = Importer.getImportedFromDecl(ToParam);
7289    assert(FromParam && "ParmVarDecl was not imported?");
7290
7291    if (Error Err = ImportDefaultArgOfParmVarDecl(*FromParam, ToParam))
7292      return std::move(Err);
7293  }
7294
7295  return CXXDefaultArgExpr::Create(Importer.getToContext(), *ToUsedLocOrErr,
7296                                   *ToParamOrErr, *UsedContextOrErr);
7297}
7298
7299ExpectedStmt
7300ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
7301  Error Err = Error::success();
7302  auto ToType = importChecked(Err, E->getType());
7303  auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7304  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7305  if (Err)
7306    return std::move(Err);
7307
7308  return new (Importer.getToContext()) CXXScalarValueInitExpr(
7309      ToType, ToTypeSourceInfo, ToRParenLoc);
7310}
7311
7312ExpectedStmt
7313ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
7314  ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7315  if (!ToSubExprOrErr)
7316    return ToSubExprOrErr.takeError();
7317
7318  auto ToDtorOrErr = import(E->getTemporary()->getDestructor());
7319  if (!ToDtorOrErr)
7320    return ToDtorOrErr.takeError();
7321
7322  ASTContext &ToCtx = Importer.getToContext();
7323  CXXTemporary *Temp = CXXTemporary::Create(ToCtx, *ToDtorOrErr);
7324  return CXXBindTemporaryExpr::Create(ToCtx, Temp, *ToSubExprOrErr);
7325}
7326
7327ExpectedStmt
7328
7329ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
7330  Error Err = Error::success();
7331  auto ToConstructor = importChecked(Err, E->getConstructor());
7332  auto ToType = importChecked(Err, E->getType());
7333  auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7334  auto ToParenOrBraceRange = importChecked(Err, E->getParenOrBraceRange());
7335  if (Err)
7336    return std::move(Err);
7337
7338  SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
7339  if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7340    return std::move(Err);
7341
7342  return CXXTemporaryObjectExpr::Create(
7343      Importer.getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs,
7344      ToParenOrBraceRange, E->hadMultipleCandidates(),
7345      E->isListInitialization(), E->isStdInitListInitialization(),
7346      E->requiresZeroInitialization());
7347}
7348
7349ExpectedDecl ASTNodeImporter::VisitLifetimeExtendedTemporaryDecl(
7350    LifetimeExtendedTemporaryDecl *D) {
7351  DeclContext *DC, *LexicalDC;
7352  if (Error Err = ImportDeclContext(D, DC, LexicalDC))
7353    return std::move(Err);
7354
7355  Error Err = Error::success();
7356  auto Temporary = importChecked(Err, D->getTemporaryExpr());
7357  auto ExtendingDecl = importChecked(Err, D->getExtendingDecl());
7358  if (Err)
7359    return std::move(Err);
7360  // FIXME: Should ManglingNumber get numbers associated with 'to' context?
7361
7362  LifetimeExtendedTemporaryDecl *To;
7363  if (GetImportedOrCreateDecl(To, D, Temporary, ExtendingDecl,
7364                              D->getManglingNumber()))
7365    return To;
7366
7367  To->setLexicalDeclContext(LexicalDC);
7368  LexicalDC->addDeclInternal(To);
7369  return To;
7370}
7371
7372ExpectedStmt
7373ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
7374  Error Err = Error::success();
7375  auto ToType = importChecked(Err, E->getType());
7376  Expr *ToTemporaryExpr = importChecked(
7377      Err, E->getLifetimeExtendedTemporaryDecl() ? nullptr : E->getSubExpr());
7378  auto ToMaterializedDecl =
7379      importChecked(Err, E->getLifetimeExtendedTemporaryDecl());
7380  if (Err)
7381    return std::move(Err);
7382
7383  if (!ToTemporaryExpr)
7384    ToTemporaryExpr = cast<Expr>(ToMaterializedDecl->getTemporaryExpr());
7385
7386  auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
7387      ToType, ToTemporaryExpr, E->isBoundToLvalueReference(),
7388      ToMaterializedDecl);
7389
7390  return ToMTE;
7391}
7392
7393ExpectedStmt ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
7394  Error Err = Error::success();
7395  auto ToType = importChecked(Err, E->getType());
7396  auto ToPattern = importChecked(Err, E->getPattern());
7397  auto ToEllipsisLoc = importChecked(Err, E->getEllipsisLoc());
7398  if (Err)
7399    return std::move(Err);
7400
7401  return new (Importer.getToContext()) PackExpansionExpr(
7402      ToType, ToPattern, ToEllipsisLoc, E->getNumExpansions());
7403}
7404
7405ExpectedStmt ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
7406  Error Err = Error::success();
7407  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7408  auto ToPack = importChecked(Err, E->getPack());
7409  auto ToPackLoc = importChecked(Err, E->getPackLoc());
7410  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7411  if (Err)
7412    return std::move(Err);
7413
7414  Optional<unsigned> Length;
7415  if (!E->isValueDependent())
7416    Length = E->getPackLength();
7417
7418  SmallVector<TemplateArgument, 8> ToPartialArguments;
7419  if (E->isPartiallySubstituted()) {
7420    if (Error Err = ImportTemplateArguments(
7421        E->getPartialArguments().data(),
7422        E->getPartialArguments().size(),
7423        ToPartialArguments))
7424      return std::move(Err);
7425  }
7426
7427  return SizeOfPackExpr::Create(
7428      Importer.getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
7429      Length, ToPartialArguments);
7430}
7431
7432
7433ExpectedStmt ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) {
7434  Error Err = Error::success();
7435  auto ToOperatorNew = importChecked(Err, E->getOperatorNew());
7436  auto ToOperatorDelete = importChecked(Err, E->getOperatorDelete());
7437  auto ToTypeIdParens = importChecked(Err, E->getTypeIdParens());
7438  auto ToArraySize = importChecked(Err, E->getArraySize());
7439  auto ToInitializer = importChecked(Err, E->getInitializer());
7440  auto ToType = importChecked(Err, E->getType());
7441  auto ToAllocatedTypeSourceInfo =
7442      importChecked(Err, E->getAllocatedTypeSourceInfo());
7443  auto ToSourceRange = importChecked(Err, E->getSourceRange());
7444  auto ToDirectInitRange = importChecked(Err, E->getDirectInitRange());
7445  if (Err)
7446    return std::move(Err);
7447
7448  SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs());
7449  if (Error Err =
7450      ImportContainerChecked(E->placement_arguments(), ToPlacementArgs))
7451    return std::move(Err);
7452
7453  return CXXNewExpr::Create(
7454      Importer.getToContext(), E->isGlobalNew(), ToOperatorNew,
7455      ToOperatorDelete, E->passAlignment(), E->doesUsualArrayDeleteWantSize(),
7456      ToPlacementArgs, ToTypeIdParens, ToArraySize, E->getInitializationStyle(),
7457      ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange,
7458      ToDirectInitRange);
7459}
7460
7461ExpectedStmt ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
7462  Error Err = Error::success();
7463  auto ToType = importChecked(Err, E->getType());
7464  auto ToOperatorDelete = importChecked(Err, E->getOperatorDelete());
7465  auto ToArgument = importChecked(Err, E->getArgument());
7466  auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7467  if (Err)
7468    return std::move(Err);
7469
7470  return new (Importer.getToContext()) CXXDeleteExpr(
7471      ToType, E->isGlobalDelete(), E->isArrayForm(), E->isArrayFormAsWritten(),
7472      E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument,
7473      ToBeginLoc);
7474}
7475
7476ExpectedStmt ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
7477  Error Err = Error::success();
7478  auto ToType = importChecked(Err, E->getType());
7479  auto ToLocation = importChecked(Err, E->getLocation());
7480  auto ToConstructor = importChecked(Err, E->getConstructor());
7481  auto ToParenOrBraceRange = importChecked(Err, E->getParenOrBraceRange());
7482  if (Err)
7483    return std::move(Err);
7484
7485  SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
7486  if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7487    return std::move(Err);
7488
7489  return CXXConstructExpr::Create(
7490      Importer.getToContext(), ToType, ToLocation, ToConstructor,
7491      E->isElidable(), ToArgs, E->hadMultipleCandidates(),
7492      E->isListInitialization(), E->isStdInitListInitialization(),
7493      E->requiresZeroInitialization(), E->getConstructionKind(),
7494      ToParenOrBraceRange);
7495}
7496
7497ExpectedStmt ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *E) {
7498  ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7499  if (!ToSubExprOrErr)
7500    return ToSubExprOrErr.takeError();
7501
7502  SmallVector<ExprWithCleanups::CleanupObject, 8> ToObjects(E->getNumObjects());
7503  if (Error Err = ImportContainerChecked(E->getObjects(), ToObjects))
7504    return std::move(Err);
7505
7506  return ExprWithCleanups::Create(
7507      Importer.getToContext(), *ToSubExprOrErr, E->cleanupsHaveSideEffects(),
7508      ToObjects);
7509}
7510
7511ExpectedStmt ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
7512  Error Err = Error::success();
7513  auto ToCallee = importChecked(Err, E->getCallee());
7514  auto ToType = importChecked(Err, E->getType());
7515  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7516  if (Err)
7517    return std::move(Err);
7518
7519  SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
7520  if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7521    return std::move(Err);
7522
7523  return CXXMemberCallExpr::Create(Importer.getToContext(), ToCallee, ToArgs,
7524                                   ToType, E->getValueKind(), ToRParenLoc,
7525                                   E->getFPFeatures());
7526}
7527
7528ExpectedStmt ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
7529  ExpectedType ToTypeOrErr = import(E->getType());
7530  if (!ToTypeOrErr)
7531    return ToTypeOrErr.takeError();
7532
7533  ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7534  if (!ToLocationOrErr)
7535    return ToLocationOrErr.takeError();
7536
7537  return new (Importer.getToContext()) CXXThisExpr(
7538      *ToLocationOrErr, *ToTypeOrErr, E->isImplicit());
7539}
7540
7541ExpectedStmt ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
7542  ExpectedType ToTypeOrErr = import(E->getType());
7543  if (!ToTypeOrErr)
7544    return ToTypeOrErr.takeError();
7545
7546  ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7547  if (!ToLocationOrErr)
7548    return ToLocationOrErr.takeError();
7549
7550  return new (Importer.getToContext()) CXXBoolLiteralExpr(
7551      E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
7552}
7553
7554ExpectedStmt ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
7555  Error Err = Error::success();
7556  auto ToBase = importChecked(Err, E->getBase());
7557  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7558  auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7559  auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7560  auto ToMemberDecl = importChecked(Err, E->getMemberDecl());
7561  auto ToType = importChecked(Err, E->getType());
7562  auto ToDecl = importChecked(Err, E->getFoundDecl().getDecl());
7563  auto ToName = importChecked(Err, E->getMemberNameInfo().getName());
7564  auto ToLoc = importChecked(Err, E->getMemberNameInfo().getLoc());
7565  if (Err)
7566    return std::move(Err);
7567
7568  DeclAccessPair ToFoundDecl =
7569      DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess());
7570
7571  DeclarationNameInfo ToMemberNameInfo(ToName, ToLoc);
7572
7573  TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
7574  if (E->hasExplicitTemplateArgs()) {
7575    if (Error Err =
7576            ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
7577                                           E->template_arguments(), ToTAInfo))
7578      return std::move(Err);
7579    ResInfo = &ToTAInfo;
7580  }
7581
7582  return MemberExpr::Create(Importer.getToContext(), ToBase, E->isArrow(),
7583                            ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
7584                            ToMemberDecl, ToFoundDecl, ToMemberNameInfo,
7585                            ResInfo, ToType, E->getValueKind(),
7586                            E->getObjectKind(), E->isNonOdrUse());
7587}
7588
7589ExpectedStmt
7590ASTNodeImporter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
7591  Error Err = Error::success();
7592  auto ToBase = importChecked(Err, E->getBase());
7593  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7594  auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7595  auto ToScopeTypeInfo = importChecked(Err, E->getScopeTypeInfo());
7596  auto ToColonColonLoc = importChecked(Err, E->getColonColonLoc());
7597  auto ToTildeLoc = importChecked(Err, E->getTildeLoc());
7598  if (Err)
7599    return std::move(Err);
7600
7601  PseudoDestructorTypeStorage Storage;
7602  if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
7603    IdentifierInfo *ToII = Importer.Import(FromII);
7604    ExpectedSLoc ToDestroyedTypeLocOrErr = import(E->getDestroyedTypeLoc());
7605    if (!ToDestroyedTypeLocOrErr)
7606      return ToDestroyedTypeLocOrErr.takeError();
7607    Storage = PseudoDestructorTypeStorage(ToII, *ToDestroyedTypeLocOrErr);
7608  } else {
7609    if (auto ToTIOrErr = import(E->getDestroyedTypeInfo()))
7610      Storage = PseudoDestructorTypeStorage(*ToTIOrErr);
7611    else
7612      return ToTIOrErr.takeError();
7613  }
7614
7615  return new (Importer.getToContext()) CXXPseudoDestructorExpr(
7616      Importer.getToContext(), ToBase, E->isArrow(), ToOperatorLoc,
7617      ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage);
7618}
7619
7620ExpectedStmt ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
7621    CXXDependentScopeMemberExpr *E) {
7622  Error Err = Error::success();
7623  auto ToType = importChecked(Err, E->getType());
7624  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7625  auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7626  auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7627  auto ToFirstQualifierFoundInScope =
7628      importChecked(Err, E->getFirstQualifierFoundInScope());
7629  if (Err)
7630    return std::move(Err);
7631
7632  Expr *ToBase = nullptr;
7633  if (!E->isImplicitAccess()) {
7634    if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
7635      ToBase = *ToBaseOrErr;
7636    else
7637      return ToBaseOrErr.takeError();
7638  }
7639
7640  TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
7641
7642  if (E->hasExplicitTemplateArgs()) {
7643    if (Error Err =
7644            ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
7645                                           E->template_arguments(), ToTAInfo))
7646      return std::move(Err);
7647    ResInfo = &ToTAInfo;
7648  }
7649  auto ToMember = importChecked(Err, E->getMember());
7650  auto ToMemberLoc = importChecked(Err, E->getMemberLoc());
7651  if (Err)
7652    return std::move(Err);
7653  DeclarationNameInfo ToMemberNameInfo(ToMember, ToMemberLoc);
7654
7655  // Import additional name location/type info.
7656  if (Error Err =
7657          ImportDeclarationNameLoc(E->getMemberNameInfo(), ToMemberNameInfo))
7658    return std::move(Err);
7659
7660  return CXXDependentScopeMemberExpr::Create(
7661      Importer.getToContext(), ToBase, ToType, E->isArrow(), ToOperatorLoc,
7662      ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope,
7663      ToMemberNameInfo, ResInfo);
7664}
7665
7666ExpectedStmt
7667ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
7668  Error Err = Error::success();
7669  auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7670  auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7671  auto ToDeclName = importChecked(Err, E->getDeclName());
7672  auto ToNameLoc = importChecked(Err, E->getNameInfo().getLoc());
7673  auto ToLAngleLoc = importChecked(Err, E->getLAngleLoc());
7674  auto ToRAngleLoc = importChecked(Err, E->getRAngleLoc());
7675  if (Err)
7676    return std::move(Err);
7677
7678  DeclarationNameInfo ToNameInfo(ToDeclName, ToNameLoc);
7679  if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
7680    return std::move(Err);
7681
7682  TemplateArgumentListInfo ToTAInfo(ToLAngleLoc, ToRAngleLoc);
7683  TemplateArgumentListInfo *ResInfo = nullptr;
7684  if (E->hasExplicitTemplateArgs()) {
7685    if (Error Err =
7686        ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
7687      return std::move(Err);
7688    ResInfo = &ToTAInfo;
7689  }
7690
7691  return DependentScopeDeclRefExpr::Create(
7692      Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc,
7693      ToNameInfo, ResInfo);
7694}
7695
7696ExpectedStmt ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
7697    CXXUnresolvedConstructExpr *E) {
7698  Error Err = Error::success();
7699  auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
7700  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7701  auto ToType = importChecked(Err, E->getType());
7702  auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7703  if (Err)
7704    return std::move(Err);
7705
7706  SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
7707  if (Error Err =
7708      ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin()))
7709    return std::move(Err);
7710
7711  return CXXUnresolvedConstructExpr::Create(
7712      Importer.getToContext(), ToType, ToTypeSourceInfo, ToLParenLoc,
7713      llvm::makeArrayRef(ToArgs), ToRParenLoc);
7714}
7715
7716ExpectedStmt
7717ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
7718  Expected<CXXRecordDecl *> ToNamingClassOrErr = import(E->getNamingClass());
7719  if (!ToNamingClassOrErr)
7720    return ToNamingClassOrErr.takeError();
7721
7722  auto ToQualifierLocOrErr = import(E->getQualifierLoc());
7723  if (!ToQualifierLocOrErr)
7724    return ToQualifierLocOrErr.takeError();
7725
7726  Error Err = Error::success();
7727  auto ToName = importChecked(Err, E->getName());
7728  auto ToNameLoc = importChecked(Err, E->getNameLoc());
7729  if (Err)
7730    return std::move(Err);
7731  DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
7732
7733  // Import additional name location/type info.
7734  if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
7735    return std::move(Err);
7736
7737  UnresolvedSet<8> ToDecls;
7738  for (auto *D : E->decls())
7739    if (auto ToDOrErr = import(D))
7740      ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
7741    else
7742      return ToDOrErr.takeError();
7743
7744  if (E->hasExplicitTemplateArgs()) {
7745    TemplateArgumentListInfo ToTAInfo;
7746    if (Error Err = ImportTemplateArgumentListInfo(
7747        E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(),
7748        ToTAInfo))
7749      return std::move(Err);
7750
7751    ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc());
7752    if (!ToTemplateKeywordLocOrErr)
7753      return ToTemplateKeywordLocOrErr.takeError();
7754
7755    return UnresolvedLookupExpr::Create(
7756        Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
7757        *ToTemplateKeywordLocOrErr, ToNameInfo, E->requiresADL(), &ToTAInfo,
7758        ToDecls.begin(), ToDecls.end());
7759  }
7760
7761  return UnresolvedLookupExpr::Create(
7762      Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
7763      ToNameInfo, E->requiresADL(), E->isOverloaded(), ToDecls.begin(),
7764      ToDecls.end());
7765}
7766
7767ExpectedStmt
7768ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
7769  Error Err = Error::success();
7770  auto ToType = importChecked(Err, E->getType());
7771  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7772  auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7773  auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7774  auto ToName = importChecked(Err, E->getName());
7775  auto ToNameLoc = importChecked(Err, E->getNameLoc());
7776  if (Err)
7777    return std::move(Err);
7778
7779  DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
7780  // Import additional name location/type info.
7781  if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
7782    return std::move(Err);
7783
7784  UnresolvedSet<8> ToDecls;
7785  for (Decl *D : E->decls())
7786    if (auto ToDOrErr = import(D))
7787      ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
7788    else
7789      return ToDOrErr.takeError();
7790
7791  TemplateArgumentListInfo ToTAInfo;
7792  TemplateArgumentListInfo *ResInfo = nullptr;
7793  if (E->hasExplicitTemplateArgs()) {
7794    TemplateArgumentListInfo FromTAInfo;
7795    E->copyTemplateArgumentsInto(FromTAInfo);
7796    if (Error Err = ImportTemplateArgumentListInfo(FromTAInfo, ToTAInfo))
7797      return std::move(Err);
7798    ResInfo = &ToTAInfo;
7799  }
7800
7801  Expr *ToBase = nullptr;
7802  if (!E->isImplicitAccess()) {
7803    if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
7804      ToBase = *ToBaseOrErr;
7805    else
7806      return ToBaseOrErr.takeError();
7807  }
7808
7809  return UnresolvedMemberExpr::Create(
7810      Importer.getToContext(), E->hasUnresolvedUsing(), ToBase, ToType,
7811      E->isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
7812      ToNameInfo, ResInfo, ToDecls.begin(), ToDecls.end());
7813}
7814
7815ExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) {
7816  Error Err = Error::success();
7817  auto ToCallee = importChecked(Err, E->getCallee());
7818  auto ToType = importChecked(Err, E->getType());
7819  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7820  if (Err)
7821    return std::move(Err);
7822
7823  unsigned NumArgs = E->getNumArgs();
7824  llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
7825  if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7826     return std::move(Err);
7827
7828  if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
7829    return CXXOperatorCallExpr::Create(
7830        Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
7831        OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
7832        OCE->getADLCallKind());
7833  }
7834
7835  return CallExpr::Create(Importer.getToContext(), ToCallee, ToArgs, ToType,
7836                          E->getValueKind(), ToRParenLoc, E->getFPFeatures(),
7837                          /*MinNumArgs=*/0, E->getADLCallKind());
7838}
7839
7840ExpectedStmt ASTNodeImporter::VisitLambdaExpr(LambdaExpr *E) {
7841  CXXRecordDecl *FromClass = E->getLambdaClass();
7842  auto ToClassOrErr = import(FromClass);
7843  if (!ToClassOrErr)
7844    return ToClassOrErr.takeError();
7845  CXXRecordDecl *ToClass = *ToClassOrErr;
7846
7847  auto ToCallOpOrErr = import(E->getCallOperator());
7848  if (!ToCallOpOrErr)
7849    return ToCallOpOrErr.takeError();
7850
7851  SmallVector<Expr *, 8> ToCaptureInits(E->capture_size());
7852  if (Error Err = ImportContainerChecked(E->capture_inits(), ToCaptureInits))
7853    return std::move(Err);
7854
7855  Error Err = Error::success();
7856  auto ToIntroducerRange = importChecked(Err, E->getIntroducerRange());
7857  auto ToCaptureDefaultLoc = importChecked(Err, E->getCaptureDefaultLoc());
7858  auto ToEndLoc = importChecked(Err, E->getEndLoc());
7859  if (Err)
7860    return std::move(Err);
7861
7862  return LambdaExpr::Create(Importer.getToContext(), ToClass, ToIntroducerRange,
7863                            E->getCaptureDefault(), ToCaptureDefaultLoc,
7864                            E->hasExplicitParameters(),
7865                            E->hasExplicitResultType(), ToCaptureInits,
7866                            ToEndLoc, E->containsUnexpandedParameterPack());
7867}
7868
7869
7870ExpectedStmt ASTNodeImporter::VisitInitListExpr(InitListExpr *E) {
7871  Error Err = Error::success();
7872  auto ToLBraceLoc = importChecked(Err, E->getLBraceLoc());
7873  auto ToRBraceLoc = importChecked(Err, E->getRBraceLoc());
7874  auto ToType = importChecked(Err, E->getType());
7875  if (Err)
7876    return std::move(Err);
7877
7878  SmallVector<Expr *, 4> ToExprs(E->getNumInits());
7879  if (Error Err = ImportContainerChecked(E->inits(), ToExprs))
7880    return std::move(Err);
7881
7882  ASTContext &ToCtx = Importer.getToContext();
7883  InitListExpr *To = new (ToCtx) InitListExpr(
7884      ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
7885  To->setType(ToType);
7886
7887  if (E->hasArrayFiller()) {
7888    if (ExpectedExpr ToFillerOrErr = import(E->getArrayFiller()))
7889      To->setArrayFiller(*ToFillerOrErr);
7890    else
7891      return ToFillerOrErr.takeError();
7892  }
7893
7894  if (FieldDecl *FromFD = E->getInitializedFieldInUnion()) {
7895    if (auto ToFDOrErr = import(FromFD))
7896      To->setInitializedFieldInUnion(*ToFDOrErr);
7897    else
7898      return ToFDOrErr.takeError();
7899  }
7900
7901  if (InitListExpr *SyntForm = E->getSyntacticForm()) {
7902    if (auto ToSyntFormOrErr = import(SyntForm))
7903      To->setSyntacticForm(*ToSyntFormOrErr);
7904    else
7905      return ToSyntFormOrErr.takeError();
7906  }
7907
7908  // Copy InitListExprBitfields, which are not handled in the ctor of
7909  // InitListExpr.
7910  To->sawArrayRangeDesignator(E->hadArrayRangeDesignator());
7911
7912  return To;
7913}
7914
7915ExpectedStmt ASTNodeImporter::VisitCXXStdInitializerListExpr(
7916    CXXStdInitializerListExpr *E) {
7917  ExpectedType ToTypeOrErr = import(E->getType());
7918  if (!ToTypeOrErr)
7919    return ToTypeOrErr.takeError();
7920
7921  ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7922  if (!ToSubExprOrErr)
7923    return ToSubExprOrErr.takeError();
7924
7925  return new (Importer.getToContext()) CXXStdInitializerListExpr(
7926      *ToTypeOrErr, *ToSubExprOrErr);
7927}
7928
7929ExpectedStmt ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
7930    CXXInheritedCtorInitExpr *E) {
7931  Error Err = Error::success();
7932  auto ToLocation = importChecked(Err, E->getLocation());
7933  auto ToType = importChecked(Err, E->getType());
7934  auto ToConstructor = importChecked(Err, E->getConstructor());
7935  if (Err)
7936    return std::move(Err);
7937
7938  return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
7939      ToLocation, ToType, ToConstructor, E->constructsVBase(),
7940      E->inheritedFromVBase());
7941}
7942
7943ExpectedStmt ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
7944  Error Err = Error::success();
7945  auto ToType = importChecked(Err, E->getType());
7946  auto ToCommonExpr = importChecked(Err, E->getCommonExpr());
7947  auto ToSubExpr = importChecked(Err, E->getSubExpr());
7948  if (Err)
7949    return std::move(Err);
7950
7951  return new (Importer.getToContext()) ArrayInitLoopExpr(
7952      ToType, ToCommonExpr, ToSubExpr);
7953}
7954
7955ExpectedStmt ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
7956  ExpectedType ToTypeOrErr = import(E->getType());
7957  if (!ToTypeOrErr)
7958    return ToTypeOrErr.takeError();
7959  return new (Importer.getToContext()) ArrayInitIndexExpr(*ToTypeOrErr);
7960}
7961
7962ExpectedStmt ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
7963  ExpectedSLoc ToBeginLocOrErr = import(E->getBeginLoc());
7964  if (!ToBeginLocOrErr)
7965    return ToBeginLocOrErr.takeError();
7966
7967  auto ToFieldOrErr = import(E->getField());
7968  if (!ToFieldOrErr)
7969    return ToFieldOrErr.takeError();
7970
7971  auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext());
7972  if (!UsedContextOrErr)
7973    return UsedContextOrErr.takeError();
7974
7975  return CXXDefaultInitExpr::Create(
7976      Importer.getToContext(), *ToBeginLocOrErr, *ToFieldOrErr, *UsedContextOrErr);
7977}
7978
7979ExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
7980  Error Err = Error::success();
7981  auto ToType = importChecked(Err, E->getType());
7982  auto ToSubExpr = importChecked(Err, E->getSubExpr());
7983  auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
7984  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7985  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7986  auto ToAngleBrackets = importChecked(Err, E->getAngleBrackets());
7987  if (Err)
7988    return std::move(Err);
7989
7990  ExprValueKind VK = E->getValueKind();
7991  CastKind CK = E->getCastKind();
7992  auto ToBasePathOrErr = ImportCastPath(E);
7993  if (!ToBasePathOrErr)
7994    return ToBasePathOrErr.takeError();
7995
7996  if (auto CCE = dyn_cast<CXXStaticCastExpr>(E)) {
7997    return CXXStaticCastExpr::Create(
7998        Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
7999        ToTypeInfoAsWritten, CCE->getFPFeatures(), ToOperatorLoc, ToRParenLoc,
8000        ToAngleBrackets);
8001  } else if (isa<CXXDynamicCastExpr>(E)) {
8002    return CXXDynamicCastExpr::Create(
8003        Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8004        ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8005  } else if (isa<CXXReinterpretCastExpr>(E)) {
8006    return CXXReinterpretCastExpr::Create(
8007        Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8008        ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8009  } else if (isa<CXXConstCastExpr>(E)) {
8010    return CXXConstCastExpr::Create(
8011        Importer.getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten,
8012        ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8013  } else {
8014    llvm_unreachable("Unknown cast type");
8015    return make_error<ImportError>();
8016  }
8017}
8018
8019ExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
8020    SubstNonTypeTemplateParmExpr *E) {
8021  Error Err = Error::success();
8022  auto ToType = importChecked(Err, E->getType());
8023  auto ToExprLoc = importChecked(Err, E->getExprLoc());
8024  auto ToParameter = importChecked(Err, E->getParameter());
8025  auto ToReplacement = importChecked(Err, E->getReplacement());
8026  if (Err)
8027    return std::move(Err);
8028
8029  return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
8030      ToType, E->getValueKind(), ToExprLoc, ToParameter,
8031      E->isReferenceParameter(), ToReplacement);
8032}
8033
8034ExpectedStmt ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
8035  Error Err = Error::success();
8036  auto ToType = importChecked(Err, E->getType());
8037  auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
8038  auto ToEndLoc = importChecked(Err, E->getEndLoc());
8039  if (Err)
8040    return std::move(Err);
8041
8042  SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
8043  if (Error Err = ImportContainerChecked(E->getArgs(), ToArgs))
8044    return std::move(Err);
8045
8046  // According to Sema::BuildTypeTrait(), if E is value-dependent,
8047  // Value is always false.
8048  bool ToValue = (E->isValueDependent() ? false : E->getValue());
8049
8050  return TypeTraitExpr::Create(
8051      Importer.getToContext(), ToType, ToBeginLoc, E->getTrait(), ToArgs,
8052      ToEndLoc, ToValue);
8053}
8054
8055ExpectedStmt ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
8056  ExpectedType ToTypeOrErr = import(E->getType());
8057  if (!ToTypeOrErr)
8058    return ToTypeOrErr.takeError();
8059
8060  auto ToSourceRangeOrErr = import(E->getSourceRange());
8061  if (!ToSourceRangeOrErr)
8062    return ToSourceRangeOrErr.takeError();
8063
8064  if (E->isTypeOperand()) {
8065    if (auto ToTSIOrErr = import(E->getTypeOperandSourceInfo()))
8066      return new (Importer.getToContext()) CXXTypeidExpr(
8067          *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
8068    else
8069      return ToTSIOrErr.takeError();
8070  }
8071
8072  ExpectedExpr ToExprOperandOrErr = import(E->getExprOperand());
8073  if (!ToExprOperandOrErr)
8074    return ToExprOperandOrErr.takeError();
8075
8076  return new (Importer.getToContext()) CXXTypeidExpr(
8077      *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
8078}
8079
8080ExpectedStmt ASTNodeImporter::VisitCXXFoldExpr(CXXFoldExpr *E) {
8081  Error Err = Error::success();
8082
8083  QualType ToType = importChecked(Err, E->getType());
8084  UnresolvedLookupExpr *ToCallee = importChecked(Err, E->getCallee());
8085  SourceLocation ToLParenLoc = importChecked(Err, E->getLParenLoc());
8086  Expr *ToLHS = importChecked(Err, E->getLHS());
8087  SourceLocation ToEllipsisLoc = importChecked(Err, E->getEllipsisLoc());
8088  Expr *ToRHS = importChecked(Err, E->getRHS());
8089  SourceLocation ToRParenLoc = importChecked(Err, E->getRParenLoc());
8090
8091  if (Err)
8092    return std::move(Err);
8093
8094  return new (Importer.getToContext())
8095      CXXFoldExpr(ToType, ToCallee, ToLParenLoc, ToLHS, E->getOperator(),
8096                  ToEllipsisLoc, ToRHS, ToRParenLoc, E->getNumExpansions());
8097}
8098
8099Error ASTNodeImporter::ImportOverriddenMethods(CXXMethodDecl *ToMethod,
8100                                               CXXMethodDecl *FromMethod) {
8101  Error ImportErrors = Error::success();
8102  for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) {
8103    if (auto ImportedOrErr = import(FromOverriddenMethod))
8104      ToMethod->getCanonicalDecl()->addOverriddenMethod(cast<CXXMethodDecl>(
8105          (*ImportedOrErr)->getCanonicalDecl()));
8106    else
8107      ImportErrors =
8108          joinErrors(std::move(ImportErrors), ImportedOrErr.takeError());
8109  }
8110  return ImportErrors;
8111}
8112
8113ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
8114                         ASTContext &FromContext, FileManager &FromFileManager,
8115                         bool MinimalImport,
8116                         std::shared_ptr<ASTImporterSharedState> SharedState)
8117    : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
8118      ToFileManager(ToFileManager), FromFileManager(FromFileManager),
8119      Minimal(MinimalImport), ODRHandling(ODRHandlingType::Conservative) {
8120
8121  // Create a default state without the lookup table: LLDB case.
8122  if (!SharedState) {
8123    this->SharedState = std::make_shared<ASTImporterSharedState>();
8124  }
8125
8126  ImportedDecls[FromContext.getTranslationUnitDecl()] =
8127      ToContext.getTranslationUnitDecl();
8128}
8129
8130ASTImporter::~ASTImporter() = default;
8131
8132Optional<unsigned> ASTImporter::getFieldIndex(Decl *F) {
8133  assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
8134      "Try to get field index for non-field.");
8135
8136  auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
8137  if (!Owner)
8138    return None;
8139
8140  unsigned Index = 0;
8141  for (const auto *D : Owner->decls()) {
8142    if (D == F)
8143      return Index;
8144
8145    if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
8146      ++Index;
8147  }
8148
8149  llvm_unreachable("Field was not found in its parent context.");
8150
8151  return None;
8152}
8153
8154ASTImporter::FoundDeclsTy
8155ASTImporter::findDeclsInToCtx(DeclContext *DC, DeclarationName Name) {
8156  // We search in the redecl context because of transparent contexts.
8157  // E.g. a simple C language enum is a transparent context:
8158  //   enum E { A, B };
8159  // Now if we had a global variable in the TU
8160  //   int A;
8161  // then the enum constant 'A' and the variable 'A' violates ODR.
8162  // We can diagnose this only if we search in the redecl context.
8163  DeclContext *ReDC = DC->getRedeclContext();
8164  if (SharedState->getLookupTable()) {
8165    ASTImporterLookupTable::LookupResult LookupResult =
8166        SharedState->getLookupTable()->lookup(ReDC, Name);
8167    return FoundDeclsTy(LookupResult.begin(), LookupResult.end());
8168  } else {
8169    DeclContext::lookup_result NoloadLookupResult = ReDC->noload_lookup(Name);
8170    FoundDeclsTy Result(NoloadLookupResult.begin(), NoloadLookupResult.end());
8171    // We must search by the slow case of localUncachedLookup because that is
8172    // working even if there is no LookupPtr for the DC. We could use
8173    // DC::buildLookup() to create the LookupPtr, but that would load external
8174    // decls again, we must avoid that case.
8175    // Also, even if we had the LookupPtr, we must find Decls which are not
8176    // in the LookupPtr, so we need the slow case.
8177    // These cases are handled in ASTImporterLookupTable, but we cannot use
8178    // that with LLDB since that traverses through the AST which initiates the
8179    // load of external decls again via DC::decls().  And again, we must avoid
8180    // loading external decls during the import.
8181    if (Result.empty())
8182      ReDC->localUncachedLookup(Name, Result);
8183    return Result;
8184  }
8185}
8186
8187void ASTImporter::AddToLookupTable(Decl *ToD) {
8188  SharedState->addDeclToLookup(ToD);
8189}
8190
8191Expected<Decl *> ASTImporter::ImportImpl(Decl *FromD) {
8192  // Import the decl using ASTNodeImporter.
8193  ASTNodeImporter Importer(*this);
8194  return Importer.Visit(FromD);
8195}
8196
8197void ASTImporter::RegisterImportedDecl(Decl *FromD, Decl *ToD) {
8198  MapImported(FromD, ToD);
8199}
8200
8201llvm::Expected<ExprWithCleanups::CleanupObject>
8202ASTImporter::Import(ExprWithCleanups::CleanupObject From) {
8203  if (auto *CLE = From.dyn_cast<CompoundLiteralExpr *>()) {
8204    if (Expected<Expr *> R = Import(CLE))
8205      return ExprWithCleanups::CleanupObject(cast<CompoundLiteralExpr>(*R));
8206  }
8207
8208  // FIXME: Handle BlockDecl when we implement importing BlockExpr in
8209  //        ASTNodeImporter.
8210  return make_error<ImportError>(ImportError::UnsupportedConstruct);
8211}
8212
8213Expected<const Type *> ASTImporter::Import(const Type *FromT) {
8214  if (!FromT)
8215    return FromT;
8216
8217  // Check whether we've already imported this type.
8218  llvm::DenseMap<const Type *, const Type *>::iterator Pos =
8219      ImportedTypes.find(FromT);
8220  if (Pos != ImportedTypes.end())
8221    return Pos->second;
8222
8223  // Import the type
8224  ASTNodeImporter Importer(*this);
8225  ExpectedType ToTOrErr = Importer.Visit(FromT);
8226  if (!ToTOrErr)
8227    return ToTOrErr.takeError();
8228
8229  // Record the imported type.
8230  ImportedTypes[FromT] = ToTOrErr->getTypePtr();
8231
8232  return ToTOrErr->getTypePtr();
8233}
8234
8235Expected<QualType> ASTImporter::Import(QualType FromT) {
8236  if (FromT.isNull())
8237    return QualType{};
8238
8239  Expected<const Type *> ToTyOrErr = Import(FromT.getTypePtr());
8240  if (!ToTyOrErr)
8241    return ToTyOrErr.takeError();
8242
8243  return ToContext.getQualifiedType(*ToTyOrErr, FromT.getLocalQualifiers());
8244}
8245
8246Expected<TypeSourceInfo *> ASTImporter::Import(TypeSourceInfo *FromTSI) {
8247  if (!FromTSI)
8248    return FromTSI;
8249
8250  // FIXME: For now we just create a "trivial" type source info based
8251  // on the type and a single location. Implement a real version of this.
8252  ExpectedType TOrErr = Import(FromTSI->getType());
8253  if (!TOrErr)
8254    return TOrErr.takeError();
8255  ExpectedSLoc BeginLocOrErr = Import(FromTSI->getTypeLoc().getBeginLoc());
8256  if (!BeginLocOrErr)
8257    return BeginLocOrErr.takeError();
8258
8259  return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr);
8260}
8261
8262Expected<Attr *> ASTImporter::Import(const Attr *FromAttr) {
8263  Attr *ToAttr = nullptr;
8264  SourceRange ToRange;
8265  if (Error Err = importInto(ToRange, FromAttr->getRange()))
8266    return std::move(Err);
8267
8268  // FIXME: Is there some kind of AttrVisitor to use here?
8269  switch (FromAttr->getKind()) {
8270  case attr::Aligned: {
8271    auto *From = cast<AlignedAttr>(FromAttr);
8272    AlignedAttr *To;
8273    auto CreateAlign = [&](bool IsAlignmentExpr, void *Alignment) {
8274      return AlignedAttr::Create(ToContext, IsAlignmentExpr, Alignment, ToRange,
8275                                 From->getSyntax(),
8276                                 From->getSemanticSpelling());
8277    };
8278    if (From->isAlignmentExpr()) {
8279      if (auto ToEOrErr = Import(From->getAlignmentExpr()))
8280        To = CreateAlign(true, *ToEOrErr);
8281      else
8282        return ToEOrErr.takeError();
8283    } else {
8284      if (auto ToTOrErr = Import(From->getAlignmentType()))
8285        To = CreateAlign(false, *ToTOrErr);
8286      else
8287        return ToTOrErr.takeError();
8288    }
8289    To->setInherited(From->isInherited());
8290    To->setPackExpansion(From->isPackExpansion());
8291    To->setImplicit(From->isImplicit());
8292    ToAttr = To;
8293    break;
8294  }
8295  case attr::Format: {
8296    const auto *From = cast<FormatAttr>(FromAttr);
8297    FormatAttr *To;
8298    IdentifierInfo *ToAttrType = Import(From->getType());
8299    To = FormatAttr::Create(ToContext, ToAttrType, From->getFormatIdx(),
8300                            From->getFirstArg(), ToRange, From->getSyntax());
8301    To->setInherited(From->isInherited());
8302    ToAttr = To;
8303    break;
8304  }
8305  default:
8306    // FIXME: 'clone' copies every member but some of them should be imported.
8307    // Handle other Attrs that have parameters that should be imported.
8308    ToAttr = FromAttr->clone(ToContext);
8309    ToAttr->setRange(ToRange);
8310    break;
8311  }
8312  assert(ToAttr && "Attribute should be created.");
8313
8314  return ToAttr;
8315}
8316
8317Decl *ASTImporter::GetAlreadyImportedOrNull(const Decl *FromD) const {
8318  auto Pos = ImportedDecls.find(FromD);
8319  if (Pos != ImportedDecls.end())
8320    return Pos->second;
8321  else
8322    return nullptr;
8323}
8324
8325TranslationUnitDecl *ASTImporter::GetFromTU(Decl *ToD) {
8326  auto FromDPos = ImportedFromDecls.find(ToD);
8327  if (FromDPos == ImportedFromDecls.end())
8328    return nullptr;
8329  return FromDPos->second->getTranslationUnitDecl();
8330}
8331
8332Expected<Decl *> ASTImporter::Import(Decl *FromD) {
8333  if (!FromD)
8334    return nullptr;
8335
8336  // Push FromD to the stack, and remove that when we return.
8337  ImportPath.push(FromD);
8338  auto ImportPathBuilder =
8339      llvm::make_scope_exit([this]() { ImportPath.pop(); });
8340
8341  // Check whether there was a previous failed import.
8342  // If yes return the existing error.
8343  if (auto Error = getImportDeclErrorIfAny(FromD))
8344    return make_error<ImportError>(*Error);
8345
8346  // Check whether we've already imported this declaration.
8347  Decl *ToD = GetAlreadyImportedOrNull(FromD);
8348  if (ToD) {
8349    // Already imported (possibly from another TU) and with an error.
8350    if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
8351      setImportDeclError(FromD, *Error);
8352      return make_error<ImportError>(*Error);
8353    }
8354
8355    // If FromD has some updated flags after last import, apply it.
8356    updateFlags(FromD, ToD);
8357    // If we encounter a cycle during an import then we save the relevant part
8358    // of the import path associated to the Decl.
8359    if (ImportPath.hasCycleAtBack())
8360      SavedImportPaths[FromD].push_back(ImportPath.copyCycleAtBack());
8361    return ToD;
8362  }
8363
8364  // Import the declaration.
8365  ExpectedDecl ToDOrErr = ImportImpl(FromD);
8366  if (!ToDOrErr) {
8367    // Failed to import.
8368
8369    auto Pos = ImportedDecls.find(FromD);
8370    if (Pos != ImportedDecls.end()) {
8371      // Import failed after the object was created.
8372      // Remove all references to it.
8373      auto *ToD = Pos->second;
8374      ImportedDecls.erase(Pos);
8375
8376      // ImportedDecls and ImportedFromDecls are not symmetric.  It may happen
8377      // (e.g. with namespaces) that several decls from the 'from' context are
8378      // mapped to the same decl in the 'to' context.  If we removed entries
8379      // from the LookupTable here then we may end up removing them multiple
8380      // times.
8381
8382      // The Lookuptable contains decls only which are in the 'to' context.
8383      // Remove from the Lookuptable only if it is *imported* into the 'to'
8384      // context (and do not remove it if it was added during the initial
8385      // traverse of the 'to' context).
8386      auto PosF = ImportedFromDecls.find(ToD);
8387      if (PosF != ImportedFromDecls.end()) {
8388        // In the case of TypedefNameDecl we create the Decl first and only
8389        // then we import and set its DeclContext. So, the DC might not be set
8390        // when we reach here.
8391        if (ToD->getDeclContext())
8392          SharedState->removeDeclFromLookup(ToD);
8393        ImportedFromDecls.erase(PosF);
8394      }
8395
8396      // FIXME: AST may contain remaining references to the failed object.
8397      // However, the ImportDeclErrors in the shared state contains all the
8398      // failed objects together with their error.
8399    }
8400
8401    // Error encountered for the first time.
8402    // After takeError the error is not usable any more in ToDOrErr.
8403    // Get a copy of the error object (any more simple solution for this?).
8404    ImportError ErrOut;
8405    handleAllErrors(ToDOrErr.takeError(),
8406                    [&ErrOut](const ImportError &E) { ErrOut = E; });
8407    setImportDeclError(FromD, ErrOut);
8408    // Set the error for the mapped to Decl, which is in the "to" context.
8409    if (Pos != ImportedDecls.end())
8410      SharedState->setImportDeclError(Pos->second, ErrOut);
8411
8412    // Set the error for all nodes which have been created before we
8413    // recognized the error.
8414    for (const auto &Path : SavedImportPaths[FromD])
8415      for (Decl *FromDi : Path) {
8416        setImportDeclError(FromDi, ErrOut);
8417        //FIXME Should we remove these Decls from ImportedDecls?
8418        // Set the error for the mapped to Decl, which is in the "to" context.
8419        auto Ii = ImportedDecls.find(FromDi);
8420        if (Ii != ImportedDecls.end())
8421          SharedState->setImportDeclError(Ii->second, ErrOut);
8422          // FIXME Should we remove these Decls from the LookupTable,
8423          // and from ImportedFromDecls?
8424      }
8425    SavedImportPaths.erase(FromD);
8426
8427    // Do not return ToDOrErr, error was taken out of it.
8428    return make_error<ImportError>(ErrOut);
8429  }
8430
8431  ToD = *ToDOrErr;
8432
8433  // FIXME: Handle the "already imported with error" case. We can get here
8434  // nullptr only if GetImportedOrCreateDecl returned nullptr (after a
8435  // previously failed create was requested).
8436  // Later GetImportedOrCreateDecl can be updated to return the error.
8437  if (!ToD) {
8438    auto Err = getImportDeclErrorIfAny(FromD);
8439    assert(Err);
8440    return make_error<ImportError>(*Err);
8441  }
8442
8443  // We could import from the current TU without error.  But previously we
8444  // already had imported a Decl as `ToD` from another TU (with another
8445  // ASTImporter object) and with an error.
8446  if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
8447    setImportDeclError(FromD, *Error);
8448    return make_error<ImportError>(*Error);
8449  }
8450
8451  // Make sure that ImportImpl registered the imported decl.
8452  assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?");
8453
8454  if (FromD->hasAttrs())
8455    for (const Attr *FromAttr : FromD->getAttrs()) {
8456      auto ToAttrOrErr = Import(FromAttr);
8457      if (ToAttrOrErr)
8458        ToD->addAttr(*ToAttrOrErr);
8459      else
8460        return ToAttrOrErr.takeError();
8461    }
8462
8463  // Notify subclasses.
8464  Imported(FromD, ToD);
8465
8466  updateFlags(FromD, ToD);
8467  SavedImportPaths.erase(FromD);
8468  return ToDOrErr;
8469}
8470
8471Expected<DeclContext *> ASTImporter::ImportContext(DeclContext *FromDC) {
8472  if (!FromDC)
8473    return FromDC;
8474
8475  ExpectedDecl ToDCOrErr = Import(cast<Decl>(FromDC));
8476  if (!ToDCOrErr)
8477    return ToDCOrErr.takeError();
8478  auto *ToDC = cast<DeclContext>(*ToDCOrErr);
8479
8480  // When we're using a record/enum/Objective-C class/protocol as a context, we
8481  // need it to have a definition.
8482  if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
8483    auto *FromRecord = cast<RecordDecl>(FromDC);
8484    if (ToRecord->isCompleteDefinition())
8485      return ToDC;
8486
8487    // If FromRecord is not defined we need to force it to be.
8488    // Simply calling CompleteDecl(...) for a RecordDecl will break some cases
8489    // it will start the definition but we never finish it.
8490    // If there are base classes they won't be imported and we will
8491    // be missing anything that we inherit from those bases.
8492    if (FromRecord->getASTContext().getExternalSource() &&
8493        !FromRecord->isCompleteDefinition())
8494      FromRecord->getASTContext().getExternalSource()->CompleteType(FromRecord);
8495
8496    if (FromRecord->isCompleteDefinition())
8497      if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8498          FromRecord, ToRecord, ASTNodeImporter::IDK_Basic))
8499        return std::move(Err);
8500  } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
8501    auto *FromEnum = cast<EnumDecl>(FromDC);
8502    if (ToEnum->isCompleteDefinition()) {
8503      // Do nothing.
8504    } else if (FromEnum->isCompleteDefinition()) {
8505      if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8506          FromEnum, ToEnum, ASTNodeImporter::IDK_Basic))
8507        return std::move(Err);
8508    } else {
8509      CompleteDecl(ToEnum);
8510    }
8511  } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
8512    auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
8513    if (ToClass->getDefinition()) {
8514      // Do nothing.
8515    } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
8516      if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8517          FromDef, ToClass, ASTNodeImporter::IDK_Basic))
8518        return std::move(Err);
8519    } else {
8520      CompleteDecl(ToClass);
8521    }
8522  } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
8523    auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
8524    if (ToProto->getDefinition()) {
8525      // Do nothing.
8526    } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
8527      if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8528          FromDef, ToProto, ASTNodeImporter::IDK_Basic))
8529        return std::move(Err);
8530    } else {
8531      CompleteDecl(ToProto);
8532    }
8533  }
8534
8535  return ToDC;
8536}
8537
8538Expected<Expr *> ASTImporter::Import(Expr *FromE) {
8539  if (ExpectedStmt ToSOrErr = Import(cast_or_null<Stmt>(FromE)))
8540    return cast_or_null<Expr>(*ToSOrErr);
8541  else
8542    return ToSOrErr.takeError();
8543}
8544
8545Expected<Stmt *> ASTImporter::Import(Stmt *FromS) {
8546  if (!FromS)
8547    return nullptr;
8548
8549  // Check whether we've already imported this statement.
8550  llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
8551  if (Pos != ImportedStmts.end())
8552    return Pos->second;
8553
8554  // Import the statement.
8555  ASTNodeImporter Importer(*this);
8556  ExpectedStmt ToSOrErr = Importer.Visit(FromS);
8557  if (!ToSOrErr)
8558    return ToSOrErr;
8559
8560  if (auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
8561    auto *FromE = cast<Expr>(FromS);
8562    // Copy ExprBitfields, which may not be handled in Expr subclasses
8563    // constructors.
8564    ToE->setValueKind(FromE->getValueKind());
8565    ToE->setObjectKind(FromE->getObjectKind());
8566    ToE->setDependence(FromE->getDependence());
8567  }
8568
8569  // Record the imported statement object.
8570  ImportedStmts[FromS] = *ToSOrErr;
8571  return ToSOrErr;
8572}
8573
8574Expected<NestedNameSpecifier *>
8575ASTImporter::Import(NestedNameSpecifier *FromNNS) {
8576  if (!FromNNS)
8577    return nullptr;
8578
8579  NestedNameSpecifier *Prefix = nullptr;
8580  if (Error Err = importInto(Prefix, FromNNS->getPrefix()))
8581    return std::move(Err);
8582
8583  switch (FromNNS->getKind()) {
8584  case NestedNameSpecifier::Identifier:
8585    assert(FromNNS->getAsIdentifier() && "NNS should contain identifier.");
8586    return NestedNameSpecifier::Create(ToContext, Prefix,
8587                                       Import(FromNNS->getAsIdentifier()));
8588
8589  case NestedNameSpecifier::Namespace:
8590    if (ExpectedDecl NSOrErr = Import(FromNNS->getAsNamespace())) {
8591      return NestedNameSpecifier::Create(ToContext, Prefix,
8592                                         cast<NamespaceDecl>(*NSOrErr));
8593    } else
8594      return NSOrErr.takeError();
8595
8596  case NestedNameSpecifier::NamespaceAlias:
8597    if (ExpectedDecl NSADOrErr = Import(FromNNS->getAsNamespaceAlias()))
8598      return NestedNameSpecifier::Create(ToContext, Prefix,
8599                                         cast<NamespaceAliasDecl>(*NSADOrErr));
8600    else
8601      return NSADOrErr.takeError();
8602
8603  case NestedNameSpecifier::Global:
8604    return NestedNameSpecifier::GlobalSpecifier(ToContext);
8605
8606  case NestedNameSpecifier::Super:
8607    if (ExpectedDecl RDOrErr = Import(FromNNS->getAsRecordDecl()))
8608      return NestedNameSpecifier::SuperSpecifier(ToContext,
8609                                                 cast<CXXRecordDecl>(*RDOrErr));
8610    else
8611      return RDOrErr.takeError();
8612
8613  case NestedNameSpecifier::TypeSpec:
8614  case NestedNameSpecifier::TypeSpecWithTemplate:
8615    if (Expected<QualType> TyOrErr =
8616            Import(QualType(FromNNS->getAsType(), 0u))) {
8617      bool TSTemplate =
8618          FromNNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate;
8619      return NestedNameSpecifier::Create(ToContext, Prefix, TSTemplate,
8620                                         TyOrErr->getTypePtr());
8621    } else {
8622      return TyOrErr.takeError();
8623    }
8624  }
8625
8626  llvm_unreachable("Invalid nested name specifier kind");
8627}
8628
8629Expected<NestedNameSpecifierLoc>
8630ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
8631  // Copied from NestedNameSpecifier mostly.
8632  SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
8633  NestedNameSpecifierLoc NNS = FromNNS;
8634
8635  // Push each of the nested-name-specifiers's onto a stack for
8636  // serialization in reverse order.
8637  while (NNS) {
8638    NestedNames.push_back(NNS);
8639    NNS = NNS.getPrefix();
8640  }
8641
8642  NestedNameSpecifierLocBuilder Builder;
8643
8644  while (!NestedNames.empty()) {
8645    NNS = NestedNames.pop_back_val();
8646    NestedNameSpecifier *Spec = nullptr;
8647    if (Error Err = importInto(Spec, NNS.getNestedNameSpecifier()))
8648      return std::move(Err);
8649
8650    NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
8651
8652    SourceLocation ToLocalBeginLoc, ToLocalEndLoc;
8653    if (Kind != NestedNameSpecifier::Super) {
8654      if (Error Err = importInto(ToLocalBeginLoc, NNS.getLocalBeginLoc()))
8655        return std::move(Err);
8656
8657      if (Kind != NestedNameSpecifier::Global)
8658        if (Error Err = importInto(ToLocalEndLoc, NNS.getLocalEndLoc()))
8659          return std::move(Err);
8660    }
8661
8662    switch (Kind) {
8663    case NestedNameSpecifier::Identifier:
8664      Builder.Extend(getToContext(), Spec->getAsIdentifier(), ToLocalBeginLoc,
8665                     ToLocalEndLoc);
8666      break;
8667
8668    case NestedNameSpecifier::Namespace:
8669      Builder.Extend(getToContext(), Spec->getAsNamespace(), ToLocalBeginLoc,
8670                     ToLocalEndLoc);
8671      break;
8672
8673    case NestedNameSpecifier::NamespaceAlias:
8674      Builder.Extend(getToContext(), Spec->getAsNamespaceAlias(),
8675                     ToLocalBeginLoc, ToLocalEndLoc);
8676      break;
8677
8678    case NestedNameSpecifier::TypeSpec:
8679    case NestedNameSpecifier::TypeSpecWithTemplate: {
8680      SourceLocation ToTLoc;
8681      if (Error Err = importInto(ToTLoc, NNS.getTypeLoc().getBeginLoc()))
8682        return std::move(Err);
8683      TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
8684            QualType(Spec->getAsType(), 0), ToTLoc);
8685      if (Kind == NestedNameSpecifier::TypeSpecWithTemplate)
8686        // ToLocalBeginLoc is here the location of the 'template' keyword.
8687        Builder.Extend(getToContext(), ToLocalBeginLoc, TSI->getTypeLoc(),
8688                       ToLocalEndLoc);
8689      else
8690        // No location for 'template' keyword here.
8691        Builder.Extend(getToContext(), SourceLocation{}, TSI->getTypeLoc(),
8692                       ToLocalEndLoc);
8693      break;
8694    }
8695
8696    case NestedNameSpecifier::Global:
8697      Builder.MakeGlobal(getToContext(), ToLocalBeginLoc);
8698      break;
8699
8700    case NestedNameSpecifier::Super: {
8701      auto ToSourceRangeOrErr = Import(NNS.getSourceRange());
8702      if (!ToSourceRangeOrErr)
8703        return ToSourceRangeOrErr.takeError();
8704
8705      Builder.MakeSuper(getToContext(), Spec->getAsRecordDecl(),
8706                        ToSourceRangeOrErr->getBegin(),
8707                        ToSourceRangeOrErr->getEnd());
8708    }
8709  }
8710  }
8711
8712  return Builder.getWithLocInContext(getToContext());
8713}
8714
8715Expected<TemplateName> ASTImporter::Import(TemplateName From) {
8716  switch (From.getKind()) {
8717  case TemplateName::Template:
8718    if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl()))
8719      return TemplateName(cast<TemplateDecl>(*ToTemplateOrErr));
8720    else
8721      return ToTemplateOrErr.takeError();
8722
8723  case TemplateName::OverloadedTemplate: {
8724    OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
8725    UnresolvedSet<2> ToTemplates;
8726    for (auto *I : *FromStorage) {
8727      if (auto ToOrErr = Import(I))
8728        ToTemplates.addDecl(cast<NamedDecl>(*ToOrErr));
8729      else
8730        return ToOrErr.takeError();
8731    }
8732    return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
8733                                               ToTemplates.end());
8734  }
8735
8736  case TemplateName::AssumedTemplate: {
8737    AssumedTemplateStorage *FromStorage = From.getAsAssumedTemplateName();
8738    auto DeclNameOrErr = Import(FromStorage->getDeclName());
8739    if (!DeclNameOrErr)
8740      return DeclNameOrErr.takeError();
8741    return ToContext.getAssumedTemplateName(*DeclNameOrErr);
8742  }
8743
8744  case TemplateName::QualifiedTemplate: {
8745    QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
8746    auto QualifierOrErr = Import(QTN->getQualifier());
8747    if (!QualifierOrErr)
8748      return QualifierOrErr.takeError();
8749
8750    if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl()))
8751      return ToContext.getQualifiedTemplateName(
8752          *QualifierOrErr, QTN->hasTemplateKeyword(),
8753          cast<TemplateDecl>(*ToTemplateOrErr));
8754    else
8755      return ToTemplateOrErr.takeError();
8756  }
8757
8758  case TemplateName::DependentTemplate: {
8759    DependentTemplateName *DTN = From.getAsDependentTemplateName();
8760    auto QualifierOrErr = Import(DTN->getQualifier());
8761    if (!QualifierOrErr)
8762      return QualifierOrErr.takeError();
8763
8764    if (DTN->isIdentifier()) {
8765      return ToContext.getDependentTemplateName(*QualifierOrErr,
8766                                                Import(DTN->getIdentifier()));
8767    }
8768
8769    return ToContext.getDependentTemplateName(*QualifierOrErr,
8770                                              DTN->getOperator());
8771  }
8772
8773  case TemplateName::SubstTemplateTemplateParm: {
8774    SubstTemplateTemplateParmStorage *Subst =
8775        From.getAsSubstTemplateTemplateParm();
8776    ExpectedDecl ParamOrErr = Import(Subst->getParameter());
8777    if (!ParamOrErr)
8778      return ParamOrErr.takeError();
8779
8780    auto ReplacementOrErr = Import(Subst->getReplacement());
8781    if (!ReplacementOrErr)
8782      return ReplacementOrErr.takeError();
8783
8784    return ToContext.getSubstTemplateTemplateParm(
8785        cast<TemplateTemplateParmDecl>(*ParamOrErr), *ReplacementOrErr);
8786  }
8787
8788  case TemplateName::SubstTemplateTemplateParmPack: {
8789    SubstTemplateTemplateParmPackStorage *SubstPack
8790      = From.getAsSubstTemplateTemplateParmPack();
8791    ExpectedDecl ParamOrErr = Import(SubstPack->getParameterPack());
8792    if (!ParamOrErr)
8793      return ParamOrErr.takeError();
8794
8795    ASTNodeImporter Importer(*this);
8796    auto ArgPackOrErr =
8797        Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
8798    if (!ArgPackOrErr)
8799      return ArgPackOrErr.takeError();
8800
8801    return ToContext.getSubstTemplateTemplateParmPack(
8802        cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr);
8803  }
8804  }
8805
8806  llvm_unreachable("Invalid template name kind");
8807}
8808
8809Expected<SourceLocation> ASTImporter::Import(SourceLocation FromLoc) {
8810  if (FromLoc.isInvalid())
8811    return SourceLocation{};
8812
8813  SourceManager &FromSM = FromContext.getSourceManager();
8814  bool IsBuiltin = FromSM.isWrittenInBuiltinFile(FromLoc);
8815
8816  std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
8817  Expected<FileID> ToFileIDOrErr = Import(Decomposed.first, IsBuiltin);
8818  if (!ToFileIDOrErr)
8819    return ToFileIDOrErr.takeError();
8820  SourceManager &ToSM = ToContext.getSourceManager();
8821  return ToSM.getComposedLoc(*ToFileIDOrErr, Decomposed.second);
8822}
8823
8824Expected<SourceRange> ASTImporter::Import(SourceRange FromRange) {
8825  SourceLocation ToBegin, ToEnd;
8826  if (Error Err = importInto(ToBegin, FromRange.getBegin()))
8827    return std::move(Err);
8828  if (Error Err = importInto(ToEnd, FromRange.getEnd()))
8829    return std::move(Err);
8830
8831  return SourceRange(ToBegin, ToEnd);
8832}
8833
8834Expected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) {
8835  llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
8836  if (Pos != ImportedFileIDs.end())
8837    return Pos->second;
8838
8839  SourceManager &FromSM = FromContext.getSourceManager();
8840  SourceManager &ToSM = ToContext.getSourceManager();
8841  const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
8842
8843  // Map the FromID to the "to" source manager.
8844  FileID ToID;
8845  if (FromSLoc.isExpansion()) {
8846    const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
8847    ExpectedSLoc ToSpLoc = Import(FromEx.getSpellingLoc());
8848    if (!ToSpLoc)
8849      return ToSpLoc.takeError();
8850    ExpectedSLoc ToExLocS = Import(FromEx.getExpansionLocStart());
8851    if (!ToExLocS)
8852      return ToExLocS.takeError();
8853    unsigned TokenLen = FromSM.getFileIDSize(FromID);
8854    SourceLocation MLoc;
8855    if (FromEx.isMacroArgExpansion()) {
8856      MLoc = ToSM.createMacroArgExpansionLoc(*ToSpLoc, *ToExLocS, TokenLen);
8857    } else {
8858      if (ExpectedSLoc ToExLocE = Import(FromEx.getExpansionLocEnd()))
8859        MLoc = ToSM.createExpansionLoc(*ToSpLoc, *ToExLocS, *ToExLocE, TokenLen,
8860                                       FromEx.isExpansionTokenRange());
8861      else
8862        return ToExLocE.takeError();
8863    }
8864    ToID = ToSM.getFileID(MLoc);
8865  } else {
8866    const SrcMgr::ContentCache *Cache = &FromSLoc.getFile().getContentCache();
8867
8868    if (!IsBuiltin && !Cache->BufferOverridden) {
8869      // Include location of this file.
8870      ExpectedSLoc ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
8871      if (!ToIncludeLoc)
8872        return ToIncludeLoc.takeError();
8873
8874      // Every FileID that is not the main FileID needs to have a valid include
8875      // location so that the include chain points to the main FileID. When
8876      // importing the main FileID (which has no include location), we need to
8877      // create a fake include location in the main file to keep this property
8878      // intact.
8879      SourceLocation ToIncludeLocOrFakeLoc = *ToIncludeLoc;
8880      if (FromID == FromSM.getMainFileID())
8881        ToIncludeLocOrFakeLoc = ToSM.getLocForStartOfFile(ToSM.getMainFileID());
8882
8883      if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
8884        // FIXME: We probably want to use getVirtualFile(), so we don't hit the
8885        // disk again
8886        // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
8887        // than mmap the files several times.
8888        auto Entry =
8889            ToFileManager.getOptionalFileRef(Cache->OrigEntry->getName());
8890        // FIXME: The filename may be a virtual name that does probably not
8891        // point to a valid file and we get no Entry here. In this case try with
8892        // the memory buffer below.
8893        if (Entry)
8894          ToID = ToSM.createFileID(*Entry, ToIncludeLocOrFakeLoc,
8895                                   FromSLoc.getFile().getFileCharacteristic());
8896      }
8897    }
8898
8899    if (ToID.isInvalid() || IsBuiltin) {
8900      // FIXME: We want to re-use the existing MemoryBuffer!
8901      llvm::Optional<llvm::MemoryBufferRef> FromBuf =
8902          Cache->getBufferOrNone(FromContext.getDiagnostics(),
8903                                 FromSM.getFileManager(), SourceLocation{});
8904      if (!FromBuf)
8905        return llvm::make_error<ImportError>(ImportError::Unknown);
8906
8907      std::unique_ptr<llvm::MemoryBuffer> ToBuf =
8908          llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
8909                                               FromBuf->getBufferIdentifier());
8910      ToID = ToSM.createFileID(std::move(ToBuf),
8911                               FromSLoc.getFile().getFileCharacteristic());
8912    }
8913  }
8914
8915  assert(ToID.isValid() && "Unexpected invalid fileID was created.");
8916
8917  ImportedFileIDs[FromID] = ToID;
8918  return ToID;
8919}
8920
8921Expected<CXXCtorInitializer *> ASTImporter::Import(CXXCtorInitializer *From) {
8922  ExpectedExpr ToExprOrErr = Import(From->getInit());
8923  if (!ToExprOrErr)
8924    return ToExprOrErr.takeError();
8925
8926  auto LParenLocOrErr = Import(From->getLParenLoc());
8927  if (!LParenLocOrErr)
8928    return LParenLocOrErr.takeError();
8929
8930  auto RParenLocOrErr = Import(From->getRParenLoc());
8931  if (!RParenLocOrErr)
8932    return RParenLocOrErr.takeError();
8933
8934  if (From->isBaseInitializer()) {
8935    auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
8936    if (!ToTInfoOrErr)
8937      return ToTInfoOrErr.takeError();
8938
8939    SourceLocation EllipsisLoc;
8940    if (From->isPackExpansion())
8941      if (Error Err = importInto(EllipsisLoc, From->getEllipsisLoc()))
8942        return std::move(Err);
8943
8944    return new (ToContext) CXXCtorInitializer(
8945        ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr,
8946        *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
8947  } else if (From->isMemberInitializer()) {
8948    ExpectedDecl ToFieldOrErr = Import(From->getMember());
8949    if (!ToFieldOrErr)
8950      return ToFieldOrErr.takeError();
8951
8952    auto MemberLocOrErr = Import(From->getMemberLocation());
8953    if (!MemberLocOrErr)
8954      return MemberLocOrErr.takeError();
8955
8956    return new (ToContext) CXXCtorInitializer(
8957        ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr,
8958        *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8959  } else if (From->isIndirectMemberInitializer()) {
8960    ExpectedDecl ToIFieldOrErr = Import(From->getIndirectMember());
8961    if (!ToIFieldOrErr)
8962      return ToIFieldOrErr.takeError();
8963
8964    auto MemberLocOrErr = Import(From->getMemberLocation());
8965    if (!MemberLocOrErr)
8966      return MemberLocOrErr.takeError();
8967
8968    return new (ToContext) CXXCtorInitializer(
8969        ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr),
8970        *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8971  } else if (From->isDelegatingInitializer()) {
8972    auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
8973    if (!ToTInfoOrErr)
8974      return ToTInfoOrErr.takeError();
8975
8976    return new (ToContext)
8977        CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr,
8978                           *ToExprOrErr, *RParenLocOrErr);
8979  } else {
8980    // FIXME: assert?
8981    return make_error<ImportError>();
8982  }
8983}
8984
8985Expected<CXXBaseSpecifier *>
8986ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
8987  auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
8988  if (Pos != ImportedCXXBaseSpecifiers.end())
8989    return Pos->second;
8990
8991  Expected<SourceRange> ToSourceRange = Import(BaseSpec->getSourceRange());
8992  if (!ToSourceRange)
8993    return ToSourceRange.takeError();
8994  Expected<TypeSourceInfo *> ToTSI = Import(BaseSpec->getTypeSourceInfo());
8995  if (!ToTSI)
8996    return ToTSI.takeError();
8997  ExpectedSLoc ToEllipsisLoc = Import(BaseSpec->getEllipsisLoc());
8998  if (!ToEllipsisLoc)
8999    return ToEllipsisLoc.takeError();
9000  CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
9001      *ToSourceRange, BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
9002      BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc);
9003  ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
9004  return Imported;
9005}
9006
9007llvm::Expected<APValue> ASTImporter::Import(const APValue &FromValue) {
9008  ASTNodeImporter Importer(*this);
9009  return Importer.ImportAPValue(FromValue);
9010}
9011
9012Error ASTImporter::ImportDefinition(Decl *From) {
9013  ExpectedDecl ToOrErr = Import(From);
9014  if (!ToOrErr)
9015    return ToOrErr.takeError();
9016  Decl *To = *ToOrErr;
9017
9018  auto *FromDC = cast<DeclContext>(From);
9019  ASTNodeImporter Importer(*this);
9020
9021  if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
9022    if (!ToRecord->getDefinition()) {
9023      return Importer.ImportDefinition(
9024          cast<RecordDecl>(FromDC), ToRecord,
9025          ASTNodeImporter::IDK_Everything);
9026    }
9027  }
9028
9029  if (auto *ToEnum = dyn_cast<EnumDecl>(To)) {
9030    if (!ToEnum->getDefinition()) {
9031      return Importer.ImportDefinition(
9032          cast<EnumDecl>(FromDC), ToEnum, ASTNodeImporter::IDK_Everything);
9033    }
9034  }
9035
9036  if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
9037    if (!ToIFace->getDefinition()) {
9038      return Importer.ImportDefinition(
9039          cast<ObjCInterfaceDecl>(FromDC), ToIFace,
9040          ASTNodeImporter::IDK_Everything);
9041    }
9042  }
9043
9044  if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
9045    if (!ToProto->getDefinition()) {
9046      return Importer.ImportDefinition(
9047          cast<ObjCProtocolDecl>(FromDC), ToProto,
9048          ASTNodeImporter::IDK_Everything);
9049    }
9050  }
9051
9052  return Importer.ImportDeclContext(FromDC, true);
9053}
9054
9055Expected<DeclarationName> ASTImporter::Import(DeclarationName FromName) {
9056  if (!FromName)
9057    return DeclarationName{};
9058
9059  switch (FromName.getNameKind()) {
9060  case DeclarationName::Identifier:
9061    return DeclarationName(Import(FromName.getAsIdentifierInfo()));
9062
9063  case DeclarationName::ObjCZeroArgSelector:
9064  case DeclarationName::ObjCOneArgSelector:
9065  case DeclarationName::ObjCMultiArgSelector:
9066    if (auto ToSelOrErr = Import(FromName.getObjCSelector()))
9067      return DeclarationName(*ToSelOrErr);
9068    else
9069      return ToSelOrErr.takeError();
9070
9071  case DeclarationName::CXXConstructorName: {
9072    if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
9073      return ToContext.DeclarationNames.getCXXConstructorName(
9074          ToContext.getCanonicalType(*ToTyOrErr));
9075    else
9076      return ToTyOrErr.takeError();
9077  }
9078
9079  case DeclarationName::CXXDestructorName: {
9080    if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
9081      return ToContext.DeclarationNames.getCXXDestructorName(
9082          ToContext.getCanonicalType(*ToTyOrErr));
9083    else
9084      return ToTyOrErr.takeError();
9085  }
9086
9087  case DeclarationName::CXXDeductionGuideName: {
9088    if (auto ToTemplateOrErr = Import(FromName.getCXXDeductionGuideTemplate()))
9089      return ToContext.DeclarationNames.getCXXDeductionGuideName(
9090          cast<TemplateDecl>(*ToTemplateOrErr));
9091    else
9092      return ToTemplateOrErr.takeError();
9093  }
9094
9095  case DeclarationName::CXXConversionFunctionName: {
9096    if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
9097      return ToContext.DeclarationNames.getCXXConversionFunctionName(
9098          ToContext.getCanonicalType(*ToTyOrErr));
9099    else
9100      return ToTyOrErr.takeError();
9101  }
9102
9103  case DeclarationName::CXXOperatorName:
9104    return ToContext.DeclarationNames.getCXXOperatorName(
9105                                          FromName.getCXXOverloadedOperator());
9106
9107  case DeclarationName::CXXLiteralOperatorName:
9108    return ToContext.DeclarationNames.getCXXLiteralOperatorName(
9109        Import(FromName.getCXXLiteralIdentifier()));
9110
9111  case DeclarationName::CXXUsingDirective:
9112    // FIXME: STATICS!
9113    return DeclarationName::getUsingDirectiveName();
9114  }
9115
9116  llvm_unreachable("Invalid DeclarationName Kind!");
9117}
9118
9119IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
9120  if (!FromId)
9121    return nullptr;
9122
9123  IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
9124
9125  if (!ToId->getBuiltinID() && FromId->getBuiltinID())
9126    ToId->setBuiltinID(FromId->getBuiltinID());
9127
9128  return ToId;
9129}
9130
9131Expected<Selector> ASTImporter::Import(Selector FromSel) {
9132  if (FromSel.isNull())
9133    return Selector{};
9134
9135  SmallVector<IdentifierInfo *, 4> Idents;
9136  Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
9137  for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
9138    Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
9139  return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
9140}
9141
9142llvm::Expected<APValue>
9143ASTNodeImporter::ImportAPValue(const APValue &FromValue) {
9144  APValue Result;
9145  llvm::Error Err = llvm::Error::success();
9146  auto ImportLoop = [&](const APValue *From, APValue *To, unsigned Size) {
9147    for (unsigned Idx = 0; Idx < Size; Idx++) {
9148      APValue Tmp = importChecked(Err, From[Idx]);
9149      To[Idx] = Tmp;
9150    }
9151  };
9152  switch (FromValue.getKind()) {
9153  case APValue::None:
9154  case APValue::Indeterminate:
9155  case APValue::Int:
9156  case APValue::Float:
9157  case APValue::FixedPoint:
9158  case APValue::ComplexInt:
9159  case APValue::ComplexFloat:
9160    Result = FromValue;
9161    break;
9162  case APValue::Vector: {
9163    Result.MakeVector();
9164    MutableArrayRef<APValue> Elts =
9165        Result.setVectorUninit(FromValue.getVectorLength());
9166    ImportLoop(((const APValue::Vec *)(const char *)&FromValue.Data)->Elts,
9167               Elts.data(), FromValue.getVectorLength());
9168    break;
9169  }
9170  case APValue::Array:
9171    Result.MakeArray(FromValue.getArrayInitializedElts(),
9172                     FromValue.getArraySize());
9173    ImportLoop(((const APValue::Arr *)(const char *)&FromValue.Data)->Elts,
9174               ((const APValue::Arr *)(const char *)&Result.Data)->Elts,
9175               FromValue.getArrayInitializedElts());
9176    break;
9177  case APValue::Struct:
9178    Result.MakeStruct(FromValue.getStructNumBases(),
9179                      FromValue.getStructNumFields());
9180    ImportLoop(
9181        ((const APValue::StructData *)(const char *)&FromValue.Data)->Elts,
9182        ((const APValue::StructData *)(const char *)&Result.Data)->Elts,
9183        FromValue.getStructNumBases() + FromValue.getStructNumFields());
9184    break;
9185  case APValue::Union: {
9186    Result.MakeUnion();
9187    const Decl *ImpFDecl = importChecked(Err, FromValue.getUnionField());
9188    APValue ImpValue = importChecked(Err, FromValue.getUnionValue());
9189    if (Err)
9190      return std::move(Err);
9191    Result.setUnion(cast<FieldDecl>(ImpFDecl), ImpValue);
9192    break;
9193  }
9194  case APValue::AddrLabelDiff: {
9195    Result.MakeAddrLabelDiff();
9196    const Expr *ImpLHS = importChecked(Err, FromValue.getAddrLabelDiffLHS());
9197    const Expr *ImpRHS = importChecked(Err, FromValue.getAddrLabelDiffRHS());
9198    if (Err)
9199      return std::move(Err);
9200    Result.setAddrLabelDiff(cast<AddrLabelExpr>(ImpLHS),
9201                            cast<AddrLabelExpr>(ImpRHS));
9202    break;
9203  }
9204  case APValue::MemberPointer: {
9205    const Decl *ImpMemPtrDecl =
9206        importChecked(Err, FromValue.getMemberPointerDecl());
9207    if (Err)
9208      return std::move(Err);
9209    MutableArrayRef<const CXXRecordDecl *> ToPath =
9210        Result.setMemberPointerUninit(
9211            cast<const ValueDecl>(ImpMemPtrDecl),
9212            FromValue.isMemberPointerToDerivedMember(),
9213            FromValue.getMemberPointerPath().size());
9214    llvm::ArrayRef<const CXXRecordDecl *> FromPath =
9215        Result.getMemberPointerPath();
9216    for (unsigned Idx = 0; Idx < FromValue.getMemberPointerPath().size();
9217         Idx++) {
9218      const Decl *ImpDecl = importChecked(Err, FromPath[Idx]);
9219      if (Err)
9220        return std::move(Err);
9221      ToPath[Idx] = cast<const CXXRecordDecl>(ImpDecl->getCanonicalDecl());
9222    }
9223    break;
9224  }
9225  case APValue::LValue:
9226    APValue::LValueBase Base;
9227    QualType FromElemTy;
9228    if (FromValue.getLValueBase()) {
9229      assert(!FromValue.getLValueBase().is<DynamicAllocLValue>() &&
9230             "in C++20 dynamic allocation are transient so they shouldn't "
9231             "appear in the AST");
9232      if (!FromValue.getLValueBase().is<TypeInfoLValue>()) {
9233        if (const auto *E =
9234                FromValue.getLValueBase().dyn_cast<const Expr *>()) {
9235          FromElemTy = E->getType();
9236          const Expr *ImpExpr = importChecked(Err, E);
9237          if (Err)
9238            return std::move(Err);
9239          Base = APValue::LValueBase(ImpExpr,
9240                                     FromValue.getLValueBase().getCallIndex(),
9241                                     FromValue.getLValueBase().getVersion());
9242        } else {
9243          FromElemTy =
9244              FromValue.getLValueBase().get<const ValueDecl *>()->getType();
9245          const Decl *ImpDecl = importChecked(
9246              Err, FromValue.getLValueBase().get<const ValueDecl *>());
9247          if (Err)
9248            return std::move(Err);
9249          Base = APValue::LValueBase(cast<ValueDecl>(ImpDecl),
9250                                     FromValue.getLValueBase().getCallIndex(),
9251                                     FromValue.getLValueBase().getVersion());
9252        }
9253      } else {
9254        FromElemTy = FromValue.getLValueBase().getTypeInfoType();
9255        QualType ImpTypeInfo = importChecked(
9256            Err,
9257            QualType(FromValue.getLValueBase().get<TypeInfoLValue>().getType(),
9258                     0));
9259        QualType ImpType =
9260            importChecked(Err, FromValue.getLValueBase().getTypeInfoType());
9261        if (Err)
9262          return std::move(Err);
9263        Base = APValue::LValueBase::getTypeInfo(
9264            TypeInfoLValue(ImpTypeInfo.getTypePtr()), ImpType);
9265      }
9266    }
9267    CharUnits Offset = FromValue.getLValueOffset();
9268    unsigned PathLength = FromValue.getLValuePath().size();
9269    Result.MakeLValue();
9270    if (FromValue.hasLValuePath()) {
9271      MutableArrayRef<APValue::LValuePathEntry> ToPath = Result.setLValueUninit(
9272          Base, Offset, PathLength, FromValue.isLValueOnePastTheEnd(),
9273          FromValue.isNullPointer());
9274      llvm::ArrayRef<APValue::LValuePathEntry> FromPath =
9275          FromValue.getLValuePath();
9276      for (unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
9277        if (FromElemTy->isRecordType()) {
9278          const Decl *FromDecl =
9279              FromPath[LoopIdx].getAsBaseOrMember().getPointer();
9280          const Decl *ImpDecl = importChecked(Err, FromDecl);
9281          if (Err)
9282            return std::move(Err);
9283          if (auto *RD = dyn_cast<CXXRecordDecl>(FromDecl))
9284            FromElemTy = Importer.FromContext.getRecordType(RD);
9285          else
9286            FromElemTy = cast<ValueDecl>(FromDecl)->getType();
9287          ToPath[LoopIdx] = APValue::LValuePathEntry(APValue::BaseOrMemberType(
9288              ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
9289        } else {
9290          FromElemTy =
9291              Importer.FromContext.getAsArrayType(FromElemTy)->getElementType();
9292          ToPath[LoopIdx] = APValue::LValuePathEntry::ArrayIndex(
9293              FromPath[LoopIdx].getAsArrayIndex());
9294        }
9295      }
9296    } else
9297      Result.setLValue(Base, Offset, APValue::NoLValuePath{},
9298                       FromValue.isNullPointer());
9299  }
9300  if (Err)
9301    return std::move(Err);
9302  return Result;
9303}
9304
9305Expected<DeclarationName> ASTImporter::HandleNameConflict(DeclarationName Name,
9306                                                          DeclContext *DC,
9307                                                          unsigned IDNS,
9308                                                          NamedDecl **Decls,
9309                                                          unsigned NumDecls) {
9310  if (ODRHandling == ODRHandlingType::Conservative)
9311    // Report error at any name conflict.
9312    return make_error<ImportError>(ImportError::NameConflict);
9313  else
9314    // Allow to create the new Decl with the same name.
9315    return Name;
9316}
9317
9318DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
9319  if (LastDiagFromFrom)
9320    ToContext.getDiagnostics().notePriorDiagnosticFrom(
9321      FromContext.getDiagnostics());
9322  LastDiagFromFrom = false;
9323  return ToContext.getDiagnostics().Report(Loc, DiagID);
9324}
9325
9326DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
9327  if (!LastDiagFromFrom)
9328    FromContext.getDiagnostics().notePriorDiagnosticFrom(
9329      ToContext.getDiagnostics());
9330  LastDiagFromFrom = true;
9331  return FromContext.getDiagnostics().Report(Loc, DiagID);
9332}
9333
9334void ASTImporter::CompleteDecl (Decl *D) {
9335  if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9336    if (!ID->getDefinition())
9337      ID->startDefinition();
9338  }
9339  else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
9340    if (!PD->getDefinition())
9341      PD->startDefinition();
9342  }
9343  else if (auto *TD = dyn_cast<TagDecl>(D)) {
9344    if (!TD->getDefinition() && !TD->isBeingDefined()) {
9345      TD->startDefinition();
9346      TD->setCompleteDefinition(true);
9347    }
9348  }
9349  else {
9350    assert(0 && "CompleteDecl called on a Decl that can't be completed");
9351  }
9352}
9353
9354Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
9355  llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
9356  assert((Pos == ImportedDecls.end() || Pos->second == To) &&
9357      "Try to import an already imported Decl");
9358  if (Pos != ImportedDecls.end())
9359    return Pos->second;
9360  ImportedDecls[From] = To;
9361  // This mapping should be maintained only in this function. Therefore do not
9362  // check for additional consistency.
9363  ImportedFromDecls[To] = From;
9364  // In the case of TypedefNameDecl we create the Decl first and only then we
9365  // import and set its DeclContext. So, the DC is still not set when we reach
9366  // here from GetImportedOrCreateDecl.
9367  if (To->getDeclContext())
9368    AddToLookupTable(To);
9369  return To;
9370}
9371
9372llvm::Optional<ImportError>
9373ASTImporter::getImportDeclErrorIfAny(Decl *FromD) const {
9374  auto Pos = ImportDeclErrors.find(FromD);
9375  if (Pos != ImportDeclErrors.end())
9376    return Pos->second;
9377  else
9378    return Optional<ImportError>();
9379}
9380
9381void ASTImporter::setImportDeclError(Decl *From, ImportError Error) {
9382  auto InsertRes = ImportDeclErrors.insert({From, Error});
9383  (void)InsertRes;
9384  // Either we set the error for the first time, or we already had set one and
9385  // now we want to set the same error.
9386  assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);
9387}
9388
9389bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
9390                                           bool Complain) {
9391  llvm::DenseMap<const Type *, const Type *>::iterator Pos =
9392      ImportedTypes.find(From.getTypePtr());
9393  if (Pos != ImportedTypes.end()) {
9394    if (ExpectedType ToFromOrErr = Import(From)) {
9395      if (ToContext.hasSameType(*ToFromOrErr, To))
9396        return true;
9397    } else {
9398      llvm::consumeError(ToFromOrErr.takeError());
9399    }
9400  }
9401
9402  StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
9403                                   getStructuralEquivalenceKind(*this), false,
9404                                   Complain);
9405  return Ctx.IsEquivalent(From, To);
9406}
9407