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