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