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