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