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