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