contrib/llvm/tools/clang/lib/AST/ASTImporter.cpp

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