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