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