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