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