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