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