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