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