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