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