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