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