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