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 VisitAtomicType(const AtomicType *T);
  43     QualType VisitBuiltinType(const BuiltinType *T);
  44     QualType VisitDecayedType(const DecayedType *T);
  45     QualType VisitComplexType(const ComplexType *T);
  46     QualType VisitPointerType(const PointerType *T);
  47     QualType VisitBlockPointerType(const BlockPointerType *T);
  48     QualType VisitLValueReferenceType(const LValueReferenceType *T);
  49     QualType VisitRValueReferenceType(const RValueReferenceType *T);
  50     QualType VisitMemberPointerType(const MemberPointerType *T);
  51     QualType VisitConstantArrayType(const ConstantArrayType *T);
  52     QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
  53     QualType VisitVariableArrayType(const VariableArrayType *T);
  54     // FIXME: DependentSizedArrayType
  55     // FIXME: DependentSizedExtVectorType
  56     QualType VisitVectorType(const VectorType *T);
  57     QualType VisitExtVectorType(const ExtVectorType *T);
  58     QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
  59     QualType VisitFunctionProtoType(const FunctionProtoType *T);
  60     // FIXME: UnresolvedUsingType
  61     QualType VisitParenType(const ParenType *T);
  62     QualType VisitTypedefType(const TypedefType *T);
  63     QualType VisitTypeOfExprType(const TypeOfExprType *T);
  64     // FIXME: DependentTypeOfExprType
  65     QualType VisitTypeOfType(const TypeOfType *T);
  66     QualType VisitDecltypeType(const DecltypeType *T);
  67     QualType VisitUnaryTransformType(const UnaryTransformType *T);
  68     QualType VisitAutoType(const AutoType *T);
  69     QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
  70     // FIXME: DependentDecltypeType
  71     QualType VisitRecordType(const RecordType *T);
  72     QualType VisitEnumType(const EnumType *T);
  73     QualType VisitAttributedType(const AttributedType *T);
  74     QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
  75     QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T);
  76     QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
  77     QualType VisitElaboratedType(const ElaboratedType *T);
  78     // FIXME: DependentNameType
  79     // FIXME: DependentTemplateSpecializationType
  80     QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
  81     QualType VisitObjCObjectType(const ObjCObjectType *T);
  82     QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
  83
  84     // Importing declarations
  85     bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
  86                          DeclContext *&LexicalDC, DeclarationName &Name,
  87                          NamedDecl *&ToD, SourceLocation &Loc);
  88     void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
  89     void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
  90                                   DeclarationNameInfo& To);
  91     void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
  92
  93     bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
  94
  95     typedef DesignatedInitExpr::Designator Designator;
  96     Designator ImportDesignator(const Designator &D);
  97
  98
  99     /// \brief What we should import from the definition.
 100     enum ImportDefinitionKind {
 101       /// \brief Import the default subset of the definition, which might be
 102       /// nothing (if minimal import is set) or might be everything (if minimal
 103       /// import is not set).
 104       IDK_Default,
 105       /// \brief Import everything.
 106       IDK_Everything,
 107       /// \brief Import only the bare bones needed to establish a valid
 108       /// DeclContext.
 109       IDK_Basic
 110     };
 111
 112     bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
 113       return IDK == IDK_Everything ||
 114              (IDK == IDK_Default && !Importer.isMinimalImport());
 115     }
 116
 117     bool ImportDefinition(RecordDecl *From, RecordDecl *To,
 118                           ImportDefinitionKind Kind = IDK_Default);
 119     bool ImportDefinition(VarDecl *From, VarDecl *To,
 120                           ImportDefinitionKind Kind = IDK_Default);
 121     bool ImportDefinition(EnumDecl *From, EnumDecl *To,
 122                           ImportDefinitionKind Kind = IDK_Default);
 123     bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
 124                           ImportDefinitionKind Kind = IDK_Default);
 125     bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
 126                           ImportDefinitionKind Kind = IDK_Default);
 127     TemplateParameterList *ImportTemplateParameterList(
 128                                                  TemplateParameterList *Params);
 129     TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
 130     TemplateArgumentLoc ImportTemplateArgumentLoc(
 131         const TemplateArgumentLoc &TALoc, bool &Error);
 132     bool ImportTemplateArguments(const TemplateArgument *FromArgs,
 133                                  unsigned NumFromArgs,
 134                                SmallVectorImpl<TemplateArgument> &ToArgs);
 135     bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
 136                            bool Complain = true);
 137     bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
 138                            bool Complain = true);
 139     bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
 140     bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
 141     bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
 142     bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
 143     Decl *VisitDecl(Decl *D);
 144     Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
 145     Decl *VisitStaticAssertDecl(StaticAssertDecl *D);
 146     Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
 147     Decl *VisitNamespaceDecl(NamespaceDecl *D);
 148     Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
 149     Decl *VisitTypedefDecl(TypedefDecl *D);
 150     Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
 151     Decl *VisitLabelDecl(LabelDecl *D);
 152     Decl *VisitEnumDecl(EnumDecl *D);
 153     Decl *VisitRecordDecl(RecordDecl *D);
 154     Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
 155     Decl *VisitFunctionDecl(FunctionDecl *D);
 156     Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
 157     Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
 158     Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
 159     Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
 160     Decl *VisitFieldDecl(FieldDecl *D);
 161     Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
 162     Decl *VisitFriendDecl(FriendDecl *D);
 163     Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
 164     Decl *VisitVarDecl(VarDecl *D);
 165     Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
 166     Decl *VisitParmVarDecl(ParmVarDecl *D);
 167     Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
 168     Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
 169     Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
 170     Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
 171     Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
 172
 173     ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
 174     Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
 175     Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
 176     Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
 177     Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
 178     Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
 179     Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
 180     Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
 181     Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
 182     Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
 183     Decl *VisitClassTemplateSpecializationDecl(
 184                                             ClassTemplateSpecializationDecl *D);
 185     Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
 186     Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
 187
 188     // Importing statements
 189     DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
 190
 191     Stmt *VisitStmt(Stmt *S);
 192     Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
 193     Stmt *VisitDeclStmt(DeclStmt *S);
 194     Stmt *VisitNullStmt(NullStmt *S);
 195     Stmt *VisitCompoundStmt(CompoundStmt *S);
 196     Stmt *VisitCaseStmt(CaseStmt *S);
 197     Stmt *VisitDefaultStmt(DefaultStmt *S);
 198     Stmt *VisitLabelStmt(LabelStmt *S);
 199     Stmt *VisitAttributedStmt(AttributedStmt *S);
 200     Stmt *VisitIfStmt(IfStmt *S);
 201     Stmt *VisitSwitchStmt(SwitchStmt *S);
 202     Stmt *VisitWhileStmt(WhileStmt *S);
 203     Stmt *VisitDoStmt(DoStmt *S);
 204     Stmt *VisitForStmt(ForStmt *S);
 205     Stmt *VisitGotoStmt(GotoStmt *S);
 206     Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
 207     Stmt *VisitContinueStmt(ContinueStmt *S);
 208     Stmt *VisitBreakStmt(BreakStmt *S);
 209     Stmt *VisitReturnStmt(ReturnStmt *S);
 210     // FIXME: MSAsmStmt
 211     // FIXME: SEHExceptStmt
 212     // FIXME: SEHFinallyStmt
 213     // FIXME: SEHTryStmt
 214     // FIXME: SEHLeaveStmt
 215     // FIXME: CapturedStmt
 216     Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
 217     Stmt *VisitCXXTryStmt(CXXTryStmt *S);
 218     Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
 219     // FIXME: MSDependentExistsStmt
 220     Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
 221     Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
 222     Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
 223     Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
 224     Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
 225     Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
 226     Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
 227
 228     // Importing expressions
 229     Expr *VisitExpr(Expr *E);
 230     Expr *VisitVAArgExpr(VAArgExpr *E);
 231     Expr *VisitGNUNullExpr(GNUNullExpr *E);
 232     Expr *VisitPredefinedExpr(PredefinedExpr *E);
 233     Expr *VisitDeclRefExpr(DeclRefExpr *E);
 234     Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE);
 235     Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
 236     Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
 237     Expr *VisitIntegerLiteral(IntegerLiteral *E);
 238     Expr *VisitFloatingLiteral(FloatingLiteral *E);
 239     Expr *VisitCharacterLiteral(CharacterLiteral *E);
 240     Expr *VisitStringLiteral(StringLiteral *E);
 241     Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
 242     Expr *VisitAtomicExpr(AtomicExpr *E);
 243     Expr *VisitAddrLabelExpr(AddrLabelExpr *E);
 244     Expr *VisitParenExpr(ParenExpr *E);
 245     Expr *VisitParenListExpr(ParenListExpr *E);
 246     Expr *VisitStmtExpr(StmtExpr *E);
 247     Expr *VisitUnaryOperator(UnaryOperator *E);
 248     Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
 249     Expr *VisitBinaryOperator(BinaryOperator *E);
 250     Expr *VisitConditionalOperator(ConditionalOperator *E);
 251     Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
 252     Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
 253     Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
 254     Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E);
 255     Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
 256     Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
 257     Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
 258     Expr *VisitExplicitCastExpr(ExplicitCastExpr *E);
 259     Expr *VisitOffsetOfExpr(OffsetOfExpr *OE);
 260     Expr *VisitCXXThrowExpr(CXXThrowExpr *E);
 261     Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
 262     Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
 263     Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
 264     Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
 265     Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE);
 266     Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
 267     Expr *VisitCXXNewExpr(CXXNewExpr *CE);
 268     Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
 269     Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
 270     Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
 271     Expr *VisitExprWithCleanups(ExprWithCleanups *EWC);
 272     Expr *VisitCXXThisExpr(CXXThisExpr *E);
 273     Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
 274     Expr *VisitMemberExpr(MemberExpr *E);
 275     Expr *VisitCallExpr(CallExpr *E);
 276     Expr *VisitInitListExpr(InitListExpr *E);
 277     Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
 278     Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
 279     Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
 280     Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
 281     Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
 282
 283
 284     template<typename IIter, typename OIter>
 285     void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
 286       typedef typename std::remove_reference<decltype(*Obegin)>::type ItemT;
 287       ASTImporter &ImporterRef = Importer;
 288       std::transform(Ibegin, Iend, Obegin,
 289                      [&ImporterRef](ItemT From) -> ItemT {
 290                        return ImporterRef.Import(From);
 291                      });
 292     }
 293
 294     template<typename IIter, typename OIter>
 295     bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
 296       typedef typename std::remove_reference<decltype(**Obegin)>::type ItemT;
 297       ASTImporter &ImporterRef = Importer;
 298       bool Failed = false;
 299       std::transform(Ibegin, Iend, Obegin,
 300                      [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
 301                        ItemT *To = cast_or_null<ItemT>(
 302                              ImporterRef.Import(From));
 303                        if (!To && From)
 304                          Failed = true;
 305                        return To;
 306                      });
 307       return Failed;
 308     }
 309
 310     template<typename InContainerTy, typename OutContainerTy>
 311     bool ImportContainerChecked(const InContainerTy &InContainer,
 312                                 OutContainerTy &OutContainer) {
 313       return ImportArrayChecked(InContainer.begin(), InContainer.end(),
 314                                 OutContainer.begin());
 315     }
 316
 317     template<typename InContainerTy, typename OIter>
 318     bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
 319       return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
 320     }
 321   };
 322 }
 323
 324 using namespace clang;
 325
 326 //----------------------------------------------------------------------------
 327 // Structural Equivalence
 328 //----------------------------------------------------------------------------
 329
 330 namespace {
 331   struct StructuralEquivalenceContext {
 332     /// \brief AST contexts for which we are checking structural equivalence.
 333     ASTContext &C1, &C2;
 334
 335     /// \brief The set of "tentative" equivalences between two canonical
 336     /// declarations, mapping from a declaration in the first context to the
 337     /// declaration in the second context that we believe to be equivalent.
 338     llvm::DenseMap<Decl *, Decl *> TentativeEquivalences;
 339
 340     /// \brief Queue of declarations in the first context whose equivalence
 341     /// with a declaration in the second context still needs to be verified.
 342     std::deque<Decl *> DeclsToCheck;
 343
 344     /// \brief Declaration (from, to) pairs that are known not to be equivalent
 345     /// (which we have already complained about).
 346     llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls;
 347
 348     /// \brief Whether we're being strict about the spelling of types when
 349     /// unifying two types.
 350     bool StrictTypeSpelling;
 351
 352     /// \brief Whether to complain about failures.
 353     bool Complain;
 354
 355     /// \brief \c true if the last diagnostic came from C2.
 356     bool LastDiagFromC2;
 357
 358     StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2,
 359                llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls,
 360                                  bool StrictTypeSpelling = false,
 361                                  bool Complain = true)
 362       : C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls),
 363         StrictTypeSpelling(StrictTypeSpelling), Complain(Complain),
 364         LastDiagFromC2(false) {}
 365
 366     /// \brief Determine whether the two declarations are structurally
 367     /// equivalent.
 368     bool IsStructurallyEquivalent(Decl *D1, Decl *D2);
 369
 370     /// \brief Determine whether the two types are structurally equivalent.
 371     bool IsStructurallyEquivalent(QualType T1, QualType T2);
 372
 373   private:
 374     /// \brief Finish checking all of the structural equivalences.
 375     ///
 376     /// \returns true if an error occurred, false otherwise.
 377     bool Finish();
 378
 379   public:
 380     DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) {
 381       assert(Complain && "Not allowed to complain");
 382       if (LastDiagFromC2)
 383         C1.getDiagnostics().notePriorDiagnosticFrom(C2.getDiagnostics());
 384       LastDiagFromC2 = false;
 385       return C1.getDiagnostics().Report(Loc, DiagID);
 386     }
 387
 388     DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) {
 389       assert(Complain && "Not allowed to complain");
 390       if (!LastDiagFromC2)
 391         C2.getDiagnostics().notePriorDiagnosticFrom(C1.getDiagnostics());
 392       LastDiagFromC2 = true;
 393       return C2.getDiagnostics().Report(Loc, DiagID);
 394     }
 395   };
 396 }
 397
 398 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 399                                      QualType T1, QualType T2);
 400 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 401                                      Decl *D1, Decl *D2);
 402 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 403                                      const TemplateArgument &Arg1,
 404                                      const TemplateArgument &Arg2);
 405
 406 /// \brief Determine structural equivalence of two expressions.
 407 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 408                                      Expr *E1, Expr *E2) {
 409   if (!E1 || !E2)
 410     return E1 == E2;
 411
 412   // FIXME: Actually perform a structural comparison!
 413   return true;
 414 }
 415
 416 /// \brief Determine whether two identifiers are equivalent.
 417 static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
 418                                      const IdentifierInfo *Name2) {
 419   if (!Name1 || !Name2)
 420     return Name1 == Name2;
 421
 422   return Name1->getName() == Name2->getName();
 423 }
 424
 425 /// \brief Determine whether two nested-name-specifiers are equivalent.
 426 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 427                                      NestedNameSpecifier *NNS1,
 428                                      NestedNameSpecifier *NNS2) {
 429   if (NNS1->getKind() != NNS2->getKind())
 430     return false;
 431
 432   NestedNameSpecifier *Prefix1 = NNS1->getPrefix(),
 433       *Prefix2 = NNS2->getPrefix();
 434   if ((bool)Prefix1 != (bool)Prefix2)
 435     return false;
 436
 437   if (Prefix1)
 438     if (!IsStructurallyEquivalent(Context, Prefix1, Prefix2))
 439       return false;
 440
 441   switch (NNS1->getKind()) {
 442   case NestedNameSpecifier::Identifier:
 443     return IsStructurallyEquivalent(NNS1->getAsIdentifier(),
 444                                     NNS2->getAsIdentifier());
 445   case NestedNameSpecifier::Namespace:
 446     return IsStructurallyEquivalent(Context, NNS1->getAsNamespace(),
 447                                     NNS2->getAsNamespace());
 448   case NestedNameSpecifier::NamespaceAlias:
 449     return IsStructurallyEquivalent(Context, NNS1->getAsNamespaceAlias(),
 450                                     NNS2->getAsNamespaceAlias());
 451   case NestedNameSpecifier::TypeSpec:
 452   case NestedNameSpecifier::TypeSpecWithTemplate:
 453     return IsStructurallyEquivalent(Context, QualType(NNS1->getAsType(), 0),
 454                                     QualType(NNS2->getAsType(), 0));
 455   case NestedNameSpecifier::Global:
 456     return true;
 457   case NestedNameSpecifier::Super:
 458     return IsStructurallyEquivalent(Context, NNS1->getAsRecordDecl(),
 459                                     NNS2->getAsRecordDecl());
 460   }
 461   return false;
 462 }
 463
 464 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 465                                      const TemplateName &N1,
 466                                      const TemplateName &N2) {
 467   if (N1.getKind() != N2.getKind())
 468     return false;
 469   switch (N1.getKind()) {
 470   case TemplateName::Template:
 471     return IsStructurallyEquivalent(Context, N1.getAsTemplateDecl(),
 472                                     N2.getAsTemplateDecl());
 473
 474   case TemplateName::OverloadedTemplate: {
 475     OverloadedTemplateStorage *OS1 = N1.getAsOverloadedTemplate(),
 476         *OS2 = N2.getAsOverloadedTemplate();
 477     OverloadedTemplateStorage::iterator I1 = OS1->begin(), I2 = OS2->begin(),
 478         E1 = OS1->end(), E2 = OS2->end();
 479     for (; I1 != E1 && I2 != E2; ++I1, ++I2)
 480       if (!IsStructurallyEquivalent(Context, *I1, *I2))
 481         return false;
 482     return I1 == E1 && I2 == E2;
 483   }
 484
 485   case TemplateName::QualifiedTemplate: {
 486     QualifiedTemplateName *QN1 = N1.getAsQualifiedTemplateName(),
 487         *QN2 = N2.getAsQualifiedTemplateName();
 488     return IsStructurallyEquivalent(Context, QN1->getDecl(), QN2->getDecl()) &&
 489         IsStructurallyEquivalent(Context, QN1->getQualifier(),
 490                                  QN2->getQualifier());
 491   }
 492
 493   case TemplateName::DependentTemplate: {
 494       DependentTemplateName *DN1 = N1.getAsDependentTemplateName(),
 495           *DN2 = N2.getAsDependentTemplateName();
 496       if (!IsStructurallyEquivalent(Context, DN1->getQualifier(),
 497                                     DN2->getQualifier()))
 498         return false;
 499       if (DN1->isIdentifier() && DN2->isIdentifier())
 500         return IsStructurallyEquivalent(DN1->getIdentifier(),
 501                                         DN2->getIdentifier());
 502       else if (DN1->isOverloadedOperator() && DN2->isOverloadedOperator())
 503         return DN1->getOperator() == DN2->getOperator();
 504       return false;
 505   }
 506
 507   case TemplateName::SubstTemplateTemplateParm: {
 508     SubstTemplateTemplateParmStorage *TS1 = N1.getAsSubstTemplateTemplateParm(),
 509         *TS2 = N2.getAsSubstTemplateTemplateParm();
 510     return IsStructurallyEquivalent(Context, TS1->getParameter(),
 511                                     TS2->getParameter()) &&
 512         IsStructurallyEquivalent(Context, TS1->getReplacement(),
 513                                  TS2->getReplacement());
 514     }
 515   case TemplateName::SubstTemplateTemplateParmPack: {
 516     SubstTemplateTemplateParmPackStorage
 517         *P1 = N1.getAsSubstTemplateTemplateParmPack(),
 518         *P2 = N2.getAsSubstTemplateTemplateParmPack();
 519     return IsStructurallyEquivalent(Context, P1->getArgumentPack(),
 520                                     P2->getArgumentPack()) &&
 521         IsStructurallyEquivalent(Context, P1->getParameterPack(),
 522                                  P2->getParameterPack());
 523   }
 524   }
 525   return false;
 526 }
 527
 528 /// \brief Determine whether two template arguments are equivalent.
 529 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 530                                      const TemplateArgument &Arg1,
 531                                      const TemplateArgument &Arg2) {
 532   if (Arg1.getKind() != Arg2.getKind())
 533     return false;
 534
 535   switch (Arg1.getKind()) {
 536   case TemplateArgument::Null:
 537     return true;
 538
 539   case TemplateArgument::Type:
 540     return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
 541
 542   case TemplateArgument::Integral:
 543     if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
 544                                           Arg2.getIntegralType()))
 545       return false;
 546
 547     return llvm::APSInt::isSameValue(Arg1.getAsIntegral(), Arg2.getAsIntegral());
 548
 549   case TemplateArgument::Declaration:
 550     return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
 551
 552   case TemplateArgument::NullPtr:
 553     return true; // FIXME: Is this correct?
 554
 555   case TemplateArgument::Template:
 556     return IsStructurallyEquivalent(Context,
 557                                     Arg1.getAsTemplate(),
 558                                     Arg2.getAsTemplate());
 559
 560   case TemplateArgument::TemplateExpansion:
 561     return IsStructurallyEquivalent(Context,
 562                                     Arg1.getAsTemplateOrTemplatePattern(),
 563                                     Arg2.getAsTemplateOrTemplatePattern());
 564
 565   case TemplateArgument::Expression:
 566     return IsStructurallyEquivalent(Context,
 567                                     Arg1.getAsExpr(), Arg2.getAsExpr());
 568
 569   case TemplateArgument::Pack:
 570     if (Arg1.pack_size() != Arg2.pack_size())
 571       return false;
 572
 573     for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
 574       if (!IsStructurallyEquivalent(Context,
 575                                     Arg1.pack_begin()[I],
 576                                     Arg2.pack_begin()[I]))
 577         return false;
 578
 579     return true;
 580   }
 581
 582   llvm_unreachable("Invalid template argument kind");
 583 }
 584
 585 /// \brief Determine structural equivalence for the common part of array
 586 /// types.
 587 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
 588                                           const ArrayType *Array1,
 589                                           const ArrayType *Array2) {
 590   if (!IsStructurallyEquivalent(Context,
 591                                 Array1->getElementType(),
 592                                 Array2->getElementType()))
 593     return false;
 594   if (Array1->getSizeModifier() != Array2->getSizeModifier())
 595     return false;
 596   if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
 597     return false;
 598
 599   return true;
 600 }
 601
 602 /// \brief Determine structural equivalence of two types.
 603 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 604                                      QualType T1, QualType T2) {
 605   if (T1.isNull() || T2.isNull())
 606     return T1.isNull() && T2.isNull();
 607
 608   if (!Context.StrictTypeSpelling) {
 609     // We aren't being strict about token-to-token equivalence of types,
 610     // so map down to the canonical type.
 611     T1 = Context.C1.getCanonicalType(T1);
 612     T2 = Context.C2.getCanonicalType(T2);
 613   }
 614
 615   if (T1.getQualifiers() != T2.getQualifiers())
 616     return false;
 617
 618   Type::TypeClass TC = T1->getTypeClass();
 619
 620   if (T1->getTypeClass() != T2->getTypeClass()) {
 621     // Compare function types with prototypes vs. without prototypes as if
 622     // both did not have prototypes.
 623     if (T1->getTypeClass() == Type::FunctionProto &&
 624         T2->getTypeClass() == Type::FunctionNoProto)
 625       TC = Type::FunctionNoProto;
 626     else if (T1->getTypeClass() == Type::FunctionNoProto &&
 627              T2->getTypeClass() == Type::FunctionProto)
 628       TC = Type::FunctionNoProto;
 629     else
 630       return false;
 631   }
 632
 633   switch (TC) {
 634   case Type::Builtin:
 635     // FIXME: Deal with Char_S/Char_U.
 636     if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
 637       return false;
 638     break;
 639
 640   case Type::Complex:
 641     if (!IsStructurallyEquivalent(Context,
 642                                   cast<ComplexType>(T1)->getElementType(),
 643                                   cast<ComplexType>(T2)->getElementType()))
 644       return false;
 645     break;
 646
 647   case Type::Adjusted:
 648   case Type::Decayed:
 649     if (!IsStructurallyEquivalent(Context,
 650                                   cast<AdjustedType>(T1)->getOriginalType(),
 651                                   cast<AdjustedType>(T2)->getOriginalType()))
 652       return false;
 653     break;
 654
 655   case Type::Pointer:
 656     if (!IsStructurallyEquivalent(Context,
 657                                   cast<PointerType>(T1)->getPointeeType(),
 658                                   cast<PointerType>(T2)->getPointeeType()))
 659       return false;
 660     break;
 661
 662   case Type::BlockPointer:
 663     if (!IsStructurallyEquivalent(Context,
 664                                   cast<BlockPointerType>(T1)->getPointeeType(),
 665                                   cast<BlockPointerType>(T2)->getPointeeType()))
 666       return false;
 667     break;
 668
 669   case Type::LValueReference:
 670   case Type::RValueReference: {
 671     const ReferenceType *Ref1 = cast<ReferenceType>(T1);
 672     const ReferenceType *Ref2 = cast<ReferenceType>(T2);
 673     if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
 674       return false;
 675     if (Ref1->isInnerRef() != Ref2->isInnerRef())
 676       return false;
 677     if (!IsStructurallyEquivalent(Context,
 678                                   Ref1->getPointeeTypeAsWritten(),
 679                                   Ref2->getPointeeTypeAsWritten()))
 680       return false;
 681     break;
 682   }
 683
 684   case Type::MemberPointer: {
 685     const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
 686     const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
 687     if (!IsStructurallyEquivalent(Context,
 688                                   MemPtr1->getPointeeType(),
 689                                   MemPtr2->getPointeeType()))
 690       return false;
 691     if (!IsStructurallyEquivalent(Context,
 692                                   QualType(MemPtr1->getClass(), 0),
 693                                   QualType(MemPtr2->getClass(), 0)))
 694       return false;
 695     break;
 696   }
 697
 698   case Type::ConstantArray: {
 699     const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
 700     const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
 701     if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
 702       return false;
 703
 704     if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
 705       return false;
 706     break;
 707   }
 708
 709   case Type::IncompleteArray:
 710     if (!IsArrayStructurallyEquivalent(Context,
 711                                        cast<ArrayType>(T1),
 712                                        cast<ArrayType>(T2)))
 713       return false;
 714     break;
 715
 716   case Type::VariableArray: {
 717     const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
 718     const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
 719     if (!IsStructurallyEquivalent(Context,
 720                                   Array1->getSizeExpr(), Array2->getSizeExpr()))
 721       return false;
 722
 723     if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
 724       return false;
 725
 726     break;
 727   }
 728
 729   case Type::DependentSizedArray: {
 730     const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
 731     const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
 732     if (!IsStructurallyEquivalent(Context,
 733                                   Array1->getSizeExpr(), Array2->getSizeExpr()))
 734       return false;
 735
 736     if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
 737       return false;
 738
 739     break;
 740   }
 741
 742   case Type::DependentSizedExtVector: {
 743     const DependentSizedExtVectorType *Vec1
 744       = cast<DependentSizedExtVectorType>(T1);
 745     const DependentSizedExtVectorType *Vec2
 746       = cast<DependentSizedExtVectorType>(T2);
 747     if (!IsStructurallyEquivalent(Context,
 748                                   Vec1->getSizeExpr(), Vec2->getSizeExpr()))
 749       return false;
 750     if (!IsStructurallyEquivalent(Context,
 751                                   Vec1->getElementType(),
 752                                   Vec2->getElementType()))
 753       return false;
 754     break;
 755   }
 756
 757   case Type::Vector:
 758   case Type::ExtVector: {
 759     const VectorType *Vec1 = cast<VectorType>(T1);
 760     const VectorType *Vec2 = cast<VectorType>(T2);
 761     if (!IsStructurallyEquivalent(Context,
 762                                   Vec1->getElementType(),
 763                                   Vec2->getElementType()))
 764       return false;
 765     if (Vec1->getNumElements() != Vec2->getNumElements())
 766       return false;
 767     if (Vec1->getVectorKind() != Vec2->getVectorKind())
 768       return false;
 769     break;
 770   }
 771
 772   case Type::FunctionProto: {
 773     const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
 774     const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
 775     if (Proto1->getNumParams() != Proto2->getNumParams())
 776       return false;
 777     for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
 778       if (!IsStructurallyEquivalent(Context, Proto1->getParamType(I),
 779                                     Proto2->getParamType(I)))
 780         return false;
 781     }
 782     if (Proto1->isVariadic() != Proto2->isVariadic())
 783       return false;
 784     if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
 785       return false;
 786     if (Proto1->getExceptionSpecType() == EST_Dynamic) {
 787       if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
 788         return false;
 789       for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
 790         if (!IsStructurallyEquivalent(Context,
 791                                       Proto1->getExceptionType(I),
 792                                       Proto2->getExceptionType(I)))
 793           return false;
 794       }
 795     } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
 796       if (!IsStructurallyEquivalent(Context,
 797                                     Proto1->getNoexceptExpr(),
 798                                     Proto2->getNoexceptExpr()))
 799         return false;
 800     }
 801     if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
 802       return false;
 803
 804     // Fall through to check the bits common with FunctionNoProtoType.
 805   }
 806
 807   case Type::FunctionNoProto: {
 808     const FunctionType *Function1 = cast<FunctionType>(T1);
 809     const FunctionType *Function2 = cast<FunctionType>(T2);
 810     if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
 811                                   Function2->getReturnType()))
 812       return false;
 813     if (Function1->getExtInfo() != Function2->getExtInfo())
 814       return false;
 815     break;
 816   }
 817
 818   case Type::UnresolvedUsing:
 819     if (!IsStructurallyEquivalent(Context,
 820                                   cast<UnresolvedUsingType>(T1)->getDecl(),
 821                                   cast<UnresolvedUsingType>(T2)->getDecl()))
 822       return false;
 823
 824     break;
 825
 826   case Type::Attributed:
 827     if (!IsStructurallyEquivalent(Context,
 828                                   cast<AttributedType>(T1)->getModifiedType(),
 829                                   cast<AttributedType>(T2)->getModifiedType()))
 830       return false;
 831     if (!IsStructurallyEquivalent(Context,
 832                                 cast<AttributedType>(T1)->getEquivalentType(),
 833                                 cast<AttributedType>(T2)->getEquivalentType()))
 834       return false;
 835     break;
 836
 837   case Type::Paren:
 838     if (!IsStructurallyEquivalent(Context,
 839                                   cast<ParenType>(T1)->getInnerType(),
 840                                   cast<ParenType>(T2)->getInnerType()))
 841       return false;
 842     break;
 843
 844   case Type::Typedef:
 845     if (!IsStructurallyEquivalent(Context,
 846                                   cast<TypedefType>(T1)->getDecl(),
 847                                   cast<TypedefType>(T2)->getDecl()))
 848       return false;
 849     break;
 850
 851   case Type::TypeOfExpr:
 852     if (!IsStructurallyEquivalent(Context,
 853                                 cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
 854                                 cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
 855       return false;
 856     break;
 857
 858   case Type::TypeOf:
 859     if (!IsStructurallyEquivalent(Context,
 860                                   cast<TypeOfType>(T1)->getUnderlyingType(),
 861                                   cast<TypeOfType>(T2)->getUnderlyingType()))
 862       return false;
 863     break;
 864
 865   case Type::UnaryTransform:
 866     if (!IsStructurallyEquivalent(Context,
 867                              cast<UnaryTransformType>(T1)->getUnderlyingType(),
 868                              cast<UnaryTransformType>(T1)->getUnderlyingType()))
 869       return false;
 870     break;
 871
 872   case Type::Decltype:
 873     if (!IsStructurallyEquivalent(Context,
 874                                   cast<DecltypeType>(T1)->getUnderlyingExpr(),
 875                                   cast<DecltypeType>(T2)->getUnderlyingExpr()))
 876       return false;
 877     break;
 878
 879   case Type::Auto:
 880     if (!IsStructurallyEquivalent(Context,
 881                                   cast<AutoType>(T1)->getDeducedType(),
 882                                   cast<AutoType>(T2)->getDeducedType()))
 883       return false;
 884     break;
 885
 886   case Type::DeducedTemplateSpecialization: {
 887     auto *DT1 = cast<DeducedTemplateSpecializationType>(T1);
 888     auto *DT2 = cast<DeducedTemplateSpecializationType>(T2);
 889     if (!IsStructurallyEquivalent(Context,
 890                                   DT1->getTemplateName(),
 891                                   DT2->getTemplateName()))
 892       return false;
 893     if (!IsStructurallyEquivalent(Context,
 894                                   DT1->getDeducedType(),
 895                                   DT2->getDeducedType()))
 896       return false;
 897     break;
 898   }
 899
 900   case Type::Record:
 901   case Type::Enum:
 902     if (!IsStructurallyEquivalent(Context,
 903                                   cast<TagType>(T1)->getDecl(),
 904                                   cast<TagType>(T2)->getDecl()))
 905       return false;
 906     break;
 907
 908   case Type::TemplateTypeParm: {
 909     const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
 910     const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
 911     if (Parm1->getDepth() != Parm2->getDepth())
 912       return false;
 913     if (Parm1->getIndex() != Parm2->getIndex())
 914       return false;
 915     if (Parm1->isParameterPack() != Parm2->isParameterPack())
 916       return false;
 917
 918     // Names of template type parameters are never significant.
 919     break;
 920   }
 921
 922   case Type::SubstTemplateTypeParm: {
 923     const SubstTemplateTypeParmType *Subst1
 924       = cast<SubstTemplateTypeParmType>(T1);
 925     const SubstTemplateTypeParmType *Subst2
 926       = cast<SubstTemplateTypeParmType>(T2);
 927     if (!IsStructurallyEquivalent(Context,
 928                                   QualType(Subst1->getReplacedParameter(), 0),
 929                                   QualType(Subst2->getReplacedParameter(), 0)))
 930       return false;
 931     if (!IsStructurallyEquivalent(Context,
 932                                   Subst1->getReplacementType(),
 933                                   Subst2->getReplacementType()))
 934       return false;
 935     break;
 936   }
 937
 938   case Type::SubstTemplateTypeParmPack: {
 939     const SubstTemplateTypeParmPackType *Subst1
 940       = cast<SubstTemplateTypeParmPackType>(T1);
 941     const SubstTemplateTypeParmPackType *Subst2
 942       = cast<SubstTemplateTypeParmPackType>(T2);
 943     if (!IsStructurallyEquivalent(Context,
 944                                   QualType(Subst1->getReplacedParameter(), 0),
 945                                   QualType(Subst2->getReplacedParameter(), 0)))
 946       return false;
 947     if (!IsStructurallyEquivalent(Context,
 948                                   Subst1->getArgumentPack(),
 949                                   Subst2->getArgumentPack()))
 950       return false;
 951     break;
 952   }
 953   case Type::TemplateSpecialization: {
 954     const TemplateSpecializationType *Spec1
 955       = cast<TemplateSpecializationType>(T1);
 956     const TemplateSpecializationType *Spec2
 957       = cast<TemplateSpecializationType>(T2);
 958     if (!IsStructurallyEquivalent(Context,
 959                                   Spec1->getTemplateName(),
 960                                   Spec2->getTemplateName()))
 961       return false;
 962     if (Spec1->getNumArgs() != Spec2->getNumArgs())
 963       return false;
 964     for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
 965       if (!IsStructurallyEquivalent(Context,
 966                                     Spec1->getArg(I), Spec2->getArg(I)))
 967         return false;
 968     }
 969     break;
 970   }
 971
 972   case Type::Elaborated: {
 973     const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
 974     const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
 975     // CHECKME: what if a keyword is ETK_None or ETK_typename ?
 976     if (Elab1->getKeyword() != Elab2->getKeyword())
 977       return false;
 978     if (!IsStructurallyEquivalent(Context,
 979                                   Elab1->getQualifier(),
 980                                   Elab2->getQualifier()))
 981       return false;
 982     if (!IsStructurallyEquivalent(Context,
 983                                   Elab1->getNamedType(),
 984                                   Elab2->getNamedType()))
 985       return false;
 986     break;
 987   }
 988
 989   case Type::InjectedClassName: {
 990     const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
 991     const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
 992     if (!IsStructurallyEquivalent(Context,
 993                                   Inj1->getInjectedSpecializationType(),
 994                                   Inj2->getInjectedSpecializationType()))
 995       return false;
 996     break;
 997   }
 998
 999   case Type::DependentName: {
1000     const DependentNameType *Typename1 = cast<DependentNameType>(T1);
1001     const DependentNameType *Typename2 = cast<DependentNameType>(T2);
1002     if (!IsStructurallyEquivalent(Context,
1003                                   Typename1->getQualifier(),
1004                                   Typename2->getQualifier()))
1005       return false;
1006     if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
1007                                   Typename2->getIdentifier()))
1008       return false;
1009
1010     break;
1011   }
1012
1013   case Type::DependentTemplateSpecialization: {
1014     const DependentTemplateSpecializationType *Spec1 =
1015       cast<DependentTemplateSpecializationType>(T1);
1016     const DependentTemplateSpecializationType *Spec2 =
1017       cast<DependentTemplateSpecializationType>(T2);
1018     if (!IsStructurallyEquivalent(Context,
1019                                   Spec1->getQualifier(),
1020                                   Spec2->getQualifier()))
1021       return false;
1022     if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
1023                                   Spec2->getIdentifier()))
1024       return false;
1025     if (Spec1->getNumArgs() != Spec2->getNumArgs())
1026       return false;
1027     for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
1028       if (!IsStructurallyEquivalent(Context,
1029                                     Spec1->getArg(I), Spec2->getArg(I)))
1030         return false;
1031     }
1032     break;
1033   }
1034
1035   case Type::PackExpansion:
1036     if (!IsStructurallyEquivalent(Context,
1037                                   cast<PackExpansionType>(T1)->getPattern(),
1038                                   cast<PackExpansionType>(T2)->getPattern()))
1039       return false;
1040     break;
1041
1042   case Type::ObjCInterface: {
1043     const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
1044     const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
1045     if (!IsStructurallyEquivalent(Context,
1046                                   Iface1->getDecl(), Iface2->getDecl()))
1047       return false;
1048     break;
1049   }
1050
1051   case Type::ObjCTypeParam: {
1052     const ObjCTypeParamType *Obj1 = cast<ObjCTypeParamType>(T1);
1053     const ObjCTypeParamType *Obj2 = cast<ObjCTypeParamType>(T2);
1054     if (!IsStructurallyEquivalent(Context, Obj1->getDecl(),
1055                                   Obj2->getDecl()))
1056       return false;
1057
1058     if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
1059       return false;
1060     for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
1061       if (!IsStructurallyEquivalent(Context,
1062                                     Obj1->getProtocol(I),
1063                                     Obj2->getProtocol(I)))
1064         return false;
1065     }
1066     break;
1067   }
1068   case Type::ObjCObject: {
1069     const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
1070     const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
1071     if (!IsStructurallyEquivalent(Context,
1072                                   Obj1->getBaseType(),
1073                                   Obj2->getBaseType()))
1074       return false;
1075     if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
1076       return false;
1077     for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
1078       if (!IsStructurallyEquivalent(Context,
1079                                     Obj1->getProtocol(I),
1080                                     Obj2->getProtocol(I)))
1081         return false;
1082     }
1083     break;
1084   }
1085
1086   case Type::ObjCObjectPointer: {
1087     const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
1088     const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
1089     if (!IsStructurallyEquivalent(Context,
1090                                   Ptr1->getPointeeType(),
1091                                   Ptr2->getPointeeType()))
1092       return false;
1093     break;
1094   }
1095
1096   case Type::Atomic: {
1097     if (!IsStructurallyEquivalent(Context,
1098                                   cast<AtomicType>(T1)->getValueType(),
1099                                   cast<AtomicType>(T2)->getValueType()))
1100       return false;
1101     break;
1102   }
1103
1104   case Type::Pipe: {
1105     if (!IsStructurallyEquivalent(Context,
1106                                   cast<PipeType>(T1)->getElementType(),
1107                                   cast<PipeType>(T2)->getElementType()))
1108       return false;
1109     break;
1110   }
1111
1112   } // end switch
1113
1114   return true;
1115 }
1116
1117 /// \brief Determine structural equivalence of two fields.
1118 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1119                                      FieldDecl *Field1, FieldDecl *Field2) {
1120   RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
1121
1122   // For anonymous structs/unions, match up the anonymous struct/union type
1123   // declarations directly, so that we don't go off searching for anonymous
1124   // types
1125   if (Field1->isAnonymousStructOrUnion() &&
1126       Field2->isAnonymousStructOrUnion()) {
1127     RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
1128     RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
1129     return IsStructurallyEquivalent(Context, D1, D2);
1130   }
1131
1132   // Check for equivalent field names.
1133   IdentifierInfo *Name1 = Field1->getIdentifier();
1134   IdentifierInfo *Name2 = Field2->getIdentifier();
1135   if (!::IsStructurallyEquivalent(Name1, Name2))
1136     return false;
1137
1138   if (!IsStructurallyEquivalent(Context,
1139                                 Field1->getType(), Field2->getType())) {
1140     if (Context.Complain) {
1141       Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1142         << Context.C2.getTypeDeclType(Owner2);
1143       Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1144         << Field2->getDeclName() << Field2->getType();
1145       Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1146         << Field1->getDeclName() << Field1->getType();
1147     }
1148     return false;
1149   }
1150
1151   if (Field1->isBitField() != Field2->isBitField()) {
1152     if (Context.Complain) {
1153       Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1154         << Context.C2.getTypeDeclType(Owner2);
1155       if (Field1->isBitField()) {
1156         Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
1157         << Field1->getDeclName() << Field1->getType()
1158         << Field1->getBitWidthValue(Context.C1);
1159         Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
1160         << Field2->getDeclName();
1161       } else {
1162         Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
1163         << Field2->getDeclName() << Field2->getType()
1164         << Field2->getBitWidthValue(Context.C2);
1165         Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
1166         << Field1->getDeclName();
1167       }
1168     }
1169     return false;
1170   }
1171
1172   if (Field1->isBitField()) {
1173     // Make sure that the bit-fields are the same length.
1174     unsigned Bits1 = Field1->getBitWidthValue(Context.C1);
1175     unsigned Bits2 = Field2->getBitWidthValue(Context.C2);
1176
1177     if (Bits1 != Bits2) {
1178       if (Context.Complain) {
1179         Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1180           << Context.C2.getTypeDeclType(Owner2);
1181         Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
1182           << Field2->getDeclName() << Field2->getType() << Bits2;
1183         Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
1184           << Field1->getDeclName() << Field1->getType() << Bits1;
1185       }
1186       return false;
1187     }
1188   }
1189
1190   return true;
1191 }
1192
1193 /// \brief Find the index of the given anonymous struct/union within its
1194 /// context.
1195 ///
1196 /// \returns Returns the index of this anonymous struct/union in its context,
1197 /// including the next assigned index (if none of them match). Returns an
1198 /// empty option if the context is not a record, i.e.. if the anonymous
1199 /// struct/union is at namespace or block scope.
1200 static Optional<unsigned> findUntaggedStructOrUnionIndex(RecordDecl *Anon) {
1201   ASTContext &Context = Anon->getASTContext();
1202   QualType AnonTy = Context.getRecordType(Anon);
1203
1204   RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
1205   if (!Owner)
1206     return None;
1207
1208   unsigned Index = 0;
1209   for (const auto *D : Owner->noload_decls()) {
1210     const auto *F = dyn_cast<FieldDecl>(D);
1211     if (!F)
1212       continue;
1213
1214     if (F->isAnonymousStructOrUnion()) {
1215       if (Context.hasSameType(F->getType(), AnonTy))
1216         break;
1217       ++Index;
1218       continue;
1219     }
1220
1221     // If the field looks like this:
1222     // struct { ... } A;
1223     QualType FieldType = F->getType();
1224     if (const auto *RecType = dyn_cast<RecordType>(FieldType)) {
1225       const RecordDecl *RecDecl = RecType->getDecl();
1226       if (RecDecl->getDeclContext() == Owner &&
1227           !RecDecl->getIdentifier()) {
1228         if (Context.hasSameType(FieldType, AnonTy))
1229           break;
1230         ++Index;
1231         continue;
1232       }
1233     }
1234   }
1235
1236   return Index;
1237 }
1238
1239 /// \brief Determine structural equivalence of two records.
1240 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1241                                      RecordDecl *D1, RecordDecl *D2) {
1242   if (D1->isUnion() != D2->isUnion()) {
1243     if (Context.Complain) {
1244       Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1245         << Context.C2.getTypeDeclType(D2);
1246       Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
1247         << D1->getDeclName() << (unsigned)D1->getTagKind();
1248     }
1249     return false;
1250   }
1251
1252   if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) {
1253     // If both anonymous structs/unions are in a record context, make sure
1254     // they occur in the same location in the context records.
1255     if (Optional<unsigned> Index1 = findUntaggedStructOrUnionIndex(D1)) {
1256       if (Optional<unsigned> Index2 = findUntaggedStructOrUnionIndex(D2)) {
1257         if (*Index1 != *Index2)
1258           return false;
1259       }
1260     }
1261   }
1262
1263   // If both declarations are class template specializations, we know
1264   // the ODR applies, so check the template and template arguments.
1265   ClassTemplateSpecializationDecl *Spec1
1266     = dyn_cast<ClassTemplateSpecializationDecl>(D1);
1267   ClassTemplateSpecializationDecl *Spec2
1268     = dyn_cast<ClassTemplateSpecializationDecl>(D2);
1269   if (Spec1 && Spec2) {
1270     // Check that the specialized templates are the same.
1271     if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
1272                                   Spec2->getSpecializedTemplate()))
1273       return false;
1274
1275     // Check that the template arguments are the same.
1276     if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
1277       return false;
1278
1279     for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
1280       if (!IsStructurallyEquivalent(Context,
1281                                     Spec1->getTemplateArgs().get(I),
1282                                     Spec2->getTemplateArgs().get(I)))
1283         return false;
1284   }
1285   // If one is a class template specialization and the other is not, these
1286   // structures are different.
1287   else if (Spec1 || Spec2)
1288     return false;
1289
1290   // Compare the definitions of these two records. If either or both are
1291   // incomplete, we assume that they are equivalent.
1292   D1 = D1->getDefinition();
1293   D2 = D2->getDefinition();
1294   if (!D1 || !D2)
1295     return true;
1296
1297   if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
1298     if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
1299       if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
1300         if (Context.Complain) {
1301           Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1302             << Context.C2.getTypeDeclType(D2);
1303           Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
1304             << D2CXX->getNumBases();
1305           Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
1306             << D1CXX->getNumBases();
1307         }
1308         return false;
1309       }
1310
1311       // Check the base classes.
1312       for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
1313                                            BaseEnd1 = D1CXX->bases_end(),
1314                                                 Base2 = D2CXX->bases_begin();
1315            Base1 != BaseEnd1;
1316            ++Base1, ++Base2) {
1317         if (!IsStructurallyEquivalent(Context,
1318                                       Base1->getType(), Base2->getType())) {
1319           if (Context.Complain) {
1320             Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1321               << Context.C2.getTypeDeclType(D2);
1322             Context.Diag2(Base2->getLocStart(), diag::note_odr_base)
1323               << Base2->getType()
1324               << Base2->getSourceRange();
1325             Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1326               << Base1->getType()
1327               << Base1->getSourceRange();
1328           }
1329           return false;
1330         }
1331
1332         // Check virtual vs. non-virtual inheritance mismatch.
1333         if (Base1->isVirtual() != Base2->isVirtual()) {
1334           if (Context.Complain) {
1335             Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1336               << Context.C2.getTypeDeclType(D2);
1337             Context.Diag2(Base2->getLocStart(),
1338                           diag::note_odr_virtual_base)
1339               << Base2->isVirtual() << Base2->getSourceRange();
1340             Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1341               << Base1->isVirtual()
1342               << Base1->getSourceRange();
1343           }
1344           return false;
1345         }
1346       }
1347     } else if (D1CXX->getNumBases() > 0) {
1348       if (Context.Complain) {
1349         Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1350           << Context.C2.getTypeDeclType(D2);
1351         const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
1352         Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1353           << Base1->getType()
1354           << Base1->getSourceRange();
1355         Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
1356       }
1357       return false;
1358     }
1359   }
1360
1361   // Check the fields for consistency.
1362   RecordDecl::field_iterator Field2 = D2->field_begin(),
1363                              Field2End = D2->field_end();
1364   for (RecordDecl::field_iterator Field1 = D1->field_begin(),
1365                                   Field1End = D1->field_end();
1366        Field1 != Field1End;
1367        ++Field1, ++Field2) {
1368     if (Field2 == Field2End) {
1369       if (Context.Complain) {
1370         Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1371           << Context.C2.getTypeDeclType(D2);
1372         Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1373           << Field1->getDeclName() << Field1->getType();
1374         Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
1375       }
1376       return false;
1377     }
1378
1379     if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
1380       return false;
1381   }
1382
1383   if (Field2 != Field2End) {
1384     if (Context.Complain) {
1385       Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1386         << Context.C2.getTypeDeclType(D2);
1387       Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1388         << Field2->getDeclName() << Field2->getType();
1389       Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
1390     }
1391     return false;
1392   }
1393
1394   return true;
1395 }
1396
1397 /// \brief Determine structural equivalence of two enums.
1398 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1399                                      EnumDecl *D1, EnumDecl *D2) {
1400   EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(),
1401                              EC2End = D2->enumerator_end();
1402   for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(),
1403                                   EC1End = D1->enumerator_end();
1404        EC1 != EC1End; ++EC1, ++EC2) {
1405     if (EC2 == EC2End) {
1406       if (Context.Complain) {
1407         Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1408           << Context.C2.getTypeDeclType(D2);
1409         Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1410           << EC1->getDeclName()
1411           << EC1->getInitVal().toString(10);
1412         Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
1413       }
1414       return false;
1415     }
1416
1417     llvm::APSInt Val1 = EC1->getInitVal();
1418     llvm::APSInt Val2 = EC2->getInitVal();
1419     if (!llvm::APSInt::isSameValue(Val1, Val2) ||
1420         !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
1421       if (Context.Complain) {
1422         Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1423           << Context.C2.getTypeDeclType(D2);
1424         Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1425           << EC2->getDeclName()
1426           << EC2->getInitVal().toString(10);
1427         Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1428           << EC1->getDeclName()
1429           << EC1->getInitVal().toString(10);
1430       }
1431       return false;
1432     }
1433   }
1434
1435   if (EC2 != EC2End) {
1436     if (Context.Complain) {
1437       Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1438         << Context.C2.getTypeDeclType(D2);
1439       Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1440         << EC2->getDeclName()
1441         << EC2->getInitVal().toString(10);
1442       Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
1443     }
1444     return false;
1445   }
1446
1447   return true;
1448 }
1449
1450 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1451                                      TemplateParameterList *Params1,
1452                                      TemplateParameterList *Params2) {
1453   if (Params1->size() != Params2->size()) {
1454     if (Context.Complain) {
1455       Context.Diag2(Params2->getTemplateLoc(),
1456                     diag::err_odr_different_num_template_parameters)
1457         << Params1->size() << Params2->size();
1458       Context.Diag1(Params1->getTemplateLoc(),
1459                     diag::note_odr_template_parameter_list);
1460     }
1461     return false;
1462   }
1463
1464   for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
1465     if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
1466       if (Context.Complain) {
1467         Context.Diag2(Params2->getParam(I)->getLocation(),
1468                       diag::err_odr_different_template_parameter_kind);
1469         Context.Diag1(Params1->getParam(I)->getLocation(),
1470                       diag::note_odr_template_parameter_here);
1471       }
1472       return false;
1473     }
1474
1475     if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
1476                                           Params2->getParam(I))) {
1477
1478       return false;
1479     }
1480   }
1481
1482   return true;
1483 }
1484
1485 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1486                                      TemplateTypeParmDecl *D1,
1487                                      TemplateTypeParmDecl *D2) {
1488   if (D1->isParameterPack() != D2->isParameterPack()) {
1489     if (Context.Complain) {
1490       Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1491         << D2->isParameterPack();
1492       Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1493         << D1->isParameterPack();
1494     }
1495     return false;
1496   }
1497
1498   return true;
1499 }
1500
1501 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1502                                      NonTypeTemplateParmDecl *D1,
1503                                      NonTypeTemplateParmDecl *D2) {
1504   if (D1->isParameterPack() != D2->isParameterPack()) {
1505     if (Context.Complain) {
1506       Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1507         << D2->isParameterPack();
1508       Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1509         << D1->isParameterPack();
1510     }
1511     return false;
1512   }
1513
1514   // Check types.
1515   if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
1516     if (Context.Complain) {
1517       Context.Diag2(D2->getLocation(),
1518                     diag::err_odr_non_type_parameter_type_inconsistent)
1519         << D2->getType() << D1->getType();
1520       Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
1521         << D1->getType();
1522     }
1523     return false;
1524   }
1525
1526   return true;
1527 }
1528
1529 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1530                                      TemplateTemplateParmDecl *D1,
1531                                      TemplateTemplateParmDecl *D2) {
1532   if (D1->isParameterPack() != D2->isParameterPack()) {
1533     if (Context.Complain) {
1534       Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1535         << D2->isParameterPack();
1536       Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1537         << D1->isParameterPack();
1538     }
1539     return false;
1540   }
1541
1542   // Check template parameter lists.
1543   return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1544                                   D2->getTemplateParameters());
1545 }
1546
1547 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1548                                      ClassTemplateDecl *D1,
1549                                      ClassTemplateDecl *D2) {
1550   // Check template parameters.
1551   if (!IsStructurallyEquivalent(Context,
1552                                 D1->getTemplateParameters(),
1553                                 D2->getTemplateParameters()))
1554     return false;
1555
1556   // Check the templated declaration.
1557   return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
1558                                           D2->getTemplatedDecl());
1559 }
1560
1561 /// \brief Determine structural equivalence of two declarations.
1562 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1563                                      Decl *D1, Decl *D2) {
1564   // FIXME: Check for known structural equivalences via a callback of some sort.
1565
1566   // Check whether we already know that these two declarations are not
1567   // structurally equivalent.
1568   if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(),
1569                                                       D2->getCanonicalDecl())))
1570     return false;
1571
1572   // Determine whether we've already produced a tentative equivalence for D1.
1573   Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
1574   if (EquivToD1)
1575     return EquivToD1 == D2->getCanonicalDecl();
1576
1577   // Produce a tentative equivalence D1 <-> D2, which will be checked later.
1578   EquivToD1 = D2->getCanonicalDecl();
1579   Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
1580   return true;
1581 }
1582
1583 bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
1584                                                             Decl *D2) {
1585   if (!::IsStructurallyEquivalent(*this, D1, D2))
1586     return false;
1587
1588   return !Finish();
1589 }
1590
1591 bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
1592                                                             QualType T2) {
1593   if (!::IsStructurallyEquivalent(*this, T1, T2))
1594     return false;
1595
1596   return !Finish();
1597 }
1598
1599 bool StructuralEquivalenceContext::Finish() {
1600   while (!DeclsToCheck.empty()) {
1601     // Check the next declaration.
1602     Decl *D1 = DeclsToCheck.front();
1603     DeclsToCheck.pop_front();
1604
1605     Decl *D2 = TentativeEquivalences[D1];
1606     assert(D2 && "Unrecorded tentative equivalence?");
1607
1608     bool Equivalent = true;
1609
1610     // FIXME: Switch on all declaration kinds. For now, we're just going to
1611     // check the obvious ones.
1612     if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
1613       if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
1614         // Check for equivalent structure names.
1615         IdentifierInfo *Name1 = Record1->getIdentifier();
1616         if (!Name1 && Record1->getTypedefNameForAnonDecl())
1617           Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
1618         IdentifierInfo *Name2 = Record2->getIdentifier();
1619         if (!Name2 && Record2->getTypedefNameForAnonDecl())
1620           Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
1621         if (!::IsStructurallyEquivalent(Name1, Name2) ||
1622             !::IsStructurallyEquivalent(*this, Record1, Record2))
1623           Equivalent = false;
1624       } else {
1625         // Record/non-record mismatch.
1626         Equivalent = false;
1627       }
1628     } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
1629       if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
1630         // Check for equivalent enum names.
1631         IdentifierInfo *Name1 = Enum1->getIdentifier();
1632         if (!Name1 && Enum1->getTypedefNameForAnonDecl())
1633           Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
1634         IdentifierInfo *Name2 = Enum2->getIdentifier();
1635         if (!Name2 && Enum2->getTypedefNameForAnonDecl())
1636           Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
1637         if (!::IsStructurallyEquivalent(Name1, Name2) ||
1638             !::IsStructurallyEquivalent(*this, Enum1, Enum2))
1639           Equivalent = false;
1640       } else {
1641         // Enum/non-enum mismatch
1642         Equivalent = false;
1643       }
1644     } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
1645       if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
1646         if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
1647                                         Typedef2->getIdentifier()) ||
1648             !::IsStructurallyEquivalent(*this,
1649                                         Typedef1->getUnderlyingType(),
1650                                         Typedef2->getUnderlyingType()))
1651           Equivalent = false;
1652       } else {
1653         // Typedef/non-typedef mismatch.
1654         Equivalent = false;
1655       }
1656     } else if (ClassTemplateDecl *ClassTemplate1
1657                                            = dyn_cast<ClassTemplateDecl>(D1)) {
1658       if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
1659         if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
1660                                         ClassTemplate2->getIdentifier()) ||
1661             !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
1662           Equivalent = false;
1663       } else {
1664         // Class template/non-class-template mismatch.
1665         Equivalent = false;
1666       }
1667     } else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) {
1668       if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
1669         if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1670           Equivalent = false;
1671       } else {
1672         // Kind mismatch.
1673         Equivalent = false;
1674       }
1675     } else if (NonTypeTemplateParmDecl *NTTP1
1676                                      = dyn_cast<NonTypeTemplateParmDecl>(D1)) {
1677       if (NonTypeTemplateParmDecl *NTTP2
1678                                       = dyn_cast<NonTypeTemplateParmDecl>(D2)) {
1679         if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
1680           Equivalent = false;
1681       } else {
1682         // Kind mismatch.
1683         Equivalent = false;
1684       }
1685     } else if (TemplateTemplateParmDecl *TTP1
1686                                   = dyn_cast<TemplateTemplateParmDecl>(D1)) {
1687       if (TemplateTemplateParmDecl *TTP2
1688                                     = dyn_cast<TemplateTemplateParmDecl>(D2)) {
1689         if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1690           Equivalent = false;
1691       } else {
1692         // Kind mismatch.
1693         Equivalent = false;
1694       }
1695     }
1696
1697     if (!Equivalent) {
1698       // Note that these two declarations are not equivalent (and we already
1699       // know about it).
1700       NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(),
1701                                                D2->getCanonicalDecl()));
1702       return true;
1703     }
1704     // FIXME: Check other declaration kinds!
1705   }
1706
1707   return false;
1708 }
1709
1710 //----------------------------------------------------------------------------
1711 // Import Types
1712 //----------------------------------------------------------------------------
1713
1714 QualType ASTNodeImporter::VisitType(const Type *T) {
1715   Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1716     << T->getTypeClassName();
1717   return QualType();
1718 }
1719
1720 QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
1721   QualType UnderlyingType = Importer.Import(T->getValueType());
1722   if(UnderlyingType.isNull())
1723     return QualType();
1724
1725   return Importer.getToContext().getAtomicType(UnderlyingType);
1726 }
1727
1728 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1729   switch (T->getKind()) {
1730 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1731   case BuiltinType::Id: \
1732     return Importer.getToContext().SingletonId;
1733 #include "clang/Basic/OpenCLImageTypes.def"
1734 #define SHARED_SINGLETON_TYPE(Expansion)
1735 #define BUILTIN_TYPE(Id, SingletonId) \
1736   case BuiltinType::Id: return Importer.getToContext().SingletonId;
1737 #include "clang/AST/BuiltinTypes.def"
1738
1739   // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1740   // context supports C++.
1741
1742   // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1743   // context supports ObjC.
1744
1745   case BuiltinType::Char_U:
1746     // The context we're importing from has an unsigned 'char'. If we're
1747     // importing into a context with a signed 'char', translate to
1748     // 'unsigned char' instead.
1749     if (Importer.getToContext().getLangOpts().CharIsSigned)
1750       return Importer.getToContext().UnsignedCharTy;
1751
1752     return Importer.getToContext().CharTy;
1753
1754   case BuiltinType::Char_S:
1755     // The context we're importing from has an unsigned 'char'. If we're
1756     // importing into a context with a signed 'char', translate to
1757     // 'unsigned char' instead.
1758     if (!Importer.getToContext().getLangOpts().CharIsSigned)
1759       return Importer.getToContext().SignedCharTy;
1760
1761     return Importer.getToContext().CharTy;
1762
1763   case BuiltinType::WChar_S:
1764   case BuiltinType::WChar_U:
1765     // FIXME: If not in C++, shall we translate to the C equivalent of
1766     // wchar_t?
1767     return Importer.getToContext().WCharTy;
1768   }
1769
1770   llvm_unreachable("Invalid BuiltinType Kind!");
1771 }
1772
1773 QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
1774   QualType OrigT = Importer.Import(T->getOriginalType());
1775   if (OrigT.isNull())
1776     return QualType();
1777
1778   return Importer.getToContext().getDecayedType(OrigT);
1779 }
1780
1781 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1782   QualType ToElementType = Importer.Import(T->getElementType());
1783   if (ToElementType.isNull())
1784     return QualType();
1785
1786   return Importer.getToContext().getComplexType(ToElementType);
1787 }
1788
1789 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1790   QualType ToPointeeType = Importer.Import(T->getPointeeType());
1791   if (ToPointeeType.isNull())
1792     return QualType();
1793
1794   return Importer.getToContext().getPointerType(ToPointeeType);
1795 }
1796
1797 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1798   // FIXME: Check for blocks support in "to" context.
1799   QualType ToPointeeType = Importer.Import(T->getPointeeType());
1800   if (ToPointeeType.isNull())
1801     return QualType();
1802
1803   return Importer.getToContext().getBlockPointerType(ToPointeeType);
1804 }
1805
1806 QualType
1807 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1808   // FIXME: Check for C++ support in "to" context.
1809   QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1810   if (ToPointeeType.isNull())
1811     return QualType();
1812
1813   return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1814 }
1815
1816 QualType
1817 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1818   // FIXME: Check for C++0x support in "to" context.
1819   QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1820   if (ToPointeeType.isNull())
1821     return QualType();
1822
1823   return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1824 }
1825
1826 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1827   // FIXME: Check for C++ support in "to" context.
1828   QualType ToPointeeType = Importer.Import(T->getPointeeType());
1829   if (ToPointeeType.isNull())
1830     return QualType();
1831
1832   QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1833   return Importer.getToContext().getMemberPointerType(ToPointeeType,
1834                                                       ClassType.getTypePtr());
1835 }
1836
1837 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1838   QualType ToElementType = Importer.Import(T->getElementType());
1839   if (ToElementType.isNull())
1840     return QualType();
1841
1842   return Importer.getToContext().getConstantArrayType(ToElementType,
1843                                                       T->getSize(),
1844                                                       T->getSizeModifier(),
1845                                                T->getIndexTypeCVRQualifiers());
1846 }
1847
1848 QualType
1849 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1850   QualType ToElementType = Importer.Import(T->getElementType());
1851   if (ToElementType.isNull())
1852     return QualType();
1853
1854   return Importer.getToContext().getIncompleteArrayType(ToElementType,
1855                                                         T->getSizeModifier(),
1856                                                 T->getIndexTypeCVRQualifiers());
1857 }
1858
1859 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1860   QualType ToElementType = Importer.Import(T->getElementType());
1861   if (ToElementType.isNull())
1862     return QualType();
1863
1864   Expr *Size = Importer.Import(T->getSizeExpr());
1865   if (!Size)
1866     return QualType();
1867
1868   SourceRange Brackets = Importer.Import(T->getBracketsRange());
1869   return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1870                                                       T->getSizeModifier(),
1871                                                 T->getIndexTypeCVRQualifiers(),
1872                                                       Brackets);
1873 }
1874
1875 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1876   QualType ToElementType = Importer.Import(T->getElementType());
1877   if (ToElementType.isNull())
1878     return QualType();
1879
1880   return Importer.getToContext().getVectorType(ToElementType,
1881                                                T->getNumElements(),
1882                                                T->getVectorKind());
1883 }
1884
1885 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1886   QualType ToElementType = Importer.Import(T->getElementType());
1887   if (ToElementType.isNull())
1888     return QualType();
1889
1890   return Importer.getToContext().getExtVectorType(ToElementType,
1891                                                   T->getNumElements());
1892 }
1893
1894 QualType
1895 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1896   // FIXME: What happens if we're importing a function without a prototype
1897   // into C++? Should we make it variadic?
1898   QualType ToResultType = Importer.Import(T->getReturnType());
1899   if (ToResultType.isNull())
1900     return QualType();
1901
1902   return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1903                                                         T->getExtInfo());
1904 }
1905
1906 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1907   QualType ToResultType = Importer.Import(T->getReturnType());
1908   if (ToResultType.isNull())
1909     return QualType();
1910
1911   // Import argument types
1912   SmallVector<QualType, 4> ArgTypes;
1913   for (const auto &A : T->param_types()) {
1914     QualType ArgType = Importer.Import(A);
1915     if (ArgType.isNull())
1916       return QualType();
1917     ArgTypes.push_back(ArgType);
1918   }
1919
1920   // Import exception types
1921   SmallVector<QualType, 4> ExceptionTypes;
1922   for (const auto &E : T->exceptions()) {
1923     QualType ExceptionType = Importer.Import(E);
1924     if (ExceptionType.isNull())
1925       return QualType();
1926     ExceptionTypes.push_back(ExceptionType);
1927   }
1928
1929   FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1930   FunctionProtoType::ExtProtoInfo ToEPI;
1931
1932   ToEPI.ExtInfo = FromEPI.ExtInfo;
1933   ToEPI.Variadic = FromEPI.Variadic;
1934   ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1935   ToEPI.TypeQuals = FromEPI.TypeQuals;
1936   ToEPI.RefQualifier = FromEPI.RefQualifier;
1937   ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
1938   ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
1939   ToEPI.ExceptionSpec.NoexceptExpr =
1940       Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
1941   ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
1942       Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
1943   ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
1944       Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
1945
1946   return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1947 }
1948
1949 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
1950   QualType ToInnerType = Importer.Import(T->getInnerType());
1951   if (ToInnerType.isNull())
1952     return QualType();
1953
1954   return Importer.getToContext().getParenType(ToInnerType);
1955 }
1956
1957 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1958   TypedefNameDecl *ToDecl
1959              = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1960   if (!ToDecl)
1961     return QualType();
1962
1963   return Importer.getToContext().getTypeDeclType(ToDecl);
1964 }
1965
1966 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1967   Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1968   if (!ToExpr)
1969     return QualType();
1970
1971   return Importer.getToContext().getTypeOfExprType(ToExpr);
1972 }
1973
1974 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1975   QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1976   if (ToUnderlyingType.isNull())
1977     return QualType();
1978
1979   return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1980 }
1981
1982 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1983   // FIXME: Make sure that the "to" context supports C++0x!
1984   Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1985   if (!ToExpr)
1986     return QualType();
1987
1988   QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1989   if (UnderlyingType.isNull())
1990     return QualType();
1991
1992   return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1993 }
1994
1995 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1996   QualType ToBaseType = Importer.Import(T->getBaseType());
1997   QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1998   if (ToBaseType.isNull() || ToUnderlyingType.isNull())
1999     return QualType();
2000
2001   return Importer.getToContext().getUnaryTransformType(ToBaseType,
2002                                                        ToUnderlyingType,
2003                                                        T->getUTTKind());
2004 }
2005
2006 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
2007   // FIXME: Make sure that the "to" context supports C++11!
2008   QualType FromDeduced = T->getDeducedType();
2009   QualType ToDeduced;
2010   if (!FromDeduced.isNull()) {
2011     ToDeduced = Importer.Import(FromDeduced);
2012     if (ToDeduced.isNull())
2013       return QualType();
2014   }
2015
2016   return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
2017                                              /*IsDependent*/false);
2018 }
2019
2020 QualType ASTNodeImporter::VisitInjectedClassNameType(
2021     const InjectedClassNameType *T) {
2022   CXXRecordDecl *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
2023   if (!D)
2024     return QualType();
2025
2026   QualType InjType = Importer.Import(T->getInjectedSpecializationType());
2027   if (InjType.isNull())
2028     return QualType();
2029
2030   // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
2031   // See comments in InjectedClassNameType definition for details
2032   // return Importer.getToContext().getInjectedClassNameType(D, InjType);
2033   enum {
2034     TypeAlignmentInBits = 4,
2035     TypeAlignment = 1 << TypeAlignmentInBits
2036   };
2037
2038   return QualType(new (Importer.getToContext(), TypeAlignment)
2039                   InjectedClassNameType(D, InjType), 0);
2040 }
2041
2042 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
2043   RecordDecl *ToDecl
2044     = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
2045   if (!ToDecl)
2046     return QualType();
2047
2048   return Importer.getToContext().getTagDeclType(ToDecl);
2049 }
2050
2051 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
2052   EnumDecl *ToDecl
2053     = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
2054   if (!ToDecl)
2055     return QualType();
2056
2057   return Importer.getToContext().getTagDeclType(ToDecl);
2058 }
2059
2060 QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
2061   QualType FromModifiedType = T->getModifiedType();
2062   QualType FromEquivalentType = T->getEquivalentType();
2063   QualType ToModifiedType;
2064   QualType ToEquivalentType;
2065
2066   if (!FromModifiedType.isNull()) {
2067     ToModifiedType = Importer.Import(FromModifiedType);
2068     if (ToModifiedType.isNull())
2069       return QualType();
2070   }
2071   if (!FromEquivalentType.isNull()) {
2072     ToEquivalentType = Importer.Import(FromEquivalentType);
2073     if (ToEquivalentType.isNull())
2074       return QualType();
2075   }
2076
2077   return Importer.getToContext().getAttributedType(T->getAttrKind(),
2078     ToModifiedType, ToEquivalentType);
2079 }
2080
2081
2082 QualType ASTNodeImporter::VisitTemplateTypeParmType(
2083     const TemplateTypeParmType *T) {
2084   TemplateTypeParmDecl *ParmDecl =
2085       cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
2086   if (!ParmDecl && T->getDecl())
2087     return QualType();
2088
2089   return Importer.getToContext().getTemplateTypeParmType(
2090         T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
2091 }
2092
2093 QualType ASTNodeImporter::VisitSubstTemplateTypeParmType(
2094     const SubstTemplateTypeParmType *T) {
2095   const TemplateTypeParmType *Replaced =
2096       cast_or_null<TemplateTypeParmType>(Importer.Import(
2097         QualType(T->getReplacedParameter(), 0)).getTypePtr());
2098   if (!Replaced)
2099     return QualType();
2100
2101   QualType Replacement = Importer.Import(T->getReplacementType());
2102   if (Replacement.isNull())
2103     return QualType();
2104   Replacement = Replacement.getCanonicalType();
2105
2106   return Importer.getToContext().getSubstTemplateTypeParmType(
2107         Replaced, Replacement);
2108 }
2109
2110 QualType ASTNodeImporter::VisitTemplateSpecializationType(
2111                                        const TemplateSpecializationType *T) {
2112   TemplateName ToTemplate = Importer.Import(T->getTemplateName());
2113   if (ToTemplate.isNull())
2114     return QualType();
2115
2116   SmallVector<TemplateArgument, 2> ToTemplateArgs;
2117   if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
2118     return QualType();
2119
2120   QualType ToCanonType;
2121   if (!QualType(T, 0).isCanonical()) {
2122     QualType FromCanonType
2123       = Importer.getFromContext().getCanonicalType(QualType(T, 0));
2124     ToCanonType =Importer.Import(FromCanonType);
2125     if (ToCanonType.isNull())
2126       return QualType();
2127   }
2128   return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
2129                                                                ToTemplateArgs,
2130                                                                ToCanonType);
2131 }
2132
2133 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
2134   NestedNameSpecifier *ToQualifier = nullptr;
2135   // Note: the qualifier in an ElaboratedType is optional.
2136   if (T->getQualifier()) {
2137     ToQualifier = Importer.Import(T->getQualifier());
2138     if (!ToQualifier)
2139       return QualType();
2140   }
2141
2142   QualType ToNamedType = Importer.Import(T->getNamedType());
2143   if (ToNamedType.isNull())
2144     return QualType();
2145
2146   return Importer.getToContext().getElaboratedType(T->getKeyword(),
2147                                                    ToQualifier, ToNamedType);
2148 }
2149
2150 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
2151   ObjCInterfaceDecl *Class
2152     = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
2153   if (!Class)
2154     return QualType();
2155
2156   return Importer.getToContext().getObjCInterfaceType(Class);
2157 }
2158
2159 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
2160   QualType ToBaseType = Importer.Import(T->getBaseType());
2161   if (ToBaseType.isNull())
2162     return QualType();
2163
2164   SmallVector<QualType, 4> TypeArgs;
2165   for (auto TypeArg : T->getTypeArgsAsWritten()) {
2166     QualType ImportedTypeArg = Importer.Import(TypeArg);
2167     if (ImportedTypeArg.isNull())
2168       return QualType();
2169
2170     TypeArgs.push_back(ImportedTypeArg);
2171   }
2172
2173   SmallVector<ObjCProtocolDecl *, 4> Protocols;
2174   for (auto *P : T->quals()) {
2175     ObjCProtocolDecl *Protocol
2176       = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
2177     if (!Protocol)
2178       return QualType();
2179     Protocols.push_back(Protocol);
2180   }
2181
2182   return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
2183                                                    Protocols,
2184                                                    T->isKindOfTypeAsWritten());
2185 }
2186
2187 QualType
2188 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
2189   QualType ToPointeeType = Importer.Import(T->getPointeeType());
2190   if (ToPointeeType.isNull())
2191     return QualType();
2192
2193   return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
2194 }
2195
2196 //----------------------------------------------------------------------------
2197 // Import Declarations
2198 //----------------------------------------------------------------------------
2199 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
2200                                       DeclContext *&LexicalDC,
2201                                       DeclarationName &Name,
2202                                       NamedDecl *&ToD,
2203                                       SourceLocation &Loc) {
2204   // Import the context of this declaration.
2205   DC = Importer.ImportContext(D->getDeclContext());
2206   if (!DC)
2207     return true;
2208
2209   LexicalDC = DC;
2210   if (D->getDeclContext() != D->getLexicalDeclContext()) {
2211     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
2212     if (!LexicalDC)
2213       return true;
2214   }
2215
2216   // Import the name of this declaration.
2217   Name = Importer.Import(D->getDeclName());
2218   if (D->getDeclName() && !Name)
2219     return true;
2220
2221   // Import the location of this declaration.
2222   Loc = Importer.Import(D->getLocation());
2223   ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
2224   return false;
2225 }
2226
2227 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
2228   if (!FromD)
2229     return;
2230
2231   if (!ToD) {
2232     ToD = Importer.Import(FromD);
2233     if (!ToD)
2234       return;
2235   }
2236
2237   if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
2238     if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
2239       if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
2240         ImportDefinition(FromRecord, ToRecord);
2241       }
2242     }
2243     return;
2244   }
2245
2246   if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
2247     if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
2248       if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
2249         ImportDefinition(FromEnum, ToEnum);
2250       }
2251     }
2252     return;
2253   }
2254 }
2255
2256 void
2257 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
2258                                           DeclarationNameInfo& To) {
2259   // NOTE: To.Name and To.Loc are already imported.
2260   // We only have to import To.LocInfo.
2261   switch (To.getName().getNameKind()) {
2262   case DeclarationName::Identifier:
2263   case DeclarationName::ObjCZeroArgSelector:
2264   case DeclarationName::ObjCOneArgSelector:
2265   case DeclarationName::ObjCMultiArgSelector:
2266   case DeclarationName::CXXUsingDirective:
2267   case DeclarationName::CXXDeductionGuideName:
2268     return;
2269
2270   case DeclarationName::CXXOperatorName: {
2271     SourceRange Range = From.getCXXOperatorNameRange();
2272     To.setCXXOperatorNameRange(Importer.Import(Range));
2273     return;
2274   }
2275   case DeclarationName::CXXLiteralOperatorName: {
2276     SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
2277     To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
2278     return;
2279   }
2280   case DeclarationName::CXXConstructorName:
2281   case DeclarationName::CXXDestructorName:
2282   case DeclarationName::CXXConversionFunctionName: {
2283     TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
2284     To.setNamedTypeInfo(Importer.Import(FromTInfo));
2285     return;
2286   }
2287   }
2288   llvm_unreachable("Unknown name kind.");
2289 }
2290
2291 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
2292   if (Importer.isMinimalImport() && !ForceImport) {
2293     Importer.ImportContext(FromDC);
2294     return;
2295   }
2296
2297   for (auto *From : FromDC->decls())
2298     Importer.Import(From);
2299 }
2300
2301 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
2302                                        ImportDefinitionKind Kind) {
2303   if (To->getDefinition() || To->isBeingDefined()) {
2304     if (Kind == IDK_Everything)
2305       ImportDeclContext(From, /*ForceImport=*/true);
2306
2307     return false;
2308   }
2309
2310   To->startDefinition();
2311
2312   // Add base classes.
2313   if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
2314     CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
2315
2316     struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2317     struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2318     ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
2319     ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
2320     ToData.Aggregate = FromData.Aggregate;
2321     ToData.PlainOldData = FromData.PlainOldData;
2322     ToData.Empty = FromData.Empty;
2323     ToData.Polymorphic = FromData.Polymorphic;
2324     ToData.Abstract = FromData.Abstract;
2325     ToData.IsStandardLayout = FromData.IsStandardLayout;
2326     ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases;
2327     ToData.HasPrivateFields = FromData.HasPrivateFields;
2328     ToData.HasProtectedFields = FromData.HasProtectedFields;
2329     ToData.HasPublicFields = FromData.HasPublicFields;
2330     ToData.HasMutableFields = FromData.HasMutableFields;
2331     ToData.HasVariantMembers = FromData.HasVariantMembers;
2332     ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
2333     ToData.HasInClassInitializer = FromData.HasInClassInitializer;
2334     ToData.HasUninitializedReferenceMember
2335       = FromData.HasUninitializedReferenceMember;
2336     ToData.HasUninitializedFields = FromData.HasUninitializedFields;
2337     ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
2338     ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
2339     ToData.NeedOverloadResolutionForMoveConstructor
2340       = FromData.NeedOverloadResolutionForMoveConstructor;
2341     ToData.NeedOverloadResolutionForMoveAssignment
2342       = FromData.NeedOverloadResolutionForMoveAssignment;
2343     ToData.NeedOverloadResolutionForDestructor
2344       = FromData.NeedOverloadResolutionForDestructor;
2345     ToData.DefaultedMoveConstructorIsDeleted
2346       = FromData.DefaultedMoveConstructorIsDeleted;
2347     ToData.DefaultedMoveAssignmentIsDeleted
2348       = FromData.DefaultedMoveAssignmentIsDeleted;
2349     ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
2350     ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
2351     ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
2352     ToData.HasConstexprNonCopyMoveConstructor
2353       = FromData.HasConstexprNonCopyMoveConstructor;
2354     ToData.HasDefaultedDefaultConstructor
2355       = FromData.HasDefaultedDefaultConstructor;
2356     ToData.DefaultedDefaultConstructorIsConstexpr
2357       = FromData.DefaultedDefaultConstructorIsConstexpr;
2358     ToData.HasConstexprDefaultConstructor
2359       = FromData.HasConstexprDefaultConstructor;
2360     ToData.HasNonLiteralTypeFieldsOrBases
2361       = FromData.HasNonLiteralTypeFieldsOrBases;
2362     // ComputedVisibleConversions not imported.
2363     ToData.UserProvidedDefaultConstructor
2364       = FromData.UserProvidedDefaultConstructor;
2365     ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
2366     ToData.ImplicitCopyConstructorCanHaveConstParamForVBase
2367       = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase;
2368     ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase
2369       = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase;
2370     ToData.ImplicitCopyAssignmentHasConstParam
2371       = FromData.ImplicitCopyAssignmentHasConstParam;
2372     ToData.HasDeclaredCopyConstructorWithConstParam
2373       = FromData.HasDeclaredCopyConstructorWithConstParam;
2374     ToData.HasDeclaredCopyAssignmentWithConstParam
2375       = FromData.HasDeclaredCopyAssignmentWithConstParam;
2376     ToData.IsLambda = FromData.IsLambda;
2377
2378     SmallVector<CXXBaseSpecifier *, 4> Bases;
2379     for (const auto &Base1 : FromCXX->bases()) {
2380       QualType T = Importer.Import(Base1.getType());
2381       if (T.isNull())
2382         return true;
2383
2384       SourceLocation EllipsisLoc;
2385       if (Base1.isPackExpansion())
2386         EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2387
2388       // Ensure that we have a definition for the base.
2389       ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
2390
2391       Bases.push_back(
2392                     new (Importer.getToContext())
2393                       CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2394                                        Base1.isVirtual(),
2395                                        Base1.isBaseOfClass(),
2396                                        Base1.getAccessSpecifierAsWritten(),
2397                                    Importer.Import(Base1.getTypeSourceInfo()),
2398                                        EllipsisLoc));
2399     }
2400     if (!Bases.empty())
2401       ToCXX->setBases(Bases.data(), Bases.size());
2402   }
2403
2404   if (shouldForceImportDeclContext(Kind))
2405     ImportDeclContext(From, /*ForceImport=*/true);
2406
2407   To->completeDefinition();
2408   return false;
2409 }
2410
2411 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
2412                                        ImportDefinitionKind Kind) {
2413   if (To->getAnyInitializer())
2414     return false;
2415
2416   // FIXME: Can we really import any initializer? Alternatively, we could force
2417   // ourselves to import every declaration of a variable and then only use
2418   // getInit() here.
2419   To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2420
2421   // FIXME: Other bits to merge?
2422
2423   return false;
2424 }
2425
2426 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
2427                                        ImportDefinitionKind Kind) {
2428   if (To->getDefinition() || To->isBeingDefined()) {
2429     if (Kind == IDK_Everything)
2430       ImportDeclContext(From, /*ForceImport=*/true);
2431     return false;
2432   }
2433
2434   To->startDefinition();
2435
2436   QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2437   if (T.isNull())
2438     return true;
2439
2440   QualType ToPromotionType = Importer.Import(From->getPromotionType());
2441   if (ToPromotionType.isNull())
2442     return true;
2443
2444   if (shouldForceImportDeclContext(Kind))
2445     ImportDeclContext(From, /*ForceImport=*/true);
2446
2447   // FIXME: we might need to merge the number of positive or negative bits
2448   // if the enumerator lists don't match.
2449   To->completeDefinition(T, ToPromotionType,
2450                          From->getNumPositiveBits(),
2451                          From->getNumNegativeBits());
2452   return false;
2453 }
2454
2455 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
2456                                                 TemplateParameterList *Params) {
2457   SmallVector<NamedDecl *, 4> ToParams(Params->size());
2458   if (ImportContainerChecked(*Params, ToParams))
2459     return nullptr;
2460
2461   Expr *ToRequiresClause;
2462   if (Expr *const R = Params->getRequiresClause()) {
2463     ToRequiresClause = Importer.Import(R);
2464     if (!ToRequiresClause)
2465       return nullptr;
2466   } else {
2467     ToRequiresClause = nullptr;
2468   }
2469
2470   return TemplateParameterList::Create(Importer.getToContext(),
2471                                        Importer.Import(Params->getTemplateLoc()),
2472                                        Importer.Import(Params->getLAngleLoc()),
2473                                        ToParams,
2474                                        Importer.Import(Params->getRAngleLoc()),
2475                                        ToRequiresClause);
2476 }
2477
2478 TemplateArgument
2479 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2480   switch (From.getKind()) {
2481   case TemplateArgument::Null:
2482     return TemplateArgument();
2483
2484   case TemplateArgument::Type: {
2485     QualType ToType = Importer.Import(From.getAsType());
2486     if (ToType.isNull())
2487       return TemplateArgument();
2488     return TemplateArgument(ToType);
2489   }
2490
2491   case TemplateArgument::Integral: {
2492     QualType ToType = Importer.Import(From.getIntegralType());
2493     if (ToType.isNull())
2494       return TemplateArgument();
2495     return TemplateArgument(From, ToType);
2496   }
2497
2498   case TemplateArgument::Declaration: {
2499     ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2500     QualType ToType = Importer.Import(From.getParamTypeForDecl());
2501     if (!To || ToType.isNull())
2502       return TemplateArgument();
2503     return TemplateArgument(To, ToType);
2504   }
2505
2506   case TemplateArgument::NullPtr: {
2507     QualType ToType = Importer.Import(From.getNullPtrType());
2508     if (ToType.isNull())
2509       return TemplateArgument();
2510     return TemplateArgument(ToType, /*isNullPtr*/true);
2511   }
2512
2513   case TemplateArgument::Template: {
2514     TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2515     if (ToTemplate.isNull())
2516       return TemplateArgument();
2517
2518     return TemplateArgument(ToTemplate);
2519   }
2520
2521   case TemplateArgument::TemplateExpansion: {
2522     TemplateName ToTemplate
2523       = Importer.Import(From.getAsTemplateOrTemplatePattern());
2524     if (ToTemplate.isNull())
2525       return TemplateArgument();
2526
2527     return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
2528   }
2529
2530   case TemplateArgument::Expression:
2531     if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2532       return TemplateArgument(ToExpr);
2533     return TemplateArgument();
2534
2535   case TemplateArgument::Pack: {
2536     SmallVector<TemplateArgument, 2> ToPack;
2537     ToPack.reserve(From.pack_size());
2538     if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
2539       return TemplateArgument();
2540
2541     return TemplateArgument(
2542         llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
2543   }
2544   }
2545
2546   llvm_unreachable("Invalid template argument kind");
2547 }
2548
2549 TemplateArgumentLoc ASTNodeImporter::ImportTemplateArgumentLoc(
2550     const TemplateArgumentLoc &TALoc, bool &Error) {
2551   Error = false;
2552   TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument());
2553   TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
2554   TemplateArgumentLocInfo ToInfo;
2555   if (Arg.getKind() == TemplateArgument::Expression) {
2556     Expr *E = Importer.Import(FromInfo.getAsExpr());
2557     ToInfo = TemplateArgumentLocInfo(E);
2558     if (!E)
2559       Error = true;
2560   } else if (Arg.getKind() == TemplateArgument::Type) {
2561     if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo()))
2562       ToInfo = TemplateArgumentLocInfo(TSI);
2563     else
2564       Error = true;
2565   } else {
2566     ToInfo = TemplateArgumentLocInfo(
2567           Importer.Import(FromInfo.getTemplateQualifierLoc()),
2568           Importer.Import(FromInfo.getTemplateNameLoc()),
2569           Importer.Import(FromInfo.getTemplateEllipsisLoc()));
2570   }
2571   return TemplateArgumentLoc(Arg, ToInfo);
2572 }
2573
2574 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
2575                                               unsigned NumFromArgs,
2576                               SmallVectorImpl<TemplateArgument> &ToArgs) {
2577   for (unsigned I = 0; I != NumFromArgs; ++I) {
2578     TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
2579     if (To.isNull() && !FromArgs[I].isNull())
2580       return true;
2581
2582     ToArgs.push_back(To);
2583   }
2584
2585   return false;
2586 }
2587
2588 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2589                                         RecordDecl *ToRecord, bool Complain) {
2590   // Eliminate a potential failure point where we attempt to re-import
2591   // something we're trying to import while completing ToRecord.
2592   Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2593   if (ToOrigin) {
2594     RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2595     if (ToOriginRecord)
2596       ToRecord = ToOriginRecord;
2597   }
2598
2599   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2600                                    ToRecord->getASTContext(),
2601                                    Importer.getNonEquivalentDecls(),
2602                                    false, Complain);
2603   return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
2604 }
2605
2606 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2607                                         bool Complain) {
2608   StructuralEquivalenceContext Ctx(
2609       Importer.getFromContext(), Importer.getToContext(),
2610       Importer.getNonEquivalentDecls(), false, Complain);
2611   return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
2612 }
2613
2614 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2615   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2616                                    Importer.getToContext(),
2617                                    Importer.getNonEquivalentDecls());
2618   return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
2619 }
2620
2621 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2622                                         EnumConstantDecl *ToEC)
2623 {
2624   const llvm::APSInt &FromVal = FromEC->getInitVal();
2625   const llvm::APSInt &ToVal = ToEC->getInitVal();
2626
2627   return FromVal.isSigned() == ToVal.isSigned() &&
2628          FromVal.getBitWidth() == ToVal.getBitWidth() &&
2629          FromVal == ToVal;
2630 }
2631
2632 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2633                                         ClassTemplateDecl *To) {
2634   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2635                                    Importer.getToContext(),
2636                                    Importer.getNonEquivalentDecls());
2637   return Ctx.IsStructurallyEquivalent(From, To);
2638 }
2639
2640 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2641                                         VarTemplateDecl *To) {
2642   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2643                                    Importer.getToContext(),
2644                                    Importer.getNonEquivalentDecls());
2645   return Ctx.IsStructurallyEquivalent(From, To);
2646 }
2647
2648 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
2649   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2650     << D->getDeclKindName();
2651   return nullptr;
2652 }
2653
2654 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2655   TranslationUnitDecl *ToD =
2656     Importer.getToContext().getTranslationUnitDecl();
2657
2658   Importer.Imported(D, ToD);
2659
2660   return ToD;
2661 }
2662
2663 Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
2664
2665   SourceLocation Loc = Importer.Import(D->getLocation());
2666   SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
2667
2668   // Import the context of this declaration.
2669   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2670   if (!DC)
2671     return nullptr;
2672
2673   AccessSpecDecl *accessSpecDecl
2674     = AccessSpecDecl::Create(Importer.getToContext(), D->getAccess(),
2675                              DC, Loc, ColonLoc);
2676
2677   if (!accessSpecDecl)
2678     return nullptr;
2679
2680   // Lexical DeclContext and Semantic DeclContext
2681   // is always the same for the accessSpec.
2682   accessSpecDecl->setLexicalDeclContext(DC);
2683   DC->addDeclInternal(accessSpecDecl);
2684
2685   return accessSpecDecl;
2686 }
2687
2688 Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2689   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2690   if (!DC)
2691     return nullptr;
2692
2693   DeclContext *LexicalDC = DC;
2694
2695   // Import the location of this declaration.
2696   SourceLocation Loc = Importer.Import(D->getLocation());
2697
2698   Expr *AssertExpr = Importer.Import(D->getAssertExpr());
2699   if (!AssertExpr)
2700     return nullptr;
2701
2702   StringLiteral *FromMsg = D->getMessage();
2703   StringLiteral *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
2704   if (!ToMsg && FromMsg)
2705     return nullptr;
2706
2707   StaticAssertDecl *ToD = StaticAssertDecl::Create(
2708         Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
2709         Importer.Import(D->getRParenLoc()), D->isFailed());
2710
2711   ToD->setLexicalDeclContext(LexicalDC);
2712   LexicalDC->addDeclInternal(ToD);
2713   Importer.Imported(D, ToD);
2714   return ToD;
2715 }
2716
2717 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2718   // Import the major distinguishing characteristics of this namespace.
2719   DeclContext *DC, *LexicalDC;
2720   DeclarationName Name;
2721   SourceLocation Loc;
2722   NamedDecl *ToD;
2723   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2724     return nullptr;
2725   if (ToD)
2726     return ToD;
2727
2728   NamespaceDecl *MergeWithNamespace = nullptr;
2729   if (!Name) {
2730     // This is an anonymous namespace. Adopt an existing anonymous
2731     // namespace if we can.
2732     // FIXME: Not testable.
2733     if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2734       MergeWithNamespace = TU->getAnonymousNamespace();
2735     else
2736       MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2737   } else {
2738     SmallVector<NamedDecl *, 4> ConflictingDecls;
2739     SmallVector<NamedDecl *, 2> FoundDecls;
2740     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2741     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2742       if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
2743         continue;
2744
2745       if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
2746         MergeWithNamespace = FoundNS;
2747         ConflictingDecls.clear();
2748         break;
2749       }
2750
2751       ConflictingDecls.push_back(FoundDecls[I]);
2752     }
2753
2754     if (!ConflictingDecls.empty()) {
2755       Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2756                                          ConflictingDecls.data(),
2757                                          ConflictingDecls.size());
2758     }
2759   }
2760
2761   // Create the "to" namespace, if needed.
2762   NamespaceDecl *ToNamespace = MergeWithNamespace;
2763   if (!ToNamespace) {
2764     ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2765                                         D->isInline(),
2766                                         Importer.Import(D->getLocStart()),
2767                                         Loc, Name.getAsIdentifierInfo(),
2768                                         /*PrevDecl=*/nullptr);
2769     ToNamespace->setLexicalDeclContext(LexicalDC);
2770     LexicalDC->addDeclInternal(ToNamespace);
2771
2772     // If this is an anonymous namespace, register it as the anonymous
2773     // namespace within its context.
2774     if (!Name) {
2775       if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2776         TU->setAnonymousNamespace(ToNamespace);
2777       else
2778         cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2779     }
2780   }
2781   Importer.Imported(D, ToNamespace);
2782
2783   ImportDeclContext(D);
2784
2785   return ToNamespace;
2786 }
2787
2788 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2789   // Import the major distinguishing characteristics of this typedef.
2790   DeclContext *DC, *LexicalDC;
2791   DeclarationName Name;
2792   SourceLocation Loc;
2793   NamedDecl *ToD;
2794   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2795     return nullptr;
2796   if (ToD)
2797     return ToD;
2798
2799   // If this typedef is not in block scope, determine whether we've
2800   // seen a typedef with the same name (that we can merge with) or any
2801   // other entity by that name (which name lookup could conflict with).
2802   if (!DC->isFunctionOrMethod()) {
2803     SmallVector<NamedDecl *, 4> ConflictingDecls;
2804     unsigned IDNS = Decl::IDNS_Ordinary;
2805     SmallVector<NamedDecl *, 2> FoundDecls;
2806     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2807     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2808       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2809         continue;
2810       if (TypedefNameDecl *FoundTypedef =
2811             dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
2812         if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2813                                             FoundTypedef->getUnderlyingType()))
2814           return Importer.Imported(D, FoundTypedef);
2815       }
2816
2817       ConflictingDecls.push_back(FoundDecls[I]);
2818     }
2819
2820     if (!ConflictingDecls.empty()) {
2821       Name = Importer.HandleNameConflict(Name, DC, IDNS,
2822                                          ConflictingDecls.data(),
2823                                          ConflictingDecls.size());
2824       if (!Name)
2825         return nullptr;
2826     }
2827   }
2828
2829   // Import the underlying type of this typedef;
2830   QualType T = Importer.Import(D->getUnderlyingType());
2831   if (T.isNull())
2832     return nullptr;
2833
2834   // Create the new typedef node.
2835   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2836   SourceLocation StartL = Importer.Import(D->getLocStart());
2837   TypedefNameDecl *ToTypedef;
2838   if (IsAlias)
2839     ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2840                                       StartL, Loc,
2841                                       Name.getAsIdentifierInfo(),
2842                                       TInfo);
2843   else
2844     ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2845                                     StartL, Loc,
2846                                     Name.getAsIdentifierInfo(),
2847                                     TInfo);
2848
2849   ToTypedef->setAccess(D->getAccess());
2850   ToTypedef->setLexicalDeclContext(LexicalDC);
2851   Importer.Imported(D, ToTypedef);
2852   LexicalDC->addDeclInternal(ToTypedef);
2853
2854   return ToTypedef;
2855 }
2856
2857 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2858   return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2859 }
2860
2861 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2862   return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2863 }
2864
2865 Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2866   // Import the major distinguishing characteristics of this label.
2867   DeclContext *DC, *LexicalDC;
2868   DeclarationName Name;
2869   SourceLocation Loc;
2870   NamedDecl *ToD;
2871   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2872     return nullptr;
2873   if (ToD)
2874     return ToD;
2875
2876   assert(LexicalDC->isFunctionOrMethod());
2877
2878   LabelDecl *ToLabel = D->isGnuLocal()
2879       ? LabelDecl::Create(Importer.getToContext(),
2880                           DC, Importer.Import(D->getLocation()),
2881                           Name.getAsIdentifierInfo(),
2882                           Importer.Import(D->getLocStart()))
2883       : LabelDecl::Create(Importer.getToContext(),
2884                           DC, Importer.Import(D->getLocation()),
2885                           Name.getAsIdentifierInfo());
2886   Importer.Imported(D, ToLabel);
2887
2888   LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
2889   if (!Label)
2890     return nullptr;
2891
2892   ToLabel->setStmt(Label);
2893   ToLabel->setLexicalDeclContext(LexicalDC);
2894   LexicalDC->addDeclInternal(ToLabel);
2895   return ToLabel;
2896 }
2897
2898 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2899   // Import the major distinguishing characteristics of this enum.
2900   DeclContext *DC, *LexicalDC;
2901   DeclarationName Name;
2902   SourceLocation Loc;
2903   NamedDecl *ToD;
2904   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2905     return nullptr;
2906   if (ToD)
2907     return ToD;
2908
2909   // Figure out what enum name we're looking for.
2910   unsigned IDNS = Decl::IDNS_Tag;
2911   DeclarationName SearchName = Name;
2912   if (!SearchName && D->getTypedefNameForAnonDecl()) {
2913     SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2914     IDNS = Decl::IDNS_Ordinary;
2915   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2916     IDNS |= Decl::IDNS_Ordinary;
2917
2918   // We may already have an enum of the same name; try to find and match it.
2919   if (!DC->isFunctionOrMethod() && SearchName) {
2920     SmallVector<NamedDecl *, 4> ConflictingDecls;
2921     SmallVector<NamedDecl *, 2> FoundDecls;
2922     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2923     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2924       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2925         continue;
2926
2927       Decl *Found = FoundDecls[I];
2928       if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2929         if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2930           Found = Tag->getDecl();
2931       }
2932
2933       if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2934         if (IsStructuralMatch(D, FoundEnum))
2935           return Importer.Imported(D, FoundEnum);
2936       }
2937
2938       ConflictingDecls.push_back(FoundDecls[I]);
2939     }
2940
2941     if (!ConflictingDecls.empty()) {
2942       Name = Importer.HandleNameConflict(Name, DC, IDNS,
2943                                          ConflictingDecls.data(),
2944                                          ConflictingDecls.size());
2945     }
2946   }
2947
2948   // Create the enum declaration.
2949   EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2950                                   Importer.Import(D->getLocStart()),
2951                                   Loc, Name.getAsIdentifierInfo(), nullptr,
2952                                   D->isScoped(), D->isScopedUsingClassTag(),
2953                                   D->isFixed());
2954   // Import the qualifier, if any.
2955   D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2956   D2->setAccess(D->getAccess());
2957   D2->setLexicalDeclContext(LexicalDC);
2958   Importer.Imported(D, D2);
2959   LexicalDC->addDeclInternal(D2);
2960
2961   // Import the integer type.
2962   QualType ToIntegerType = Importer.Import(D->getIntegerType());
2963   if (ToIntegerType.isNull())
2964     return nullptr;
2965   D2->setIntegerType(ToIntegerType);
2966
2967   // Import the definition
2968   if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2969     return nullptr;
2970
2971   return D2;
2972 }
2973
2974 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2975   // If this record has a definition in the translation unit we're coming from,
2976   // but this particular declaration is not that definition, import the
2977   // definition and map to that.
2978   TagDecl *Definition = D->getDefinition();
2979   if (Definition && Definition != D) {
2980     Decl *ImportedDef = Importer.Import(Definition);
2981     if (!ImportedDef)
2982       return nullptr;
2983
2984     return Importer.Imported(D, ImportedDef);
2985   }
2986
2987   // Import the major distinguishing characteristics of this record.
2988   DeclContext *DC, *LexicalDC;
2989   DeclarationName Name;
2990   SourceLocation Loc;
2991   NamedDecl *ToD;
2992   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2993     return nullptr;
2994   if (ToD)
2995     return ToD;
2996
2997   // Figure out what structure name we're looking for.
2998   unsigned IDNS = Decl::IDNS_Tag;
2999   DeclarationName SearchName = Name;
3000   if (!SearchName && D->getTypedefNameForAnonDecl()) {
3001     SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
3002     IDNS = Decl::IDNS_Ordinary;
3003   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
3004     IDNS |= Decl::IDNS_Ordinary;
3005
3006   // We may already have a record of the same name; try to find and match it.
3007   RecordDecl *AdoptDecl = nullptr;
3008   if (!DC->isFunctionOrMethod()) {
3009     SmallVector<NamedDecl *, 4> ConflictingDecls;
3010     SmallVector<NamedDecl *, 2> FoundDecls;
3011     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3012     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3013       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3014         continue;
3015
3016       Decl *Found = FoundDecls[I];
3017       if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
3018         if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
3019           Found = Tag->getDecl();
3020       }
3021
3022       if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
3023         if (D->isAnonymousStructOrUnion() &&
3024             FoundRecord->isAnonymousStructOrUnion()) {
3025           // If both anonymous structs/unions are in a record context, make sure
3026           // they occur in the same location in the context records.
3027           if (Optional<unsigned> Index1
3028               = findUntaggedStructOrUnionIndex(D)) {
3029             if (Optional<unsigned> Index2 =
3030                     findUntaggedStructOrUnionIndex(FoundRecord)) {
3031               if (*Index1 != *Index2)
3032                 continue;
3033             }
3034           }
3035         }
3036
3037         if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
3038           if ((SearchName && !D->isCompleteDefinition())
3039               || (D->isCompleteDefinition() &&
3040                   D->isAnonymousStructOrUnion()
3041                     == FoundDef->isAnonymousStructOrUnion() &&
3042                   IsStructuralMatch(D, FoundDef))) {
3043             // The record types structurally match, or the "from" translation
3044             // unit only had a forward declaration anyway; call it the same
3045             // function.
3046             // FIXME: For C++, we should also merge methods here.
3047             return Importer.Imported(D, FoundDef);
3048           }
3049         } else if (!D->isCompleteDefinition()) {
3050           // We have a forward declaration of this type, so adopt that forward
3051           // declaration rather than building a new one.
3052
3053           // If one or both can be completed from external storage then try one
3054           // last time to complete and compare them before doing this.
3055
3056           if (FoundRecord->hasExternalLexicalStorage() &&
3057               !FoundRecord->isCompleteDefinition())
3058             FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
3059           if (D->hasExternalLexicalStorage())
3060             D->getASTContext().getExternalSource()->CompleteType(D);
3061
3062           if (FoundRecord->isCompleteDefinition() &&
3063               D->isCompleteDefinition() &&
3064               !IsStructuralMatch(D, FoundRecord))
3065             continue;
3066
3067           AdoptDecl = FoundRecord;
3068           continue;
3069         } else if (!SearchName) {
3070           continue;
3071         }
3072       }
3073
3074       ConflictingDecls.push_back(FoundDecls[I]);
3075     }
3076
3077     if (!ConflictingDecls.empty() && SearchName) {
3078       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3079                                          ConflictingDecls.data(),
3080                                          ConflictingDecls.size());
3081     }
3082   }
3083
3084   // Create the record declaration.
3085   RecordDecl *D2 = AdoptDecl;
3086   SourceLocation StartLoc = Importer.Import(D->getLocStart());
3087   if (!D2) {
3088     CXXRecordDecl *D2CXX = nullptr;
3089     if (CXXRecordDecl *DCXX = llvm::dyn_cast<CXXRecordDecl>(D)) {
3090       if (DCXX->isLambda()) {
3091         TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
3092         D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(),
3093                                             DC, TInfo, Loc,
3094                                             DCXX->isDependentLambda(),
3095                                             DCXX->isGenericLambda(),
3096                                             DCXX->getLambdaCaptureDefault());
3097         Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
3098         if (DCXX->getLambdaContextDecl() && !CDecl)
3099           return nullptr;
3100         D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
3101       } else if (DCXX->isInjectedClassName()) {
3102         // We have to be careful to do a similar dance to the one in
3103         // Sema::ActOnStartCXXMemberDeclarations
3104         CXXRecordDecl *const PrevDecl = nullptr;
3105         const bool DelayTypeCreation = true;
3106         D2CXX = CXXRecordDecl::Create(
3107             Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc,
3108             Name.getAsIdentifierInfo(), PrevDecl, DelayTypeCreation);
3109         Importer.getToContext().getTypeDeclType(
3110             D2CXX, llvm::dyn_cast<CXXRecordDecl>(DC));
3111       } else {
3112         D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
3113                                       D->getTagKind(),
3114                                       DC, StartLoc, Loc,
3115                                       Name.getAsIdentifierInfo());
3116       }
3117       D2 = D2CXX;
3118       D2->setAccess(D->getAccess());
3119     } else {
3120       D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
3121                               DC, StartLoc, Loc, Name.getAsIdentifierInfo());
3122     }
3123
3124     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3125     D2->setLexicalDeclContext(LexicalDC);
3126     LexicalDC->addDeclInternal(D2);
3127     if (D->isAnonymousStructOrUnion())
3128       D2->setAnonymousStructOrUnion(true);
3129   }
3130
3131   Importer.Imported(D, D2);
3132
3133   if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
3134     return nullptr;
3135
3136   return D2;
3137 }
3138
3139 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
3140   // Import the major distinguishing characteristics of this enumerator.
3141   DeclContext *DC, *LexicalDC;
3142   DeclarationName Name;
3143   SourceLocation Loc;
3144   NamedDecl *ToD;
3145   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3146     return nullptr;
3147   if (ToD)
3148     return ToD;
3149
3150   QualType T = Importer.Import(D->getType());
3151   if (T.isNull())
3152     return nullptr;
3153
3154   // Determine whether there are any other declarations with the same name and
3155   // in the same context.
3156   if (!LexicalDC->isFunctionOrMethod()) {
3157     SmallVector<NamedDecl *, 4> ConflictingDecls;
3158     unsigned IDNS = Decl::IDNS_Ordinary;
3159     SmallVector<NamedDecl *, 2> FoundDecls;
3160     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3161     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3162       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3163         continue;
3164
3165       if (EnumConstantDecl *FoundEnumConstant
3166             = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
3167         if (IsStructuralMatch(D, FoundEnumConstant))
3168           return Importer.Imported(D, FoundEnumConstant);
3169       }
3170
3171       ConflictingDecls.push_back(FoundDecls[I]);
3172     }
3173
3174     if (!ConflictingDecls.empty()) {
3175       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3176                                          ConflictingDecls.data(),
3177                                          ConflictingDecls.size());
3178       if (!Name)
3179         return nullptr;
3180     }
3181   }
3182
3183   Expr *Init = Importer.Import(D->getInitExpr());
3184   if (D->getInitExpr() && !Init)
3185     return nullptr;
3186
3187   EnumConstantDecl *ToEnumerator
3188     = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
3189                                Name.getAsIdentifierInfo(), T,
3190                                Init, D->getInitVal());
3191   ToEnumerator->setAccess(D->getAccess());
3192   ToEnumerator->setLexicalDeclContext(LexicalDC);
3193   Importer.Imported(D, ToEnumerator);
3194   LexicalDC->addDeclInternal(ToEnumerator);
3195   return ToEnumerator;
3196 }
3197
3198 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
3199   // Import the major distinguishing characteristics of this function.
3200   DeclContext *DC, *LexicalDC;
3201   DeclarationName Name;
3202   SourceLocation Loc;
3203   NamedDecl *ToD;
3204   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3205     return nullptr;
3206   if (ToD)
3207     return ToD;
3208
3209   // Try to find a function in our own ("to") context with the same name, same
3210   // type, and in the same context as the function we're importing.
3211   if (!LexicalDC->isFunctionOrMethod()) {
3212     SmallVector<NamedDecl *, 4> ConflictingDecls;
3213     unsigned IDNS = Decl::IDNS_Ordinary;
3214     SmallVector<NamedDecl *, 2> FoundDecls;
3215     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3216     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3217       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3218         continue;
3219
3220       if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
3221         if (FoundFunction->hasExternalFormalLinkage() &&
3222             D->hasExternalFormalLinkage()) {
3223           if (Importer.IsStructurallyEquivalent(D->getType(),
3224                                                 FoundFunction->getType())) {
3225             // FIXME: Actually try to merge the body and other attributes.
3226             return Importer.Imported(D, FoundFunction);
3227           }
3228
3229           // FIXME: Check for overloading more carefully, e.g., by boosting
3230           // Sema::IsOverload out to the AST library.
3231
3232           // Function overloading is okay in C++.
3233           if (Importer.getToContext().getLangOpts().CPlusPlus)
3234             continue;
3235
3236           // Complain about inconsistent function types.
3237           Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
3238             << Name << D->getType() << FoundFunction->getType();
3239           Importer.ToDiag(FoundFunction->getLocation(),
3240                           diag::note_odr_value_here)
3241             << FoundFunction->getType();
3242         }
3243       }
3244
3245       ConflictingDecls.push_back(FoundDecls[I]);
3246     }
3247
3248     if (!ConflictingDecls.empty()) {
3249       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3250                                          ConflictingDecls.data(),
3251                                          ConflictingDecls.size());
3252       if (!Name)
3253         return nullptr;
3254     }
3255   }
3256
3257   DeclarationNameInfo NameInfo(Name, Loc);
3258   // Import additional name location/type info.
3259   ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3260
3261   QualType FromTy = D->getType();
3262   bool usedDifferentExceptionSpec = false;
3263
3264   if (const FunctionProtoType *
3265         FromFPT = D->getType()->getAs<FunctionProtoType>()) {
3266     FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
3267     // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
3268     // FunctionDecl that we are importing the FunctionProtoType for.
3269     // To avoid an infinite recursion when importing, create the FunctionDecl
3270     // with a simplified function type and update it afterwards.
3271     if (FromEPI.ExceptionSpec.SourceDecl ||
3272         FromEPI.ExceptionSpec.SourceTemplate ||
3273         FromEPI.ExceptionSpec.NoexceptExpr) {
3274       FunctionProtoType::ExtProtoInfo DefaultEPI;
3275       FromTy = Importer.getFromContext().getFunctionType(
3276           FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
3277       usedDifferentExceptionSpec = true;
3278     }
3279   }
3280
3281   // Import the type.
3282   QualType T = Importer.Import(FromTy);
3283   if (T.isNull())
3284     return nullptr;
3285
3286   // Import the function parameters.
3287   SmallVector<ParmVarDecl *, 8> Parameters;
3288   for (auto P : D->parameters()) {
3289     ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
3290     if (!ToP)
3291       return nullptr;
3292
3293     Parameters.push_back(ToP);
3294   }
3295
3296   // Create the imported function.
3297   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3298   FunctionDecl *ToFunction = nullptr;
3299   SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
3300   if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3301     ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
3302                                             cast<CXXRecordDecl>(DC),
3303                                             InnerLocStart,
3304                                             NameInfo, T, TInfo,
3305                                             FromConstructor->isExplicit(),
3306                                             D->isInlineSpecified(),
3307                                             D->isImplicit(),
3308                                             D->isConstexpr());
3309     if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3310       SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
3311       for (CXXCtorInitializer *I : FromConstructor->inits()) {
3312         CXXCtorInitializer *ToI =
3313             cast_or_null<CXXCtorInitializer>(Importer.Import(I));
3314         if (!ToI && I)
3315           return nullptr;
3316         CtorInitializers.push_back(ToI);
3317       }
3318       CXXCtorInitializer **Memory =
3319           new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
3320       std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3321       CXXConstructorDecl *ToCtor = llvm::cast<CXXConstructorDecl>(ToFunction);
3322       ToCtor->setCtorInitializers(Memory);
3323       ToCtor->setNumCtorInitializers(NumInitializers);
3324     }
3325   } else if (isa<CXXDestructorDecl>(D)) {
3326     ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
3327                                            cast<CXXRecordDecl>(DC),
3328                                            InnerLocStart,
3329                                            NameInfo, T, TInfo,
3330                                            D->isInlineSpecified(),
3331                                            D->isImplicit());
3332   } else if (CXXConversionDecl *FromConversion
3333                                            = dyn_cast<CXXConversionDecl>(D)) {
3334     ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
3335                                            cast<CXXRecordDecl>(DC),
3336                                            InnerLocStart,
3337                                            NameInfo, T, TInfo,
3338                                            D->isInlineSpecified(),
3339                                            FromConversion->isExplicit(),
3340                                            D->isConstexpr(),
3341                                            Importer.Import(D->getLocEnd()));
3342   } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
3343     ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
3344                                        cast<CXXRecordDecl>(DC),
3345                                        InnerLocStart,
3346                                        NameInfo, T, TInfo,
3347                                        Method->getStorageClass(),
3348                                        Method->isInlineSpecified(),
3349                                        D->isConstexpr(),
3350                                        Importer.Import(D->getLocEnd()));
3351   } else {
3352     ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
3353                                       InnerLocStart,
3354                                       NameInfo, T, TInfo, D->getStorageClass(),
3355                                       D->isInlineSpecified(),
3356                                       D->hasWrittenPrototype(),
3357                                       D->isConstexpr());
3358   }
3359
3360   // Import the qualifier, if any.
3361   ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3362   ToFunction->setAccess(D->getAccess());
3363   ToFunction->setLexicalDeclContext(LexicalDC);
3364   ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
3365   ToFunction->setTrivial(D->isTrivial());
3366   ToFunction->setPure(D->isPure());
3367   Importer.Imported(D, ToFunction);
3368
3369   // Set the parameters.
3370   for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
3371     Parameters[I]->setOwningFunction(ToFunction);
3372     ToFunction->addDeclInternal(Parameters[I]);
3373   }
3374   ToFunction->setParams(Parameters);
3375
3376   if (usedDifferentExceptionSpec) {
3377     // Update FunctionProtoType::ExtProtoInfo.
3378     QualType T = Importer.Import(D->getType());
3379     if (T.isNull())
3380       return nullptr;
3381     ToFunction->setType(T);
3382   }
3383
3384   // Import the body, if any.
3385   if (Stmt *FromBody = D->getBody()) {
3386     if (Stmt *ToBody = Importer.Import(FromBody)) {
3387       ToFunction->setBody(ToBody);
3388     }
3389   }
3390
3391   // FIXME: Other bits to merge?
3392
3393   // Add this function to the lexical context.
3394   LexicalDC->addDeclInternal(ToFunction);
3395
3396   return ToFunction;
3397 }
3398
3399 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
3400   return VisitFunctionDecl(D);
3401 }
3402
3403 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
3404   return VisitCXXMethodDecl(D);
3405 }
3406
3407 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
3408   return VisitCXXMethodDecl(D);
3409 }
3410
3411 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
3412   return VisitCXXMethodDecl(D);
3413 }
3414
3415 static unsigned getFieldIndex(Decl *F) {
3416   RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
3417   if (!Owner)
3418     return 0;
3419
3420   unsigned Index = 1;
3421   for (const auto *D : Owner->noload_decls()) {
3422     if (D == F)
3423       return Index;
3424
3425     if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
3426       ++Index;
3427   }
3428
3429   return Index;
3430 }
3431
3432 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
3433   // Import the major distinguishing characteristics of a variable.
3434   DeclContext *DC, *LexicalDC;
3435   DeclarationName Name;
3436   SourceLocation Loc;
3437   NamedDecl *ToD;
3438   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3439     return nullptr;
3440   if (ToD)
3441     return ToD;
3442
3443   // Determine whether we've already imported this field.
3444   SmallVector<NamedDecl *, 2> FoundDecls;
3445   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3446   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3447     if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
3448       // For anonymous fields, match up by index.
3449       if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3450         continue;
3451
3452       if (Importer.IsStructurallyEquivalent(D->getType(),
3453                                             FoundField->getType())) {
3454         Importer.Imported(D, FoundField);
3455         return FoundField;
3456       }
3457
3458       Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3459         << Name << D->getType() << FoundField->getType();
3460       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3461         << FoundField->getType();
3462       return nullptr;
3463     }
3464   }
3465
3466   // Import the type.
3467   QualType T = Importer.Import(D->getType());
3468   if (T.isNull())
3469     return nullptr;
3470
3471   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3472   Expr *BitWidth = Importer.Import(D->getBitWidth());
3473   if (!BitWidth && D->getBitWidth())
3474     return nullptr;
3475
3476   FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
3477                                          Importer.Import(D->getInnerLocStart()),
3478                                          Loc, Name.getAsIdentifierInfo(),
3479                                          T, TInfo, BitWidth, D->isMutable(),
3480                                          D->getInClassInitStyle());
3481   ToField->setAccess(D->getAccess());
3482   ToField->setLexicalDeclContext(LexicalDC);
3483   if (Expr *FromInitializer = D->getInClassInitializer()) {
3484     Expr *ToInitializer = Importer.Import(FromInitializer);
3485     if (ToInitializer)
3486       ToField->setInClassInitializer(ToInitializer);
3487     else
3488       return nullptr;
3489   }
3490   ToField->setImplicit(D->isImplicit());
3491   Importer.Imported(D, ToField);
3492   LexicalDC->addDeclInternal(ToField);
3493   return ToField;
3494 }
3495
3496 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
3497   // Import the major distinguishing characteristics of a variable.
3498   DeclContext *DC, *LexicalDC;
3499   DeclarationName Name;
3500   SourceLocation Loc;
3501   NamedDecl *ToD;
3502   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3503     return nullptr;
3504   if (ToD)
3505     return ToD;
3506
3507   // Determine whether we've already imported this field.
3508   SmallVector<NamedDecl *, 2> FoundDecls;
3509   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3510   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3511     if (IndirectFieldDecl *FoundField
3512                                 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3513       // For anonymous indirect fields, match up by index.
3514       if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3515         continue;
3516
3517       if (Importer.IsStructurallyEquivalent(D->getType(),
3518                                             FoundField->getType(),
3519                                             !Name.isEmpty())) {
3520         Importer.Imported(D, FoundField);
3521         return FoundField;
3522       }
3523
3524       // If there are more anonymous fields to check, continue.
3525       if (!Name && I < N-1)
3526         continue;
3527
3528       Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3529         << Name << D->getType() << FoundField->getType();
3530       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3531         << FoundField->getType();
3532       return nullptr;
3533     }
3534   }
3535
3536   // Import the type.
3537   QualType T = Importer.Import(D->getType());
3538   if (T.isNull())
3539     return nullptr;
3540
3541   NamedDecl **NamedChain =
3542     new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
3543
3544   unsigned i = 0;
3545   for (auto *PI : D->chain()) {
3546     Decl *D = Importer.Import(PI);
3547     if (!D)
3548       return nullptr;
3549     NamedChain[i++] = cast<NamedDecl>(D);
3550   }
3551
3552   IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
3553       Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
3554       {NamedChain, D->getChainingSize()});
3555
3556   for (const auto *Attr : D->attrs())
3557     ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
3558
3559   ToIndirectField->setAccess(D->getAccess());
3560   ToIndirectField->setLexicalDeclContext(LexicalDC);
3561   Importer.Imported(D, ToIndirectField);
3562   LexicalDC->addDeclInternal(ToIndirectField);
3563   return ToIndirectField;
3564 }
3565
3566 Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
3567   // Import the major distinguishing characteristics of a declaration.
3568   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3569   DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
3570       ? DC : Importer.ImportContext(D->getLexicalDeclContext());
3571   if (!DC || !LexicalDC)
3572     return nullptr;
3573
3574   // Determine whether we've already imported this decl.
3575   // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
3576   auto *RD = cast<CXXRecordDecl>(DC);
3577   FriendDecl *ImportedFriend = RD->getFirstFriend();
3578   StructuralEquivalenceContext Context(
3579       Importer.getFromContext(), Importer.getToContext(),
3580       Importer.getNonEquivalentDecls(), false, false);
3581
3582   while (ImportedFriend) {
3583     if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
3584       if (Context.IsStructurallyEquivalent(D->getFriendDecl(),
3585                                            ImportedFriend->getFriendDecl()))
3586         return Importer.Imported(D, ImportedFriend);
3587
3588     } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
3589       if (Importer.IsStructurallyEquivalent(
3590             D->getFriendType()->getType(),
3591             ImportedFriend->getFriendType()->getType(), true))
3592         return Importer.Imported(D, ImportedFriend);
3593     }
3594     ImportedFriend = ImportedFriend->getNextFriend();
3595   }
3596
3597   // Not found. Create it.
3598   FriendDecl::FriendUnion ToFU;
3599   if (NamedDecl *FriendD = D->getFriendDecl())
3600     ToFU = cast_or_null<NamedDecl>(Importer.Import(FriendD));
3601   else
3602     ToFU = Importer.Import(D->getFriendType());
3603   if (!ToFU)
3604     return nullptr;
3605
3606   SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
3607   TemplateParameterList **FromTPLists =
3608       D->getTrailingObjects<TemplateParameterList *>();
3609   for (unsigned I = 0; I < D->NumTPLists; I++) {
3610     TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
3611     if (!List)
3612       return nullptr;
3613     ToTPLists[I] = List;
3614   }
3615
3616   FriendDecl *FrD = FriendDecl::Create(Importer.getToContext(), DC,
3617                                        Importer.Import(D->getLocation()),
3618                                        ToFU, Importer.Import(D->getFriendLoc()),
3619                                        ToTPLists);
3620
3621   Importer.Imported(D, FrD);
3622   RD->pushFriendDecl(FrD);
3623
3624   FrD->setAccess(D->getAccess());
3625   FrD->setLexicalDeclContext(LexicalDC);
3626   LexicalDC->addDeclInternal(FrD);
3627   return FrD;
3628 }
3629
3630 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3631   // Import the major distinguishing characteristics of an ivar.
3632   DeclContext *DC, *LexicalDC;
3633   DeclarationName Name;
3634   SourceLocation Loc;
3635   NamedDecl *ToD;
3636   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3637     return nullptr;
3638   if (ToD)
3639     return ToD;
3640
3641   // Determine whether we've already imported this ivar
3642   SmallVector<NamedDecl *, 2> FoundDecls;
3643   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3644   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3645     if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
3646       if (Importer.IsStructurallyEquivalent(D->getType(),
3647                                             FoundIvar->getType())) {
3648         Importer.Imported(D, FoundIvar);
3649         return FoundIvar;
3650       }
3651
3652       Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3653         << Name << D->getType() << FoundIvar->getType();
3654       Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3655         << FoundIvar->getType();
3656       return nullptr;
3657     }
3658   }
3659
3660   // Import the type.
3661   QualType T = Importer.Import(D->getType());
3662   if (T.isNull())
3663     return nullptr;
3664
3665   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3666   Expr *BitWidth = Importer.Import(D->getBitWidth());
3667   if (!BitWidth && D->getBitWidth())
3668     return nullptr;
3669
3670   ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3671                                               cast<ObjCContainerDecl>(DC),
3672                                        Importer.Import(D->getInnerLocStart()),
3673                                               Loc, Name.getAsIdentifierInfo(),
3674                                               T, TInfo, D->getAccessControl(),
3675                                               BitWidth, D->getSynthesize());
3676   ToIvar->setLexicalDeclContext(LexicalDC);
3677   Importer.Imported(D, ToIvar);
3678   LexicalDC->addDeclInternal(ToIvar);
3679   return ToIvar;
3680
3681 }
3682
3683 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3684   // Import the major distinguishing characteristics of a variable.
3685   DeclContext *DC, *LexicalDC;
3686   DeclarationName Name;
3687   SourceLocation Loc;
3688   NamedDecl *ToD;
3689   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3690     return nullptr;
3691   if (ToD)
3692     return ToD;
3693
3694   // Try to find a variable in our own ("to") context with the same name and
3695   // in the same context as the variable we're importing.
3696   if (D->isFileVarDecl()) {
3697     VarDecl *MergeWithVar = nullptr;
3698     SmallVector<NamedDecl *, 4> ConflictingDecls;
3699     unsigned IDNS = Decl::IDNS_Ordinary;
3700     SmallVector<NamedDecl *, 2> FoundDecls;
3701     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3702     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3703       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3704         continue;
3705
3706       if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
3707         // We have found a variable that we may need to merge with. Check it.
3708         if (FoundVar->hasExternalFormalLinkage() &&
3709             D->hasExternalFormalLinkage()) {
3710           if (Importer.IsStructurallyEquivalent(D->getType(),
3711                                                 FoundVar->getType())) {
3712             MergeWithVar = FoundVar;
3713             break;
3714           }
3715
3716           const ArrayType *FoundArray
3717             = Importer.getToContext().getAsArrayType(FoundVar->getType());
3718           const ArrayType *TArray
3719             = Importer.getToContext().getAsArrayType(D->getType());
3720           if (FoundArray && TArray) {
3721             if (isa<IncompleteArrayType>(FoundArray) &&
3722                 isa<ConstantArrayType>(TArray)) {
3723               // Import the type.
3724               QualType T = Importer.Import(D->getType());
3725               if (T.isNull())
3726                 return nullptr;
3727
3728               FoundVar->setType(T);
3729               MergeWithVar = FoundVar;
3730               break;
3731             } else if (isa<IncompleteArrayType>(TArray) &&
3732                        isa<ConstantArrayType>(FoundArray)) {
3733               MergeWithVar = FoundVar;
3734               break;
3735             }
3736           }
3737
3738           Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3739             << Name << D->getType() << FoundVar->getType();
3740           Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3741             << FoundVar->getType();
3742         }
3743       }
3744
3745       ConflictingDecls.push_back(FoundDecls[I]);
3746     }
3747
3748     if (MergeWithVar) {
3749       // An equivalent variable with external linkage has been found. Link
3750       // the two declarations, then merge them.
3751       Importer.Imported(D, MergeWithVar);
3752
3753       if (VarDecl *DDef = D->getDefinition()) {
3754         if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3755           Importer.ToDiag(ExistingDef->getLocation(),
3756                           diag::err_odr_variable_multiple_def)
3757             << Name;
3758           Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3759         } else {
3760           Expr *Init = Importer.Import(DDef->getInit());
3761           MergeWithVar->setInit(Init);
3762           if (DDef->isInitKnownICE()) {
3763             EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3764             Eval->CheckedICE = true;
3765             Eval->IsICE = DDef->isInitICE();
3766           }
3767         }
3768       }
3769
3770       return MergeWithVar;
3771     }
3772
3773     if (!ConflictingDecls.empty()) {
3774       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3775                                          ConflictingDecls.data(),
3776                                          ConflictingDecls.size());
3777       if (!Name)
3778         return nullptr;
3779     }
3780   }
3781
3782   // Import the type.
3783   QualType T = Importer.Import(D->getType());
3784   if (T.isNull())
3785     return nullptr;
3786
3787   // Create the imported variable.
3788   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3789   VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3790                                    Importer.Import(D->getInnerLocStart()),
3791                                    Loc, Name.getAsIdentifierInfo(),
3792                                    T, TInfo,
3793                                    D->getStorageClass());
3794   ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3795   ToVar->setAccess(D->getAccess());
3796   ToVar->setLexicalDeclContext(LexicalDC);
3797   Importer.Imported(D, ToVar);
3798   LexicalDC->addDeclInternal(ToVar);
3799
3800   if (!D->isFileVarDecl() &&
3801       D->isUsed())
3802     ToVar->setIsUsed();
3803
3804   // Merge the initializer.
3805   if (ImportDefinition(D, ToVar))
3806     return nullptr;
3807
3808   if (D->isConstexpr())
3809     ToVar->setConstexpr(true);
3810
3811   return ToVar;
3812 }
3813
3814 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3815   // Parameters are created in the translation unit's context, then moved
3816   // into the function declaration's context afterward.
3817   DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3818
3819   // Import the name of this declaration.
3820   DeclarationName Name = Importer.Import(D->getDeclName());
3821   if (D->getDeclName() && !Name)
3822     return nullptr;
3823
3824   // Import the location of this declaration.
3825   SourceLocation Loc = Importer.Import(D->getLocation());
3826
3827   // Import the parameter's type.
3828   QualType T = Importer.Import(D->getType());
3829   if (T.isNull())
3830     return nullptr;
3831
3832   // Create the imported parameter.
3833   ImplicitParamDecl *ToParm
3834     = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3835                                 Loc, Name.getAsIdentifierInfo(),
3836                                 T);
3837   return Importer.Imported(D, ToParm);
3838 }
3839
3840 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3841   // Parameters are created in the translation unit's context, then moved
3842   // into the function declaration's context afterward.
3843   DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3844
3845   // Import the name of this declaration.
3846   DeclarationName Name = Importer.Import(D->getDeclName());
3847   if (D->getDeclName() && !Name)
3848     return nullptr;
3849
3850   // Import the location of this declaration.
3851   SourceLocation Loc = Importer.Import(D->getLocation());
3852
3853   // Import the parameter's type.
3854   QualType T = Importer.Import(D->getType());
3855   if (T.isNull())
3856     return nullptr;
3857
3858   // Create the imported parameter.
3859   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3860   ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3861                                      Importer.Import(D->getInnerLocStart()),
3862                                             Loc, Name.getAsIdentifierInfo(),
3863                                             T, TInfo, D->getStorageClass(),
3864                                             /*DefaultArg*/ nullptr);
3865
3866   // Set the default argument.
3867   ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3868   ToParm->setKNRPromoted(D->isKNRPromoted());
3869
3870   Expr *ToDefArg = nullptr;
3871   Expr *FromDefArg = nullptr;
3872   if (D->hasUninstantiatedDefaultArg()) {
3873     FromDefArg = D->getUninstantiatedDefaultArg();
3874     ToDefArg = Importer.Import(FromDefArg);
3875     ToParm->setUninstantiatedDefaultArg(ToDefArg);
3876   } else if (D->hasUnparsedDefaultArg()) {
3877     ToParm->setUnparsedDefaultArg();
3878   } else if (D->hasDefaultArg()) {
3879     FromDefArg = D->getDefaultArg();
3880     ToDefArg = Importer.Import(FromDefArg);
3881     ToParm->setDefaultArg(ToDefArg);
3882   }
3883   if (FromDefArg && !ToDefArg)
3884     return nullptr;
3885
3886   if (D->isUsed())
3887     ToParm->setIsUsed();
3888
3889   return Importer.Imported(D, ToParm);
3890 }
3891
3892 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3893   // Import the major distinguishing characteristics of a method.
3894   DeclContext *DC, *LexicalDC;
3895   DeclarationName Name;
3896   SourceLocation Loc;
3897   NamedDecl *ToD;
3898   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3899     return nullptr;
3900   if (ToD)
3901     return ToD;
3902
3903   SmallVector<NamedDecl *, 2> FoundDecls;
3904   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3905   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3906     if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
3907       if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3908         continue;
3909
3910       // Check return types.
3911       if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3912                                              FoundMethod->getReturnType())) {
3913         Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3914             << D->isInstanceMethod() << Name << D->getReturnType()
3915             << FoundMethod->getReturnType();
3916         Importer.ToDiag(FoundMethod->getLocation(),
3917                         diag::note_odr_objc_method_here)
3918           << D->isInstanceMethod() << Name;
3919         return nullptr;
3920       }
3921
3922       // Check the number of parameters.
3923       if (D->param_size() != FoundMethod->param_size()) {
3924         Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3925           << D->isInstanceMethod() << Name
3926           << D->param_size() << FoundMethod->param_size();
3927         Importer.ToDiag(FoundMethod->getLocation(),
3928                         diag::note_odr_objc_method_here)
3929           << D->isInstanceMethod() << Name;
3930         return nullptr;
3931       }
3932
3933       // Check parameter types.
3934       for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3935              PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3936            P != PEnd; ++P, ++FoundP) {
3937         if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3938                                                (*FoundP)->getType())) {
3939           Importer.FromDiag((*P)->getLocation(),
3940                             diag::err_odr_objc_method_param_type_inconsistent)
3941             << D->isInstanceMethod() << Name
3942             << (*P)->getType() << (*FoundP)->getType();
3943           Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3944             << (*FoundP)->getType();
3945           return nullptr;
3946         }
3947       }
3948
3949       // Check variadic/non-variadic.
3950       // Check the number of parameters.
3951       if (D->isVariadic() != FoundMethod->isVariadic()) {
3952         Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3953           << D->isInstanceMethod() << Name;
3954         Importer.ToDiag(FoundMethod->getLocation(),
3955                         diag::note_odr_objc_method_here)
3956           << D->isInstanceMethod() << Name;
3957         return nullptr;
3958       }
3959
3960       // FIXME: Any other bits we need to merge?
3961       return Importer.Imported(D, FoundMethod);
3962     }
3963   }
3964
3965   // Import the result type.
3966   QualType ResultTy = Importer.Import(D->getReturnType());
3967   if (ResultTy.isNull())
3968     return nullptr;
3969
3970   TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3971
3972   ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create(
3973       Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3974       Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(),
3975       D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3976       D->getImplementationControl(), D->hasRelatedResultType());
3977
3978   // FIXME: When we decide to merge method definitions, we'll need to
3979   // deal with implicit parameters.
3980
3981   // Import the parameters
3982   SmallVector<ParmVarDecl *, 5> ToParams;
3983   for (auto *FromP : D->parameters()) {
3984     ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3985     if (!ToP)
3986       return nullptr;
3987
3988     ToParams.push_back(ToP);
3989   }
3990
3991   // Set the parameters.
3992   for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
3993     ToParams[I]->setOwningFunction(ToMethod);
3994     ToMethod->addDeclInternal(ToParams[I]);
3995   }
3996   SmallVector<SourceLocation, 12> SelLocs;
3997   D->getSelectorLocs(SelLocs);
3998   ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3999
4000   ToMethod->setLexicalDeclContext(LexicalDC);
4001   Importer.Imported(D, ToMethod);
4002   LexicalDC->addDeclInternal(ToMethod);
4003   return ToMethod;
4004 }
4005
4006 Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
4007   // Import the major distinguishing characteristics of a category.
4008   DeclContext *DC, *LexicalDC;
4009   DeclarationName Name;
4010   SourceLocation Loc;
4011   NamedDecl *ToD;
4012   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4013     return nullptr;
4014   if (ToD)
4015     return ToD;
4016
4017   TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
4018   if (!BoundInfo)
4019     return nullptr;
4020
4021   ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create(
4022                                 Importer.getToContext(), DC,
4023                                 D->getVariance(),
4024                                 Importer.Import(D->getVarianceLoc()),
4025                                 D->getIndex(),
4026                                 Importer.Import(D->getLocation()),
4027                                 Name.getAsIdentifierInfo(),
4028                                 Importer.Import(D->getColonLoc()),
4029                                 BoundInfo);
4030   Importer.Imported(D, Result);
4031   Result->setLexicalDeclContext(LexicalDC);
4032   return Result;
4033 }
4034
4035 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
4036   // Import the major distinguishing characteristics of a category.
4037   DeclContext *DC, *LexicalDC;
4038   DeclarationName Name;
4039   SourceLocation Loc;
4040   NamedDecl *ToD;
4041   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4042     return nullptr;
4043   if (ToD)
4044     return ToD;
4045
4046   ObjCInterfaceDecl *ToInterface
4047     = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
4048   if (!ToInterface)
4049     return nullptr;
4050
4051   // Determine if we've already encountered this category.
4052   ObjCCategoryDecl *MergeWithCategory
4053     = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
4054   ObjCCategoryDecl *ToCategory = MergeWithCategory;
4055   if (!ToCategory) {
4056     ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
4057                                           Importer.Import(D->getAtStartLoc()),
4058                                           Loc,
4059                                        Importer.Import(D->getCategoryNameLoc()),
4060                                           Name.getAsIdentifierInfo(),
4061                                           ToInterface,
4062                                           /*TypeParamList=*/nullptr,
4063                                        Importer.Import(D->getIvarLBraceLoc()),
4064                                        Importer.Import(D->getIvarRBraceLoc()));
4065     ToCategory->setLexicalDeclContext(LexicalDC);
4066     LexicalDC->addDeclInternal(ToCategory);
4067     Importer.Imported(D, ToCategory);
4068     // Import the type parameter list after calling Imported, to avoid
4069     // loops when bringing in their DeclContext.
4070     ToCategory->setTypeParamList(ImportObjCTypeParamList(
4071                                    D->getTypeParamList()));
4072
4073     // Import protocols
4074     SmallVector<ObjCProtocolDecl *, 4> Protocols;
4075     SmallVector<SourceLocation, 4> ProtocolLocs;
4076     ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
4077       = D->protocol_loc_begin();
4078     for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
4079                                           FromProtoEnd = D->protocol_end();
4080          FromProto != FromProtoEnd;
4081          ++FromProto, ++FromProtoLoc) {
4082       ObjCProtocolDecl *ToProto
4083         = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4084       if (!ToProto)
4085         return nullptr;
4086       Protocols.push_back(ToProto);
4087       ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4088     }
4089
4090     // FIXME: If we're merging, make sure that the protocol list is the same.
4091     ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
4092                                 ProtocolLocs.data(), Importer.getToContext());
4093
4094   } else {
4095     Importer.Imported(D, ToCategory);
4096   }
4097
4098   // Import all of the members of this category.
4099   ImportDeclContext(D);
4100
4101   // If we have an implementation, import it as well.
4102   if (D->getImplementation()) {
4103     ObjCCategoryImplDecl *Impl
4104       = cast_or_null<ObjCCategoryImplDecl>(
4105                                        Importer.Import(D->getImplementation()));
4106     if (!Impl)
4107       return nullptr;
4108
4109     ToCategory->setImplementation(Impl);
4110   }
4111
4112   return ToCategory;
4113 }
4114
4115 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
4116                                        ObjCProtocolDecl *To,
4117                                        ImportDefinitionKind Kind) {
4118   if (To->getDefinition()) {
4119     if (shouldForceImportDeclContext(Kind))
4120       ImportDeclContext(From);
4121     return false;
4122   }
4123
4124   // Start the protocol definition
4125   To->startDefinition();
4126
4127   // Import protocols
4128   SmallVector<ObjCProtocolDecl *, 4> Protocols;
4129   SmallVector<SourceLocation, 4> ProtocolLocs;
4130   ObjCProtocolDecl::protocol_loc_iterator
4131   FromProtoLoc = From->protocol_loc_begin();
4132   for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
4133                                         FromProtoEnd = From->protocol_end();
4134        FromProto != FromProtoEnd;
4135        ++FromProto, ++FromProtoLoc) {
4136     ObjCProtocolDecl *ToProto
4137       = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4138     if (!ToProto)
4139       return true;
4140     Protocols.push_back(ToProto);
4141     ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4142   }
4143
4144   // FIXME: If we're merging, make sure that the protocol list is the same.
4145   To->setProtocolList(Protocols.data(), Protocols.size(),
4146                       ProtocolLocs.data(), Importer.getToContext());
4147
4148   if (shouldForceImportDeclContext(Kind)) {
4149     // Import all of the members of this protocol.
4150     ImportDeclContext(From, /*ForceImport=*/true);
4151   }
4152   return false;
4153 }
4154
4155 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
4156   // If this protocol has a definition in the translation unit we're coming
4157   // from, but this particular declaration is not that definition, import the
4158   // definition and map to that.
4159   ObjCProtocolDecl *Definition = D->getDefinition();
4160   if (Definition && Definition != D) {
4161     Decl *ImportedDef = Importer.Import(Definition);
4162     if (!ImportedDef)
4163       return nullptr;
4164
4165     return Importer.Imported(D, ImportedDef);
4166   }
4167
4168   // Import the major distinguishing characteristics of a protocol.
4169   DeclContext *DC, *LexicalDC;
4170   DeclarationName Name;
4171   SourceLocation Loc;
4172   NamedDecl *ToD;
4173   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4174     return nullptr;
4175   if (ToD)
4176     return ToD;
4177
4178   ObjCProtocolDecl *MergeWithProtocol = nullptr;
4179   SmallVector<NamedDecl *, 2> FoundDecls;
4180   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4181   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4182     if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
4183       continue;
4184
4185     if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
4186       break;
4187   }
4188
4189   ObjCProtocolDecl *ToProto = MergeWithProtocol;
4190   if (!ToProto) {
4191     ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
4192                                        Name.getAsIdentifierInfo(), Loc,
4193                                        Importer.Import(D->getAtStartLoc()),
4194                                        /*PrevDecl=*/nullptr);
4195     ToProto->setLexicalDeclContext(LexicalDC);
4196     LexicalDC->addDeclInternal(ToProto);
4197   }
4198
4199   Importer.Imported(D, ToProto);
4200
4201   if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
4202     return nullptr;
4203
4204   return ToProto;
4205 }
4206
4207 Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
4208   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4209   DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4210
4211   SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
4212   SourceLocation LangLoc = Importer.Import(D->getLocation());
4213
4214   bool HasBraces = D->hasBraces();
4215
4216   LinkageSpecDecl *ToLinkageSpec =
4217     LinkageSpecDecl::Create(Importer.getToContext(),
4218                             DC,
4219                             ExternLoc,
4220                             LangLoc,
4221                             D->getLanguage(),
4222                             HasBraces);
4223
4224   if (HasBraces) {
4225     SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
4226     ToLinkageSpec->setRBraceLoc(RBraceLoc);
4227   }
4228
4229   ToLinkageSpec->setLexicalDeclContext(LexicalDC);
4230   LexicalDC->addDeclInternal(ToLinkageSpec);
4231
4232   Importer.Imported(D, ToLinkageSpec);
4233
4234   return ToLinkageSpec;
4235 }
4236
4237 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
4238                                        ObjCInterfaceDecl *To,
4239                                        ImportDefinitionKind Kind) {
4240   if (To->getDefinition()) {
4241     // Check consistency of superclass.
4242     ObjCInterfaceDecl *FromSuper = From->getSuperClass();
4243     if (FromSuper) {
4244       FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
4245       if (!FromSuper)
4246         return true;
4247     }
4248
4249     ObjCInterfaceDecl *ToSuper = To->getSuperClass();
4250     if ((bool)FromSuper != (bool)ToSuper ||
4251         (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
4252       Importer.ToDiag(To->getLocation(),
4253                       diag::err_odr_objc_superclass_inconsistent)
4254         << To->getDeclName();
4255       if (ToSuper)
4256         Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
4257           << To->getSuperClass()->getDeclName();
4258       else
4259         Importer.ToDiag(To->getLocation(),
4260                         diag::note_odr_objc_missing_superclass);
4261       if (From->getSuperClass())
4262         Importer.FromDiag(From->getSuperClassLoc(),
4263                           diag::note_odr_objc_superclass)
4264         << From->getSuperClass()->getDeclName();
4265       else
4266         Importer.FromDiag(From->getLocation(),
4267                           diag::note_odr_objc_missing_superclass);
4268     }
4269
4270     if (shouldForceImportDeclContext(Kind))
4271       ImportDeclContext(From);
4272     return false;
4273   }
4274
4275   // Start the definition.
4276   To->startDefinition();
4277
4278   // If this class has a superclass, import it.
4279   if (From->getSuperClass()) {
4280     TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
4281     if (!SuperTInfo)
4282       return true;
4283
4284     To->setSuperClass(SuperTInfo);
4285   }
4286
4287   // Import protocols
4288   SmallVector<ObjCProtocolDecl *, 4> Protocols;
4289   SmallVector<SourceLocation, 4> ProtocolLocs;
4290   ObjCInterfaceDecl::protocol_loc_iterator
4291   FromProtoLoc = From->protocol_loc_begin();
4292
4293   for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
4294                                          FromProtoEnd = From->protocol_end();
4295        FromProto != FromProtoEnd;
4296        ++FromProto, ++FromProtoLoc) {
4297     ObjCProtocolDecl *ToProto
4298       = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4299     if (!ToProto)
4300       return true;
4301     Protocols.push_back(ToProto);
4302     ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4303   }
4304
4305   // FIXME: If we're merging, make sure that the protocol list is the same.
4306   To->setProtocolList(Protocols.data(), Protocols.size(),
4307                       ProtocolLocs.data(), Importer.getToContext());
4308
4309   // Import categories. When the categories themselves are imported, they'll
4310   // hook themselves into this interface.
4311   for (auto *Cat : From->known_categories())
4312     Importer.Import(Cat);
4313
4314   // If we have an @implementation, import it as well.
4315   if (From->getImplementation()) {
4316     ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
4317                                      Importer.Import(From->getImplementation()));
4318     if (!Impl)
4319       return true;
4320
4321     To->setImplementation(Impl);
4322   }
4323
4324   if (shouldForceImportDeclContext(Kind)) {
4325     // Import all of the members of this class.
4326     ImportDeclContext(From, /*ForceImport=*/true);
4327   }
4328   return false;
4329 }
4330
4331 ObjCTypeParamList *
4332 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
4333   if (!list)
4334     return nullptr;
4335
4336   SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
4337   for (auto fromTypeParam : *list) {
4338     auto toTypeParam = cast_or_null<ObjCTypeParamDecl>(
4339                          Importer.Import(fromTypeParam));
4340     if (!toTypeParam)
4341       return nullptr;
4342
4343     toTypeParams.push_back(toTypeParam);
4344   }
4345
4346   return ObjCTypeParamList::create(Importer.getToContext(),
4347                                    Importer.Import(list->getLAngleLoc()),
4348                                    toTypeParams,
4349                                    Importer.Import(list->getRAngleLoc()));
4350 }
4351
4352 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
4353   // If this class has a definition in the translation unit we're coming from,
4354   // but this particular declaration is not that definition, import the
4355   // definition and map to that.
4356   ObjCInterfaceDecl *Definition = D->getDefinition();
4357   if (Definition && Definition != D) {
4358     Decl *ImportedDef = Importer.Import(Definition);
4359     if (!ImportedDef)
4360       return nullptr;
4361
4362     return Importer.Imported(D, ImportedDef);
4363   }
4364
4365   // Import the major distinguishing characteristics of an @interface.
4366   DeclContext *DC, *LexicalDC;
4367   DeclarationName Name;
4368   SourceLocation Loc;
4369   NamedDecl *ToD;
4370   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4371     return nullptr;
4372   if (ToD)
4373     return ToD;
4374
4375   // Look for an existing interface with the same name.
4376   ObjCInterfaceDecl *MergeWithIface = nullptr;
4377   SmallVector<NamedDecl *, 2> FoundDecls;
4378   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4379   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4380     if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4381       continue;
4382
4383     if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
4384       break;
4385   }
4386
4387   // Create an interface declaration, if one does not already exist.
4388   ObjCInterfaceDecl *ToIface = MergeWithIface;
4389   if (!ToIface) {
4390     ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
4391                                         Importer.Import(D->getAtStartLoc()),
4392                                         Name.getAsIdentifierInfo(),
4393                                         /*TypeParamList=*/nullptr,
4394                                         /*PrevDecl=*/nullptr, Loc,
4395                                         D->isImplicitInterfaceDecl());
4396     ToIface->setLexicalDeclContext(LexicalDC);
4397     LexicalDC->addDeclInternal(ToIface);
4398   }
4399   Importer.Imported(D, ToIface);
4400   // Import the type parameter list after calling Imported, to avoid
4401   // loops when bringing in their DeclContext.
4402   ToIface->setTypeParamList(ImportObjCTypeParamList(
4403                               D->getTypeParamListAsWritten()));
4404
4405   if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
4406     return nullptr;
4407
4408   return ToIface;
4409 }
4410
4411 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
4412   ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
4413                                         Importer.Import(D->getCategoryDecl()));
4414   if (!Category)
4415     return nullptr;
4416
4417   ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4418   if (!ToImpl) {
4419     DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4420     if (!DC)
4421       return nullptr;
4422
4423     SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
4424     ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
4425                                           Importer.Import(D->getIdentifier()),
4426                                           Category->getClassInterface(),
4427                                           Importer.Import(D->getLocation()),
4428                                           Importer.Import(D->getAtStartLoc()),
4429                                           CategoryNameLoc);
4430
4431     DeclContext *LexicalDC = DC;
4432     if (D->getDeclContext() != D->getLexicalDeclContext()) {
4433       LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4434       if (!LexicalDC)
4435         return nullptr;
4436
4437       ToImpl->setLexicalDeclContext(LexicalDC);
4438     }
4439
4440     LexicalDC->addDeclInternal(ToImpl);
4441     Category->setImplementation(ToImpl);
4442   }
4443
4444   Importer.Imported(D, ToImpl);
4445   ImportDeclContext(D);
4446   return ToImpl;
4447 }
4448
4449 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
4450   // Find the corresponding interface.
4451   ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
4452                                        Importer.Import(D->getClassInterface()));
4453   if (!Iface)
4454     return nullptr;
4455
4456   // Import the superclass, if any.
4457   ObjCInterfaceDecl *Super = nullptr;
4458   if (D->getSuperClass()) {
4459     Super = cast_or_null<ObjCInterfaceDecl>(
4460                                           Importer.Import(D->getSuperClass()));
4461     if (!Super)
4462       return nullptr;
4463   }
4464
4465   ObjCImplementationDecl *Impl = Iface->getImplementation();
4466   if (!Impl) {
4467     // We haven't imported an implementation yet. Create a new @implementation
4468     // now.
4469     Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
4470                                   Importer.ImportContext(D->getDeclContext()),
4471                                           Iface, Super,
4472                                           Importer.Import(D->getLocation()),
4473                                           Importer.Import(D->getAtStartLoc()),
4474                                           Importer.Import(D->getSuperClassLoc()),
4475                                           Importer.Import(D->getIvarLBraceLoc()),
4476                                           Importer.Import(D->getIvarRBraceLoc()));
4477
4478     if (D->getDeclContext() != D->getLexicalDeclContext()) {
4479       DeclContext *LexicalDC
4480         = Importer.ImportContext(D->getLexicalDeclContext());
4481       if (!LexicalDC)
4482         return nullptr;
4483       Impl->setLexicalDeclContext(LexicalDC);
4484     }
4485
4486     // Associate the implementation with the class it implements.
4487     Iface->setImplementation(Impl);
4488     Importer.Imported(D, Iface->getImplementation());
4489   } else {
4490     Importer.Imported(D, Iface->getImplementation());
4491
4492     // Verify that the existing @implementation has the same superclass.
4493     if ((Super && !Impl->getSuperClass()) ||
4494         (!Super && Impl->getSuperClass()) ||
4495         (Super && Impl->getSuperClass() &&
4496          !declaresSameEntity(Super->getCanonicalDecl(),
4497                              Impl->getSuperClass()))) {
4498       Importer.ToDiag(Impl->getLocation(),
4499                       diag::err_odr_objc_superclass_inconsistent)
4500         << Iface->getDeclName();
4501       // FIXME: It would be nice to have the location of the superclass
4502       // below.
4503       if (Impl->getSuperClass())
4504         Importer.ToDiag(Impl->getLocation(),
4505                         diag::note_odr_objc_superclass)
4506         << Impl->getSuperClass()->getDeclName();
4507       else
4508         Importer.ToDiag(Impl->getLocation(),
4509                         diag::note_odr_objc_missing_superclass);
4510       if (D->getSuperClass())
4511         Importer.FromDiag(D->getLocation(),
4512                           diag::note_odr_objc_superclass)
4513         << D->getSuperClass()->getDeclName();
4514       else
4515         Importer.FromDiag(D->getLocation(),
4516                           diag::note_odr_objc_missing_superclass);
4517       return nullptr;
4518     }
4519   }
4520
4521   // Import all of the members of this @implementation.
4522   ImportDeclContext(D);
4523
4524   return Impl;
4525 }
4526
4527 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
4528   // Import the major distinguishing characteristics of an @property.
4529   DeclContext *DC, *LexicalDC;
4530   DeclarationName Name;
4531   SourceLocation Loc;
4532   NamedDecl *ToD;
4533   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4534     return nullptr;
4535   if (ToD)
4536     return ToD;
4537
4538   // Check whether we have already imported this property.
4539   SmallVector<NamedDecl *, 2> FoundDecls;
4540   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4541   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4542     if (ObjCPropertyDecl *FoundProp
4543                                 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
4544       // Check property types.
4545       if (!Importer.IsStructurallyEquivalent(D->getType(),
4546                                              FoundProp->getType())) {
4547         Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
4548           << Name << D->getType() << FoundProp->getType();
4549         Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
4550           << FoundProp->getType();
4551         return nullptr;
4552       }
4553
4554       // FIXME: Check property attributes, getters, setters, etc.?
4555
4556       // Consider these properties to be equivalent.
4557       Importer.Imported(D, FoundProp);
4558       return FoundProp;
4559     }
4560   }
4561
4562   // Import the type.
4563   TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4564   if (!TSI)
4565     return nullptr;
4566
4567   // Create the new property.
4568   ObjCPropertyDecl *ToProperty
4569     = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
4570                                Name.getAsIdentifierInfo(),
4571                                Importer.Import(D->getAtLoc()),
4572                                Importer.Import(D->getLParenLoc()),
4573                                Importer.Import(D->getType()),
4574                                TSI,
4575                                D->getPropertyImplementation());
4576   Importer.Imported(D, ToProperty);
4577   ToProperty->setLexicalDeclContext(LexicalDC);
4578   LexicalDC->addDeclInternal(ToProperty);
4579
4580   ToProperty->setPropertyAttributes(D->getPropertyAttributes());
4581   ToProperty->setPropertyAttributesAsWritten(
4582                                       D->getPropertyAttributesAsWritten());
4583   ToProperty->setGetterName(Importer.Import(D->getGetterName()),
4584                             Importer.Import(D->getGetterNameLoc()));
4585   ToProperty->setSetterName(Importer.Import(D->getSetterName()),
4586                             Importer.Import(D->getSetterNameLoc()));
4587   ToProperty->setGetterMethodDecl(
4588      cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4589   ToProperty->setSetterMethodDecl(
4590      cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4591   ToProperty->setPropertyIvarDecl(
4592        cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4593   return ToProperty;
4594 }
4595
4596 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
4597   ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
4598                                         Importer.Import(D->getPropertyDecl()));
4599   if (!Property)
4600     return nullptr;
4601
4602   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4603   if (!DC)
4604     return nullptr;
4605
4606   // Import the lexical declaration context.
4607   DeclContext *LexicalDC = DC;
4608   if (D->getDeclContext() != D->getLexicalDeclContext()) {
4609     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4610     if (!LexicalDC)
4611       return nullptr;
4612   }
4613
4614   ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
4615   if (!InImpl)
4616     return nullptr;
4617
4618   // Import the ivar (for an @synthesize).
4619   ObjCIvarDecl *Ivar = nullptr;
4620   if (D->getPropertyIvarDecl()) {
4621     Ivar = cast_or_null<ObjCIvarDecl>(
4622                                     Importer.Import(D->getPropertyIvarDecl()));
4623     if (!Ivar)
4624       return nullptr;
4625   }
4626
4627   ObjCPropertyImplDecl *ToImpl
4628     = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
4629                                    Property->getQueryKind());
4630   if (!ToImpl) {
4631     ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
4632                                           Importer.Import(D->getLocStart()),
4633                                           Importer.Import(D->getLocation()),
4634                                           Property,
4635                                           D->getPropertyImplementation(),
4636                                           Ivar,
4637                                   Importer.Import(D->getPropertyIvarDeclLoc()));
4638     ToImpl->setLexicalDeclContext(LexicalDC);
4639     Importer.Imported(D, ToImpl);
4640     LexicalDC->addDeclInternal(ToImpl);
4641   } else {
4642     // Check that we have the same kind of property implementation (@synthesize
4643     // vs. @dynamic).
4644     if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
4645       Importer.ToDiag(ToImpl->getLocation(),
4646                       diag::err_odr_objc_property_impl_kind_inconsistent)
4647         << Property->getDeclName()
4648         << (ToImpl->getPropertyImplementation()
4649                                               == ObjCPropertyImplDecl::Dynamic);
4650       Importer.FromDiag(D->getLocation(),
4651                         diag::note_odr_objc_property_impl_kind)
4652         << D->getPropertyDecl()->getDeclName()
4653         << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
4654       return nullptr;
4655     }
4656
4657     // For @synthesize, check that we have the same
4658     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
4659         Ivar != ToImpl->getPropertyIvarDecl()) {
4660       Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4661                       diag::err_odr_objc_synthesize_ivar_inconsistent)
4662         << Property->getDeclName()
4663         << ToImpl->getPropertyIvarDecl()->getDeclName()
4664         << Ivar->getDeclName();
4665       Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4666                         diag::note_odr_objc_synthesize_ivar_here)
4667         << D->getPropertyIvarDecl()->getDeclName();
4668       return nullptr;
4669     }
4670
4671     // Merge the existing implementation with the new implementation.
4672     Importer.Imported(D, ToImpl);
4673   }
4674
4675   return ToImpl;
4676 }
4677
4678 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
4679   // For template arguments, we adopt the translation unit as our declaration
4680   // context. This context will be fixed when the actual template declaration
4681   // is created.
4682
4683   // FIXME: Import default argument.
4684   return TemplateTypeParmDecl::Create(Importer.getToContext(),
4685                               Importer.getToContext().getTranslationUnitDecl(),
4686                                       Importer.Import(D->getLocStart()),
4687                                       Importer.Import(D->getLocation()),
4688                                       D->getDepth(),
4689                                       D->getIndex(),
4690                                       Importer.Import(D->getIdentifier()),
4691                                       D->wasDeclaredWithTypename(),
4692                                       D->isParameterPack());
4693 }
4694
4695 Decl *
4696 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
4697   // Import the name of this declaration.
4698   DeclarationName Name = Importer.Import(D->getDeclName());
4699   if (D->getDeclName() && !Name)
4700     return nullptr;
4701
4702   // Import the location of this declaration.
4703   SourceLocation Loc = Importer.Import(D->getLocation());
4704
4705   // Import the type of this declaration.
4706   QualType T = Importer.Import(D->getType());
4707   if (T.isNull())
4708     return nullptr;
4709
4710   // Import type-source information.
4711   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4712   if (D->getTypeSourceInfo() && !TInfo)
4713     return nullptr;
4714
4715   // FIXME: Import default argument.
4716
4717   return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
4718                                Importer.getToContext().getTranslationUnitDecl(),
4719                                          Importer.Import(D->getInnerLocStart()),
4720                                          Loc, D->getDepth(), D->getPosition(),
4721                                          Name.getAsIdentifierInfo(),
4722                                          T, D->isParameterPack(), TInfo);
4723 }
4724
4725 Decl *
4726 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
4727   // Import the name of this declaration.
4728   DeclarationName Name = Importer.Import(D->getDeclName());
4729   if (D->getDeclName() && !Name)
4730     return nullptr;
4731
4732   // Import the location of this declaration.
4733   SourceLocation Loc = Importer.Import(D->getLocation());
4734
4735   // Import template parameters.
4736   TemplateParameterList *TemplateParams
4737     = ImportTemplateParameterList(D->getTemplateParameters());
4738   if (!TemplateParams)
4739     return nullptr;
4740
4741   // FIXME: Import default argument.
4742
4743   return TemplateTemplateParmDecl::Create(Importer.getToContext(),
4744                               Importer.getToContext().getTranslationUnitDecl(),
4745                                           Loc, D->getDepth(), D->getPosition(),
4746                                           D->isParameterPack(),
4747                                           Name.getAsIdentifierInfo(),
4748                                           TemplateParams);
4749 }
4750
4751 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
4752   // If this record has a definition in the translation unit we're coming from,
4753   // but this particular declaration is not that definition, import the
4754   // definition and map to that.
4755   CXXRecordDecl *Definition
4756     = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
4757   if (Definition && Definition != D->getTemplatedDecl()) {
4758     Decl *ImportedDef
4759       = Importer.Import(Definition->getDescribedClassTemplate());
4760     if (!ImportedDef)
4761       return nullptr;
4762
4763     return Importer.Imported(D, ImportedDef);
4764   }
4765
4766   // Import the major distinguishing characteristics of this class template.
4767   DeclContext *DC, *LexicalDC;
4768   DeclarationName Name;
4769   SourceLocation Loc;
4770   NamedDecl *ToD;
4771   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4772     return nullptr;
4773   if (ToD)
4774     return ToD;
4775
4776   // We may already have a template of the same name; try to find and match it.
4777   if (!DC->isFunctionOrMethod()) {
4778     SmallVector<NamedDecl *, 4> ConflictingDecls;
4779     SmallVector<NamedDecl *, 2> FoundDecls;
4780     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4781     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4782       if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4783         continue;
4784
4785       Decl *Found = FoundDecls[I];
4786       if (ClassTemplateDecl *FoundTemplate
4787                                         = dyn_cast<ClassTemplateDecl>(Found)) {
4788         if (IsStructuralMatch(D, FoundTemplate)) {
4789           // The class templates structurally match; call it the same template.
4790           // FIXME: We may be filling in a forward declaration here. Handle
4791           // this case!
4792           Importer.Imported(D->getTemplatedDecl(),
4793                             FoundTemplate->getTemplatedDecl());
4794           return Importer.Imported(D, FoundTemplate);
4795         }
4796       }
4797
4798       ConflictingDecls.push_back(FoundDecls[I]);
4799     }
4800
4801     if (!ConflictingDecls.empty()) {
4802       Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4803                                          ConflictingDecls.data(),
4804                                          ConflictingDecls.size());
4805     }
4806
4807     if (!Name)
4808       return nullptr;
4809   }
4810
4811   CXXRecordDecl *DTemplated = D->getTemplatedDecl();
4812
4813   // Create the declaration that is being templated.
4814   // Create the declaration that is being templated.
4815   CXXRecordDecl *D2Templated = cast_or_null<CXXRecordDecl>(
4816         Importer.Import(DTemplated));
4817   if (!D2Templated)
4818     return nullptr;
4819
4820   // Resolve possible cyclic import.
4821   if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D))
4822     return AlreadyImported;
4823
4824   // Create the class template declaration itself.
4825   TemplateParameterList *TemplateParams
4826     = ImportTemplateParameterList(D->getTemplateParameters());
4827   if (!TemplateParams)
4828     return nullptr;
4829
4830   ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4831                                                     Loc, Name, TemplateParams,
4832                                                     D2Templated);
4833   D2Templated->setDescribedClassTemplate(D2);
4834
4835   D2->setAccess(D->getAccess());
4836   D2->setLexicalDeclContext(LexicalDC);
4837   LexicalDC->addDeclInternal(D2);
4838
4839   // Note the relationship between the class templates.
4840   Importer.Imported(D, D2);
4841   Importer.Imported(DTemplated, D2Templated);
4842
4843   if (DTemplated->isCompleteDefinition() &&
4844       !D2Templated->isCompleteDefinition()) {
4845     // FIXME: Import definition!
4846   }
4847
4848   return D2;
4849 }
4850
4851 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4852                                           ClassTemplateSpecializationDecl *D) {
4853   // If this record has a definition in the translation unit we're coming from,
4854   // but this particular declaration is not that definition, import the
4855   // definition and map to that.
4856   TagDecl *Definition = D->getDefinition();
4857   if (Definition && Definition != D) {
4858     Decl *ImportedDef = Importer.Import(Definition);
4859     if (!ImportedDef)
4860       return nullptr;
4861
4862     return Importer.Imported(D, ImportedDef);
4863   }
4864
4865   ClassTemplateDecl *ClassTemplate
4866     = cast_or_null<ClassTemplateDecl>(Importer.Import(
4867                                                  D->getSpecializedTemplate()));
4868   if (!ClassTemplate)
4869     return nullptr;
4870
4871   // Import the context of this declaration.
4872   DeclContext *DC = ClassTemplate->getDeclContext();
4873   if (!DC)
4874     return nullptr;
4875
4876   DeclContext *LexicalDC = DC;
4877   if (D->getDeclContext() != D->getLexicalDeclContext()) {
4878     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4879     if (!LexicalDC)
4880       return nullptr;
4881   }
4882
4883   // Import the location of this declaration.
4884   SourceLocation StartLoc = Importer.Import(D->getLocStart());
4885   SourceLocation IdLoc = Importer.Import(D->getLocation());
4886
4887   // Import template arguments.
4888   SmallVector<TemplateArgument, 2> TemplateArgs;
4889   if (ImportTemplateArguments(D->getTemplateArgs().data(),
4890                               D->getTemplateArgs().size(),
4891                               TemplateArgs))
4892     return nullptr;
4893
4894   // Try to find an existing specialization with these template arguments.
4895   void *InsertPos = nullptr;
4896   ClassTemplateSpecializationDecl *D2
4897     = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4898   if (D2) {
4899     // We already have a class template specialization with these template
4900     // arguments.
4901
4902     // FIXME: Check for specialization vs. instantiation errors.
4903
4904     if (RecordDecl *FoundDef = D2->getDefinition()) {
4905       if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4906         // The record types structurally match, or the "from" translation
4907         // unit only had a forward declaration anyway; call it the same
4908         // function.
4909         return Importer.Imported(D, FoundDef);
4910       }
4911     }
4912   } else {
4913     // Create a new specialization.
4914     if (ClassTemplatePartialSpecializationDecl *PartialSpec =
4915         dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
4916
4917       // Import TemplateArgumentListInfo
4918       TemplateArgumentListInfo ToTAInfo;
4919       auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
4920       for (unsigned I = 0, E = ASTTemplateArgs.NumTemplateArgs; I < E; ++I) {
4921         bool Error = false;
4922         auto ToLoc = ImportTemplateArgumentLoc(ASTTemplateArgs[I], Error);
4923         if (Error)
4924           return nullptr;
4925         ToTAInfo.addArgument(ToLoc);
4926       }
4927
4928       QualType CanonInjType = Importer.Import(
4929             PartialSpec->getInjectedSpecializationType());
4930       if (CanonInjType.isNull())
4931         return nullptr;
4932       CanonInjType = CanonInjType.getCanonicalType();
4933
4934       TemplateParameterList *ToTPList = ImportTemplateParameterList(
4935             PartialSpec->getTemplateParameters());
4936       if (!ToTPList && PartialSpec->getTemplateParameters())
4937         return nullptr;
4938
4939       D2 = ClassTemplatePartialSpecializationDecl::Create(
4940             Importer.getToContext(), D->getTagKind(), DC, StartLoc, IdLoc,
4941             ToTPList, ClassTemplate,
4942             llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
4943             ToTAInfo, CanonInjType, nullptr);
4944
4945     } else {
4946       D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4947                                                    D->getTagKind(), DC,
4948                                                    StartLoc, IdLoc,
4949                                                    ClassTemplate,
4950                                                    TemplateArgs,
4951                                                    /*PrevDecl=*/nullptr);
4952     }
4953
4954     D2->setSpecializationKind(D->getSpecializationKind());
4955
4956     // Add this specialization to the class template.
4957     ClassTemplate->AddSpecialization(D2, InsertPos);
4958
4959     // Import the qualifier, if any.
4960     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4961
4962     Importer.Imported(D, D2);
4963
4964     if (auto *TSI = D->getTypeAsWritten()) {
4965       TypeSourceInfo *TInfo = Importer.Import(TSI);
4966       if (!TInfo)
4967         return nullptr;
4968       D2->setTypeAsWritten(TInfo);
4969       D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
4970       D2->setExternLoc(Importer.Import(D->getExternLoc()));
4971     }
4972
4973     SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
4974     if (POI.isValid())
4975       D2->setPointOfInstantiation(POI);
4976     else if (D->getPointOfInstantiation().isValid())
4977       return nullptr;
4978
4979     D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
4980
4981     // Add the specialization to this context.
4982     D2->setLexicalDeclContext(LexicalDC);
4983     LexicalDC->addDeclInternal(D2);
4984   }
4985   Importer.Imported(D, D2);
4986   if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4987     return nullptr;
4988
4989   return D2;
4990 }
4991
4992 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4993   // If this variable has a definition in the translation unit we're coming
4994   // from,
4995   // but this particular declaration is not that definition, import the
4996   // definition and map to that.
4997   VarDecl *Definition =
4998       cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4999   if (Definition && Definition != D->getTemplatedDecl()) {
5000     Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
5001     if (!ImportedDef)
5002       return nullptr;
5003
5004     return Importer.Imported(D, ImportedDef);
5005   }
5006
5007   // Import the major distinguishing characteristics of this variable template.
5008   DeclContext *DC, *LexicalDC;
5009   DeclarationName Name;
5010   SourceLocation Loc;
5011   NamedDecl *ToD;
5012   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5013     return nullptr;
5014   if (ToD)
5015     return ToD;
5016
5017   // We may already have a template of the same name; try to find and match it.
5018   assert(!DC->isFunctionOrMethod() &&
5019          "Variable templates cannot be declared at function scope");
5020   SmallVector<NamedDecl *, 4> ConflictingDecls;
5021   SmallVector<NamedDecl *, 2> FoundDecls;
5022   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
5023   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
5024     if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
5025       continue;
5026
5027     Decl *Found = FoundDecls[I];
5028     if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
5029       if (IsStructuralMatch(D, FoundTemplate)) {
5030         // The variable templates structurally match; call it the same template.
5031         Importer.Imported(D->getTemplatedDecl(),
5032                           FoundTemplate->getTemplatedDecl());
5033         return Importer.Imported(D, FoundTemplate);
5034       }
5035     }
5036
5037     ConflictingDecls.push_back(FoundDecls[I]);
5038   }
5039
5040   if (!ConflictingDecls.empty()) {
5041     Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
5042                                        ConflictingDecls.data(),
5043                                        ConflictingDecls.size());
5044   }
5045
5046   if (!Name)
5047     return nullptr;
5048
5049   VarDecl *DTemplated = D->getTemplatedDecl();
5050
5051   // Import the type.
5052   QualType T = Importer.Import(DTemplated->getType());
5053   if (T.isNull())
5054     return nullptr;
5055
5056   // Create the declaration that is being templated.
5057   SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
5058   SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
5059   TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
5060   VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
5061                                          IdLoc, Name.getAsIdentifierInfo(), T,
5062                                          TInfo, DTemplated->getStorageClass());
5063   D2Templated->setAccess(DTemplated->getAccess());
5064   D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
5065   D2Templated->setLexicalDeclContext(LexicalDC);
5066
5067   // Importer.Imported(DTemplated, D2Templated);
5068   // LexicalDC->addDeclInternal(D2Templated);
5069
5070   // Merge the initializer.
5071   if (ImportDefinition(DTemplated, D2Templated))
5072     return nullptr;
5073
5074   // Create the variable template declaration itself.
5075   TemplateParameterList *TemplateParams =
5076       ImportTemplateParameterList(D->getTemplateParameters());
5077   if (!TemplateParams)
5078     return nullptr;
5079
5080   VarTemplateDecl *D2 = VarTemplateDecl::Create(
5081       Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
5082   D2Templated->setDescribedVarTemplate(D2);
5083
5084   D2->setAccess(D->getAccess());
5085   D2->setLexicalDeclContext(LexicalDC);
5086   LexicalDC->addDeclInternal(D2);
5087
5088   // Note the relationship between the variable templates.
5089   Importer.Imported(D, D2);
5090   Importer.Imported(DTemplated, D2Templated);
5091
5092   if (DTemplated->isThisDeclarationADefinition() &&
5093       !D2Templated->isThisDeclarationADefinition()) {
5094     // FIXME: Import definition!
5095   }
5096
5097   return D2;
5098 }
5099
5100 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
5101     VarTemplateSpecializationDecl *D) {
5102   // If this record has a definition in the translation unit we're coming from,
5103   // but this particular declaration is not that definition, import the
5104   // definition and map to that.
5105   VarDecl *Definition = D->getDefinition();
5106   if (Definition && Definition != D) {
5107     Decl *ImportedDef = Importer.Import(Definition);
5108     if (!ImportedDef)
5109       return nullptr;
5110
5111     return Importer.Imported(D, ImportedDef);
5112   }
5113
5114   VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
5115       Importer.Import(D->getSpecializedTemplate()));
5116   if (!VarTemplate)
5117     return nullptr;
5118
5119   // Import the context of this declaration.
5120   DeclContext *DC = VarTemplate->getDeclContext();
5121   if (!DC)
5122     return nullptr;
5123
5124   DeclContext *LexicalDC = DC;
5125   if (D->getDeclContext() != D->getLexicalDeclContext()) {
5126     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
5127     if (!LexicalDC)
5128       return nullptr;
5129   }
5130
5131   // Import the location of this declaration.
5132   SourceLocation StartLoc = Importer.Import(D->getLocStart());
5133   SourceLocation IdLoc = Importer.Import(D->getLocation());
5134
5135   // Import template arguments.
5136   SmallVector<TemplateArgument, 2> TemplateArgs;
5137   if (ImportTemplateArguments(D->getTemplateArgs().data(),
5138                               D->getTemplateArgs().size(), TemplateArgs))
5139     return nullptr;
5140
5141   // Try to find an existing specialization with these template arguments.
5142   void *InsertPos = nullptr;
5143   VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
5144       TemplateArgs, InsertPos);
5145   if (D2) {
5146     // We already have a variable template specialization with these template
5147     // arguments.
5148
5149     // FIXME: Check for specialization vs. instantiation errors.
5150
5151     if (VarDecl *FoundDef = D2->getDefinition()) {
5152       if (!D->isThisDeclarationADefinition() ||
5153           IsStructuralMatch(D, FoundDef)) {
5154         // The record types structurally match, or the "from" translation
5155         // unit only had a forward declaration anyway; call it the same
5156         // variable.
5157         return Importer.Imported(D, FoundDef);
5158       }
5159     }
5160   } else {
5161
5162     // Import the type.
5163     QualType T = Importer.Import(D->getType());
5164     if (T.isNull())
5165       return nullptr;
5166     TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
5167
5168     // Create a new specialization.
5169     D2 = VarTemplateSpecializationDecl::Create(
5170         Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
5171         D->getStorageClass(), TemplateArgs);
5172     D2->setSpecializationKind(D->getSpecializationKind());
5173     D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
5174
5175     // Add this specialization to the class template.
5176     VarTemplate->AddSpecialization(D2, InsertPos);
5177
5178     // Import the qualifier, if any.
5179     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
5180
5181     // Add the specialization to this context.
5182     D2->setLexicalDeclContext(LexicalDC);
5183     LexicalDC->addDeclInternal(D2);
5184   }
5185   Importer.Imported(D, D2);
5186
5187   if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
5188     return nullptr;
5189
5190   return D2;
5191 }
5192
5193 //----------------------------------------------------------------------------
5194 // Import Statements
5195 //----------------------------------------------------------------------------
5196
5197 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
5198   if (DG.isNull())
5199     return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
5200   size_t NumDecls = DG.end() - DG.begin();
5201   SmallVector<Decl *, 1> ToDecls(NumDecls);
5202   auto &_Importer = this->Importer;
5203   std::transform(DG.begin(), DG.end(), ToDecls.begin(),
5204     [&_Importer](Decl *D) -> Decl * {
5205       return _Importer.Import(D);
5206     });
5207   return DeclGroupRef::Create(Importer.getToContext(),
5208                               ToDecls.begin(),
5209                               NumDecls);
5210 }
5211
5212  Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
5213    Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
5214      << S->getStmtClassName();
5215    return nullptr;
5216  }
5217
5218
5219 Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
5220   SmallVector<IdentifierInfo *, 4> Names;
5221   for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5222     IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
5223     // ToII is nullptr when no symbolic name is given for output operand
5224     // see ParseStmtAsm::ParseAsmOperandsOpt
5225     if (!ToII && S->getOutputIdentifier(I))
5226       return nullptr;
5227     Names.push_back(ToII);
5228   }
5229   for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
5230     IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
5231     // ToII is nullptr when no symbolic name is given for input operand
5232     // see ParseStmtAsm::ParseAsmOperandsOpt
5233     if (!ToII && S->getInputIdentifier(I))
5234       return nullptr;
5235     Names.push_back(ToII);
5236   }
5237
5238   SmallVector<StringLiteral *, 4> Clobbers;
5239   for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
5240     StringLiteral *Clobber = cast_or_null<StringLiteral>(
5241           Importer.Import(S->getClobberStringLiteral(I)));
5242     if (!Clobber)
5243       return nullptr;
5244     Clobbers.push_back(Clobber);
5245   }
5246
5247   SmallVector<StringLiteral *, 4> Constraints;
5248   for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5249     StringLiteral *Output = cast_or_null<StringLiteral>(
5250           Importer.Import(S->getOutputConstraintLiteral(I)));
5251     if (!Output)
5252       return nullptr;
5253     Constraints.push_back(Output);
5254   }
5255
5256   for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
5257     StringLiteral *Input = cast_or_null<StringLiteral>(
5258           Importer.Import(S->getInputConstraintLiteral(I)));
5259     if (!Input)
5260       return nullptr;
5261     Constraints.push_back(Input);
5262   }
5263
5264   SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
5265   if (ImportContainerChecked(S->outputs(), Exprs))
5266     return nullptr;
5267
5268   if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
5269     return nullptr;
5270
5271   StringLiteral *AsmStr = cast_or_null<StringLiteral>(
5272         Importer.Import(S->getAsmString()));
5273   if (!AsmStr)
5274     return nullptr;
5275
5276   return new (Importer.getToContext()) GCCAsmStmt(
5277         Importer.getToContext(),
5278         Importer.Import(S->getAsmLoc()),
5279         S->isSimple(),
5280         S->isVolatile(),
5281         S->getNumOutputs(),
5282         S->getNumInputs(),
5283         Names.data(),
5284         Constraints.data(),
5285         Exprs.data(),
5286         AsmStr,
5287         S->getNumClobbers(),
5288         Clobbers.data(),
5289         Importer.Import(S->getRParenLoc()));
5290 }
5291
5292 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
5293   DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
5294   for (Decl *ToD : ToDG) {
5295     if (!ToD)
5296       return nullptr;
5297   }
5298   SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
5299   SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
5300   return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
5301 }
5302
5303 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
5304   SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
5305   return new (Importer.getToContext()) NullStmt(ToSemiLoc,
5306                                                 S->hasLeadingEmptyMacro());
5307 }
5308
5309 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
5310   llvm::SmallVector<Stmt *, 8> ToStmts(S->size());
5311
5312   if (ImportContainerChecked(S->body(), ToStmts))
5313     return nullptr;
5314
5315   SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
5316   SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
5317   return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(),
5318                                                     ToStmts,
5319                                                     ToLBraceLoc, ToRBraceLoc);
5320 }
5321
5322 Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
5323   Expr *ToLHS = Importer.Import(S->getLHS());
5324   if (!ToLHS)
5325     return nullptr;
5326   Expr *ToRHS = Importer.Import(S->getRHS());
5327   if (!ToRHS && S->getRHS())
5328     return nullptr;
5329   SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
5330   SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
5331   SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5332   return new (Importer.getToContext()) CaseStmt(ToLHS, ToRHS,
5333                                                 ToCaseLoc, ToEllipsisLoc,
5334                                                 ToColonLoc);
5335 }
5336
5337 Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
5338   SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
5339   SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5340   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5341   if (!ToSubStmt && S->getSubStmt())
5342     return nullptr;
5343   return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
5344                                                    ToSubStmt);
5345 }
5346
5347 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
5348   SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
5349   LabelDecl *ToLabelDecl =
5350     cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
5351   if (!ToLabelDecl && S->getDecl())
5352     return nullptr;
5353   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5354   if (!ToSubStmt && S->getSubStmt())
5355     return nullptr;
5356   return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
5357                                                  ToSubStmt);
5358 }
5359
5360 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
5361   SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
5362   ArrayRef<const Attr*> FromAttrs(S->getAttrs());
5363   SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
5364   ASTContext &_ToContext = Importer.getToContext();
5365   std::transform(FromAttrs.begin(), FromAttrs.end(), ToAttrs.begin(),
5366     [&_ToContext](const Attr *A) -> const Attr * {
5367       return A->clone(_ToContext);
5368     });
5369   for (const Attr *ToA : ToAttrs) {
5370     if (!ToA)
5371       return nullptr;
5372   }
5373   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5374   if (!ToSubStmt && S->getSubStmt())
5375     return nullptr;
5376   return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
5377                                 ToAttrs, ToSubStmt);
5378 }
5379
5380 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
5381   SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
5382   Stmt *ToInit = Importer.Import(S->getInit());
5383   if (!ToInit && S->getInit())
5384     return nullptr;
5385   VarDecl *ToConditionVariable = nullptr;
5386   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5387     ToConditionVariable =
5388       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5389     if (!ToConditionVariable)
5390       return nullptr;
5391   }
5392   Expr *ToCondition = Importer.Import(S->getCond());
5393   if (!ToCondition && S->getCond())
5394     return nullptr;
5395   Stmt *ToThenStmt = Importer.Import(S->getThen());
5396   if (!ToThenStmt && S->getThen())
5397     return nullptr;
5398   SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
5399   Stmt *ToElseStmt = Importer.Import(S->getElse());
5400   if (!ToElseStmt && S->getElse())
5401     return nullptr;
5402   return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
5403                                               ToIfLoc, S->isConstexpr(),
5404                                               ToInit,
5405                                               ToConditionVariable,
5406                                               ToCondition, ToThenStmt,
5407                                               ToElseLoc, ToElseStmt);
5408 }
5409
5410 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
5411   Stmt *ToInit = Importer.Import(S->getInit());
5412   if (!ToInit && S->getInit())
5413     return nullptr;
5414   VarDecl *ToConditionVariable = nullptr;
5415   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5416     ToConditionVariable =
5417       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5418     if (!ToConditionVariable)
5419       return nullptr;
5420   }
5421   Expr *ToCondition = Importer.Import(S->getCond());
5422   if (!ToCondition && S->getCond())
5423     return nullptr;
5424   SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
5425                          Importer.getToContext(), ToInit,
5426                          ToConditionVariable, ToCondition);
5427   Stmt *ToBody = Importer.Import(S->getBody());
5428   if (!ToBody && S->getBody())
5429     return nullptr;
5430   ToStmt->setBody(ToBody);
5431   ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
5432   // Now we have to re-chain the cases.
5433   SwitchCase *LastChainedSwitchCase = nullptr;
5434   for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
5435        SC = SC->getNextSwitchCase()) {
5436     SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
5437     if (!ToSC)
5438       return nullptr;
5439     if (LastChainedSwitchCase)
5440       LastChainedSwitchCase->setNextSwitchCase(ToSC);
5441     else
5442       ToStmt->setSwitchCaseList(ToSC);
5443     LastChainedSwitchCase = ToSC;
5444   }
5445   return ToStmt;
5446 }
5447
5448 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
5449   VarDecl *ToConditionVariable = nullptr;
5450   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5451     ToConditionVariable =
5452       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5453     if (!ToConditionVariable)
5454       return nullptr;
5455   }
5456   Expr *ToCondition = Importer.Import(S->getCond());
5457   if (!ToCondition && S->getCond())
5458     return nullptr;
5459   Stmt *ToBody = Importer.Import(S->getBody());
5460   if (!ToBody && S->getBody())
5461     return nullptr;
5462   SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5463   return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
5464                                                  ToConditionVariable,
5465                                                  ToCondition, ToBody,
5466                                                  ToWhileLoc);
5467 }
5468
5469 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
5470   Stmt *ToBody = Importer.Import(S->getBody());
5471   if (!ToBody && S->getBody())
5472     return nullptr;
5473   Expr *ToCondition = Importer.Import(S->getCond());
5474   if (!ToCondition && S->getCond())
5475     return nullptr;
5476   SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
5477   SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5478   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5479   return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
5480                                               ToDoLoc, ToWhileLoc,
5481                                               ToRParenLoc);
5482 }
5483
5484 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
5485   Stmt *ToInit = Importer.Import(S->getInit());
5486   if (!ToInit && S->getInit())
5487     return nullptr;
5488   Expr *ToCondition = Importer.Import(S->getCond());
5489   if (!ToCondition && S->getCond())
5490     return nullptr;
5491   VarDecl *ToConditionVariable = nullptr;
5492   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5493     ToConditionVariable =
5494       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5495     if (!ToConditionVariable)
5496       return nullptr;
5497   }
5498   Expr *ToInc = Importer.Import(S->getInc());
5499   if (!ToInc && S->getInc())
5500     return nullptr;
5501   Stmt *ToBody = Importer.Import(S->getBody());
5502   if (!ToBody && S->getBody())
5503     return nullptr;
5504   SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5505   SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
5506   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5507   return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
5508                                                ToInit, ToCondition,
5509                                                ToConditionVariable,
5510                                                ToInc, ToBody,
5511                                                ToForLoc, ToLParenLoc,
5512                                                ToRParenLoc);
5513 }
5514
5515 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
5516   LabelDecl *ToLabel = nullptr;
5517   if (LabelDecl *FromLabel = S->getLabel()) {
5518     ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
5519     if (!ToLabel)
5520       return nullptr;
5521   }
5522   SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5523   SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
5524   return new (Importer.getToContext()) GotoStmt(ToLabel,
5525                                                 ToGotoLoc, ToLabelLoc);
5526 }
5527
5528 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
5529   SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5530   SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
5531   Expr *ToTarget = Importer.Import(S->getTarget());
5532   if (!ToTarget && S->getTarget())
5533     return nullptr;
5534   return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
5535                                                         ToTarget);
5536 }
5537
5538 Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
5539   SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
5540   return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5541 }
5542
5543 Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
5544   SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
5545   return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5546 }
5547
5548 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
5549   SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
5550   Expr *ToRetExpr = Importer.Import(S->getRetValue());
5551   if (!ToRetExpr && S->getRetValue())
5552     return nullptr;
5553   VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate());
5554   VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
5555   if (!ToNRVOCandidate && NRVOCandidate)
5556     return nullptr;
5557   return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
5558                                                   ToNRVOCandidate);
5559 }
5560
5561 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
5562   SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
5563   VarDecl *ToExceptionDecl = nullptr;
5564   if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
5565     ToExceptionDecl =
5566       dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5567     if (!ToExceptionDecl)
5568       return nullptr;
5569   }
5570   Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
5571   if (!ToHandlerBlock && S->getHandlerBlock())
5572     return nullptr;
5573   return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
5574                                                     ToExceptionDecl,
5575                                                     ToHandlerBlock);
5576 }
5577
5578 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
5579   SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
5580   Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
5581   if (!ToTryBlock && S->getTryBlock())
5582     return nullptr;
5583   SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
5584   for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
5585     CXXCatchStmt *FromHandler = S->getHandler(HI);
5586     if (Stmt *ToHandler = Importer.Import(FromHandler))
5587       ToHandlers[HI] = ToHandler;
5588     else
5589       return nullptr;
5590   }
5591   return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
5592                             ToHandlers);
5593 }
5594
5595 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
5596   DeclStmt *ToRange =
5597     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
5598   if (!ToRange && S->getRangeStmt())
5599     return nullptr;
5600   DeclStmt *ToBegin =
5601     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
5602   if (!ToBegin && S->getBeginStmt())
5603     return nullptr;
5604   DeclStmt *ToEnd =
5605     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
5606   if (!ToEnd && S->getEndStmt())
5607     return nullptr;
5608   Expr *ToCond = Importer.Import(S->getCond());
5609   if (!ToCond && S->getCond())
5610     return nullptr;
5611   Expr *ToInc = Importer.Import(S->getInc());
5612   if (!ToInc && S->getInc())
5613     return nullptr;
5614   DeclStmt *ToLoopVar =
5615     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
5616   if (!ToLoopVar && S->getLoopVarStmt())
5617     return nullptr;
5618   Stmt *ToBody = Importer.Import(S->getBody());
5619   if (!ToBody && S->getBody())
5620     return nullptr;
5621   SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5622   SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
5623   SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5624   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5625   return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
5626                                                        ToCond, ToInc,
5627                                                        ToLoopVar, ToBody,
5628                                                        ToForLoc, ToCoawaitLoc,
5629                                                        ToColonLoc, ToRParenLoc);
5630 }
5631
5632 Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
5633   Stmt *ToElem = Importer.Import(S->getElement());
5634   if (!ToElem && S->getElement())
5635     return nullptr;
5636   Expr *ToCollect = Importer.Import(S->getCollection());
5637   if (!ToCollect && S->getCollection())
5638     return nullptr;
5639   Stmt *ToBody = Importer.Import(S->getBody());
5640   if (!ToBody && S->getBody())
5641     return nullptr;
5642   SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5643   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5644   return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
5645                                                              ToCollect,
5646                                                              ToBody, ToForLoc,
5647                                                              ToRParenLoc);
5648 }
5649
5650 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
5651   SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
5652   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5653   VarDecl *ToExceptionDecl = nullptr;
5654   if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
5655     ToExceptionDecl =
5656       dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5657     if (!ToExceptionDecl)
5658       return nullptr;
5659   }
5660   Stmt *ToBody = Importer.Import(S->getCatchBody());
5661   if (!ToBody && S->getCatchBody())
5662     return nullptr;
5663   return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
5664                                                        ToRParenLoc,
5665                                                        ToExceptionDecl,
5666                                                        ToBody);
5667 }
5668
5669 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
5670   SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
5671   Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
5672   if (!ToAtFinallyStmt && S->getFinallyBody())
5673     return nullptr;
5674   return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
5675                                                          ToAtFinallyStmt);
5676 }
5677
5678 Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
5679   SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
5680   Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
5681   if (!ToAtTryStmt && S->getTryBody())
5682     return nullptr;
5683   SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
5684   for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
5685     ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
5686     if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
5687       ToCatchStmts[CI] = ToCatchStmt;
5688     else
5689       return nullptr;
5690   }
5691   Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
5692   if (!ToAtFinallyStmt && S->getFinallyStmt())
5693     return nullptr;
5694   return ObjCAtTryStmt::Create(Importer.getToContext(),
5695                                ToAtTryLoc, ToAtTryStmt,
5696                                ToCatchStmts.begin(), ToCatchStmts.size(),
5697                                ToAtFinallyStmt);
5698 }
5699
5700 Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
5701   (ObjCAtSynchronizedStmt *S) {
5702   SourceLocation ToAtSynchronizedLoc =
5703     Importer.Import(S->getAtSynchronizedLoc());
5704   Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5705   if (!ToSynchExpr && S->getSynchExpr())
5706     return nullptr;
5707   Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5708   if (!ToSynchBody && S->getSynchBody())
5709     return nullptr;
5710   return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5711     ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5712 }
5713
5714 Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
5715   SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5716   Expr *ToThrow = Importer.Import(S->getThrowExpr());
5717   if (!ToThrow && S->getThrowExpr())
5718     return nullptr;
5719   return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5720 }
5721
5722 Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
5723   (ObjCAutoreleasePoolStmt *S) {
5724   SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5725   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5726   if (!ToSubStmt && S->getSubStmt())
5727     return nullptr;
5728   return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5729                                                                ToSubStmt);
5730 }
5731
5732 //----------------------------------------------------------------------------
5733 // Import Expressions
5734 //----------------------------------------------------------------------------
5735 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
5736   Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5737     << E->getStmtClassName();
5738   return nullptr;
5739 }
5740
5741 Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
5742   QualType T = Importer.Import(E->getType());
5743   if (T.isNull())
5744     return nullptr;
5745
5746   Expr *SubExpr = Importer.Import(E->getSubExpr());
5747   if (!SubExpr && E->getSubExpr())
5748     return nullptr;
5749
5750   TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
5751   if (!TInfo)
5752     return nullptr;
5753
5754   return new (Importer.getToContext()) VAArgExpr(
5755         Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
5756         Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5757 }
5758
5759
5760 Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
5761   QualType T = Importer.Import(E->getType());
5762   if (T.isNull())
5763     return nullptr;
5764
5765   return new (Importer.getToContext()) GNUNullExpr(
5766         T, Importer.Import(E->getLocStart()));
5767 }
5768
5769 Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
5770   QualType T = Importer.Import(E->getType());
5771   if (T.isNull())
5772     return nullptr;
5773
5774   StringLiteral *SL = cast_or_null<StringLiteral>(
5775         Importer.Import(E->getFunctionName()));
5776   if (!SL && E->getFunctionName())
5777     return nullptr;
5778
5779   return new (Importer.getToContext()) PredefinedExpr(
5780         Importer.Import(E->getLocStart()), T, E->getIdentType(), SL);
5781 }
5782
5783 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
5784   ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5785   if (!ToD)
5786     return nullptr;
5787
5788   NamedDecl *FoundD = nullptr;
5789   if (E->getDecl() != E->getFoundDecl()) {
5790     FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5791     if (!FoundD)
5792       return nullptr;
5793   }
5794
5795   QualType T = Importer.Import(E->getType());
5796   if (T.isNull())
5797     return nullptr;
5798
5799
5800   TemplateArgumentListInfo ToTAInfo;
5801   TemplateArgumentListInfo *ResInfo = nullptr;
5802   if (E->hasExplicitTemplateArgs()) {
5803     for (const auto &FromLoc : E->template_arguments()) {
5804       bool Error = false;
5805       TemplateArgumentLoc ToTALoc = ImportTemplateArgumentLoc(FromLoc, Error);
5806       if (Error)
5807         return nullptr;
5808       ToTAInfo.addArgument(ToTALoc);
5809     }
5810     ResInfo = &ToTAInfo;
5811   }
5812
5813   DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5814                                          Importer.Import(E->getQualifierLoc()),
5815                                    Importer.Import(E->getTemplateKeywordLoc()),
5816                                          ToD,
5817                                         E->refersToEnclosingVariableOrCapture(),
5818                                          Importer.Import(E->getLocation()),
5819                                          T, E->getValueKind(),
5820                                          FoundD, ResInfo);
5821   if (E->hadMultipleCandidates())
5822     DRE->setHadMultipleCandidates(true);
5823   return DRE;
5824 }
5825
5826 Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
5827   QualType T = Importer.Import(E->getType());
5828   if (T.isNull())
5829     return nullptr;
5830
5831   return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5832 }
5833
5834 ASTNodeImporter::Designator
5835 ASTNodeImporter::ImportDesignator(const Designator &D) {
5836   if (D.isFieldDesignator()) {
5837     IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
5838     // Caller checks for import error
5839     return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
5840                       Importer.Import(D.getFieldLoc()));
5841   }
5842   if (D.isArrayDesignator())
5843     return Designator(D.getFirstExprIndex(),
5844                       Importer.Import(D.getLBracketLoc()),
5845                       Importer.Import(D.getRBracketLoc()));
5846
5847   assert(D.isArrayRangeDesignator());
5848   return Designator(D.getFirstExprIndex(),
5849                     Importer.Import(D.getLBracketLoc()),
5850                     Importer.Import(D.getEllipsisLoc()),
5851                     Importer.Import(D.getRBracketLoc()));
5852 }
5853
5854
5855 Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
5856   Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
5857   if (!Init)
5858     return nullptr;
5859
5860   SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
5861   // List elements from the second, the first is Init itself
5862   for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
5863     if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
5864       IndexExprs[I - 1] = Arg;
5865     else
5866       return nullptr;
5867   }
5868
5869   SmallVector<Designator, 4> Designators(DIE->size());
5870   llvm::transform(DIE->designators(), Designators.begin(),
5871                   [this](const Designator &D) -> Designator {
5872                     return ImportDesignator(D);
5873                   });
5874
5875   for (const Designator &D : DIE->designators())
5876     if (D.isFieldDesignator() && !D.getFieldName())
5877       return nullptr;
5878
5879   return DesignatedInitExpr::Create(
5880         Importer.getToContext(), Designators,
5881         IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
5882         DIE->usesGNUSyntax(), Init);
5883 }
5884
5885 Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
5886   QualType T = Importer.Import(E->getType());
5887   if (T.isNull())
5888     return nullptr;
5889
5890   return new (Importer.getToContext())
5891       CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5892 }
5893
5894 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
5895   QualType T = Importer.Import(E->getType());
5896   if (T.isNull())
5897     return nullptr;
5898
5899   return IntegerLiteral::Create(Importer.getToContext(),
5900                                 E->getValue(), T,
5901                                 Importer.Import(E->getLocation()));
5902 }
5903
5904 Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
5905   QualType T = Importer.Import(E->getType());
5906   if (T.isNull())
5907     return nullptr;
5908
5909   return FloatingLiteral::Create(Importer.getToContext(),
5910                                 E->getValue(), E->isExact(), T,
5911                                 Importer.Import(E->getLocation()));
5912 }
5913
5914 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
5915   QualType T = Importer.Import(E->getType());
5916   if (T.isNull())
5917     return nullptr;
5918
5919   return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5920                                                         E->getKind(), T,
5921                                           Importer.Import(E->getLocation()));
5922 }
5923
5924 Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
5925   QualType T = Importer.Import(E->getType());
5926   if (T.isNull())
5927     return nullptr;
5928
5929   SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
5930   ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
5931
5932   return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5933                                E->getKind(), E->isPascal(), T,
5934                                Locations.data(), Locations.size());
5935 }
5936
5937 Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
5938   QualType T = Importer.Import(E->getType());
5939   if (T.isNull())
5940     return nullptr;
5941
5942   TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5943   if (!TInfo)
5944     return nullptr;
5945
5946   Expr *Init = Importer.Import(E->getInitializer());
5947   if (!Init)
5948     return nullptr;
5949
5950   return new (Importer.getToContext()) CompoundLiteralExpr(
5951         Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5952         Init, E->isFileScope());
5953 }
5954
5955 Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
5956   QualType T = Importer.Import(E->getType());
5957   if (T.isNull())
5958     return nullptr;
5959
5960   SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
5961   if (ImportArrayChecked(
5962         E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
5963         Exprs.begin()))
5964     return nullptr;
5965
5966   return new (Importer.getToContext()) AtomicExpr(
5967         Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5968         Importer.Import(E->getRParenLoc()));
5969 }
5970
5971 Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
5972   QualType T = Importer.Import(E->getType());
5973   if (T.isNull())
5974     return nullptr;
5975
5976   LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
5977   if (!ToLabel)
5978     return nullptr;
5979
5980   return new (Importer.getToContext()) AddrLabelExpr(
5981         Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5982         ToLabel, T);
5983 }
5984
5985 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
5986   Expr *SubExpr = Importer.Import(E->getSubExpr());
5987   if (!SubExpr)
5988     return nullptr;
5989
5990   return new (Importer.getToContext())
5991                                   ParenExpr(Importer.Import(E->getLParen()),
5992                                             Importer.Import(E->getRParen()),
5993                                             SubExpr);
5994 }
5995
5996 Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
5997   SmallVector<Expr *, 4> Exprs(E->getNumExprs());
5998   if (ImportContainerChecked(E->exprs(), Exprs))
5999     return nullptr;
6000
6001   return new (Importer.getToContext()) ParenListExpr(
6002         Importer.getToContext(), Importer.Import(E->getLParenLoc()),
6003         Exprs, Importer.Import(E->getLParenLoc()));
6004 }
6005
6006 Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
6007   QualType T = Importer.Import(E->getType());
6008   if (T.isNull())
6009     return nullptr;
6010
6011   CompoundStmt *ToSubStmt = cast_or_null<CompoundStmt>(
6012         Importer.Import(E->getSubStmt()));
6013   if (!ToSubStmt && E->getSubStmt())
6014     return nullptr;
6015
6016   return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
6017         Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
6018 }
6019
6020 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
6021   QualType T = Importer.Import(E->getType());
6022   if (T.isNull())
6023     return nullptr;
6024
6025   Expr *SubExpr = Importer.Import(E->getSubExpr());
6026   if (!SubExpr)
6027     return nullptr;
6028
6029   return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
6030                                                      T, E->getValueKind(),
6031                                                      E->getObjectKind(),
6032                                          Importer.Import(E->getOperatorLoc()));
6033 }
6034
6035 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
6036                                             UnaryExprOrTypeTraitExpr *E) {
6037   QualType ResultType = Importer.Import(E->getType());
6038
6039   if (E->isArgumentType()) {
6040     TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
6041     if (!TInfo)
6042       return nullptr;
6043
6044     return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
6045                                            TInfo, ResultType,
6046                                            Importer.Import(E->getOperatorLoc()),
6047                                            Importer.Import(E->getRParenLoc()));
6048   }
6049
6050   Expr *SubExpr = Importer.Import(E->getArgumentExpr());
6051   if (!SubExpr)
6052     return nullptr;
6053
6054   return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
6055                                           SubExpr, ResultType,
6056                                           Importer.Import(E->getOperatorLoc()),
6057                                           Importer.Import(E->getRParenLoc()));
6058 }
6059
6060 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
6061   QualType T = Importer.Import(E->getType());
6062   if (T.isNull())
6063     return nullptr;
6064
6065   Expr *LHS = Importer.Import(E->getLHS());
6066   if (!LHS)
6067     return nullptr;
6068
6069   Expr *RHS = Importer.Import(E->getRHS());
6070   if (!RHS)
6071     return nullptr;
6072
6073   return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
6074                                                       T, E->getValueKind(),
6075                                                       E->getObjectKind(),
6076                                            Importer.Import(E->getOperatorLoc()),
6077                                                       E->getFPFeatures());
6078 }
6079
6080 Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
6081   QualType T = Importer.Import(E->getType());
6082   if (T.isNull())
6083     return nullptr;
6084
6085   Expr *ToLHS = Importer.Import(E->getLHS());
6086   if (!ToLHS)
6087     return nullptr;
6088
6089   Expr *ToRHS = Importer.Import(E->getRHS());
6090   if (!ToRHS)
6091     return nullptr;
6092
6093   Expr *ToCond = Importer.Import(E->getCond());
6094   if (!ToCond)
6095     return nullptr;
6096
6097   return new (Importer.getToContext()) ConditionalOperator(
6098         ToCond, Importer.Import(E->getQuestionLoc()),
6099         ToLHS, Importer.Import(E->getColonLoc()),
6100         ToRHS, T, E->getValueKind(), E->getObjectKind());
6101 }
6102
6103 Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
6104     BinaryConditionalOperator *E) {
6105   QualType T = Importer.Import(E->getType());
6106   if (T.isNull())
6107     return nullptr;
6108
6109   Expr *Common = Importer.Import(E->getCommon());
6110   if (!Common)
6111     return nullptr;
6112
6113   Expr *Cond = Importer.Import(E->getCond());
6114   if (!Cond)
6115     return nullptr;
6116
6117   OpaqueValueExpr *OpaqueValue = cast_or_null<OpaqueValueExpr>(
6118         Importer.Import(E->getOpaqueValue()));
6119   if (!OpaqueValue)
6120     return nullptr;
6121
6122   Expr *TrueExpr = Importer.Import(E->getTrueExpr());
6123   if (!TrueExpr)
6124     return nullptr;
6125
6126   Expr *FalseExpr = Importer.Import(E->getFalseExpr());
6127   if (!FalseExpr)
6128     return nullptr;
6129
6130   return new (Importer.getToContext()) BinaryConditionalOperator(
6131         Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
6132         Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
6133         T, E->getValueKind(), E->getObjectKind());
6134 }
6135
6136 Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
6137   QualType T = Importer.Import(E->getType());
6138   if (T.isNull())
6139     return nullptr;
6140
6141   TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
6142   if (!ToQueried)
6143     return nullptr;
6144
6145   Expr *Dim = Importer.Import(E->getDimensionExpression());
6146   if (!Dim && E->getDimensionExpression())
6147     return nullptr;
6148
6149   return new (Importer.getToContext()) ArrayTypeTraitExpr(
6150         Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
6151         E->getValue(), Dim, Importer.Import(E->getLocEnd()), T);
6152 }
6153
6154 Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
6155   QualType T = Importer.Import(E->getType());
6156   if (T.isNull())
6157     return nullptr;
6158
6159   Expr *ToQueried = Importer.Import(E->getQueriedExpression());
6160   if (!ToQueried)
6161     return nullptr;
6162
6163   return new (Importer.getToContext()) ExpressionTraitExpr(
6164         Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
6165         E->getValue(), Importer.Import(E->getLocEnd()), T);
6166 }
6167
6168 Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
6169   QualType T = Importer.Import(E->getType());
6170   if (T.isNull())
6171     return nullptr;
6172
6173   Expr *SourceExpr = Importer.Import(E->getSourceExpr());
6174   if (!SourceExpr && E->getSourceExpr())
6175     return nullptr;
6176
6177   return new (Importer.getToContext()) OpaqueValueExpr(
6178         Importer.Import(E->getLocation()), T, E->getValueKind(),
6179         E->getObjectKind(), SourceExpr);
6180 }
6181
6182 Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
6183   QualType T = Importer.Import(E->getType());
6184   if (T.isNull())
6185     return nullptr;
6186
6187   Expr *ToLHS = Importer.Import(E->getLHS());
6188   if (!ToLHS)
6189     return nullptr;
6190
6191   Expr *ToRHS = Importer.Import(E->getRHS());
6192   if (!ToRHS)
6193     return nullptr;
6194
6195   return new (Importer.getToContext()) ArraySubscriptExpr(
6196         ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
6197         Importer.Import(E->getRBracketLoc()));
6198 }
6199
6200 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
6201   QualType T = Importer.Import(E->getType());
6202   if (T.isNull())
6203     return nullptr;
6204
6205   QualType CompLHSType = Importer.Import(E->getComputationLHSType());
6206   if (CompLHSType.isNull())
6207     return nullptr;
6208
6209   QualType CompResultType = Importer.Import(E->getComputationResultType());
6210   if (CompResultType.isNull())
6211     return nullptr;
6212
6213   Expr *LHS = Importer.Import(E->getLHS());
6214   if (!LHS)
6215     return nullptr;
6216
6217   Expr *RHS = Importer.Import(E->getRHS());
6218   if (!RHS)
6219     return nullptr;
6220
6221   return new (Importer.getToContext())
6222                         CompoundAssignOperator(LHS, RHS, E->getOpcode(),
6223                                                T, E->getValueKind(),
6224                                                E->getObjectKind(),
6225                                                CompLHSType, CompResultType,
6226                                            Importer.Import(E->getOperatorLoc()),
6227                                                E->getFPFeatures());
6228 }
6229
6230 bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) {
6231   for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
6232     if (CXXBaseSpecifier *Spec = Importer.Import(*I))
6233       Path.push_back(Spec);
6234     else
6235       return true;
6236   }
6237   return false;
6238 }
6239
6240 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
6241   QualType T = Importer.Import(E->getType());
6242   if (T.isNull())
6243     return nullptr;
6244
6245   Expr *SubExpr = Importer.Import(E->getSubExpr());
6246   if (!SubExpr)
6247     return nullptr;
6248
6249   CXXCastPath BasePath;
6250   if (ImportCastPath(E, BasePath))
6251     return nullptr;
6252
6253   return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
6254                                   SubExpr, &BasePath, E->getValueKind());
6255 }
6256
6257 Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
6258   QualType T = Importer.Import(E->getType());
6259   if (T.isNull())
6260     return nullptr;
6261
6262   Expr *SubExpr = Importer.Import(E->getSubExpr());
6263   if (!SubExpr)
6264     return nullptr;
6265
6266   TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
6267   if (!TInfo && E->getTypeInfoAsWritten())
6268     return nullptr;
6269
6270   CXXCastPath BasePath;
6271   if (ImportCastPath(E, BasePath))
6272     return nullptr;
6273
6274   switch (E->getStmtClass()) {
6275   case Stmt::CStyleCastExprClass: {
6276     CStyleCastExpr *CCE = cast<CStyleCastExpr>(E);
6277     return CStyleCastExpr::Create(Importer.getToContext(), T,
6278                                   E->getValueKind(), E->getCastKind(),
6279                                   SubExpr, &BasePath, TInfo,
6280                                   Importer.Import(CCE->getLParenLoc()),
6281                                   Importer.Import(CCE->getRParenLoc()));
6282   }
6283
6284   case Stmt::CXXFunctionalCastExprClass: {
6285     CXXFunctionalCastExpr *FCE = cast<CXXFunctionalCastExpr>(E);
6286     return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
6287                                          E->getValueKind(), TInfo,
6288                                          E->getCastKind(), SubExpr, &BasePath,
6289                                          Importer.Import(FCE->getLParenLoc()),
6290                                          Importer.Import(FCE->getRParenLoc()));
6291   }
6292
6293   case Stmt::ObjCBridgedCastExprClass: {
6294       ObjCBridgedCastExpr *OCE = cast<ObjCBridgedCastExpr>(E);
6295       return new (Importer.getToContext()) ObjCBridgedCastExpr(
6296             Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
6297             E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
6298             TInfo, SubExpr);
6299   }
6300   default:
6301     break; // just fall through
6302   }
6303
6304   CXXNamedCastExpr *Named = cast<CXXNamedCastExpr>(E);
6305   SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
6306       RParenLoc = Importer.Import(Named->getRParenLoc());
6307   SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
6308
6309   switch (E->getStmtClass()) {
6310   case Stmt::CXXStaticCastExprClass:
6311     return CXXStaticCastExpr::Create(Importer.getToContext(), T,
6312                                      E->getValueKind(), E->getCastKind(),
6313                                      SubExpr, &BasePath, TInfo,
6314                                      ExprLoc, RParenLoc, Brackets);
6315
6316   case Stmt::CXXDynamicCastExprClass:
6317     return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
6318                                       E->getValueKind(), E->getCastKind(),
6319                                       SubExpr, &BasePath, TInfo,
6320                                       ExprLoc, RParenLoc, Brackets);
6321
6322   case Stmt::CXXReinterpretCastExprClass:
6323     return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
6324                                           E->getValueKind(), E->getCastKind(),
6325                                           SubExpr, &BasePath, TInfo,
6326                                           ExprLoc, RParenLoc, Brackets);
6327
6328   case Stmt::CXXConstCastExprClass:
6329     return CXXConstCastExpr::Create(Importer.getToContext(), T,
6330                                     E->getValueKind(), SubExpr, TInfo, ExprLoc,
6331                                     RParenLoc, Brackets);
6332   default:
6333     llvm_unreachable("Cast expression of unsupported type!");
6334     return nullptr;
6335   }
6336 }
6337
6338 Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) {
6339   QualType T = Importer.Import(OE->getType());
6340   if (T.isNull())
6341     return nullptr;
6342
6343   SmallVector<OffsetOfNode, 4> Nodes;
6344   for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
6345     const OffsetOfNode &Node = OE->getComponent(I);
6346
6347     switch (Node.getKind()) {
6348     case OffsetOfNode::Array:
6349       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()),
6350                                    Node.getArrayExprIndex(),
6351                                    Importer.Import(Node.getLocEnd())));
6352       break;
6353
6354     case OffsetOfNode::Base: {
6355       CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
6356       if (!BS && Node.getBase())
6357         return nullptr;
6358       Nodes.push_back(OffsetOfNode(BS));
6359       break;
6360     }
6361     case OffsetOfNode::Field: {
6362       FieldDecl *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
6363       if (!FD)
6364         return nullptr;
6365       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
6366                                    Importer.Import(Node.getLocEnd())));
6367       break;
6368     }
6369     case OffsetOfNode::Identifier: {
6370       IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
6371       if (!ToII)
6372         return nullptr;
6373       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII,
6374                                    Importer.Import(Node.getLocEnd())));
6375       break;
6376     }
6377     }
6378   }
6379
6380   SmallVector<Expr *, 4> Exprs(OE->getNumExpressions());
6381   for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) {
6382     Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I));
6383     if (!ToIndexExpr)
6384       return nullptr;
6385     Exprs[I] = ToIndexExpr;
6386   }
6387
6388   TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo());
6389   if (!TInfo && OE->getTypeSourceInfo())
6390     return nullptr;
6391
6392   return OffsetOfExpr::Create(Importer.getToContext(), T,
6393                               Importer.Import(OE->getOperatorLoc()),
6394                               TInfo, Nodes, Exprs,
6395                               Importer.Import(OE->getRParenLoc()));
6396 }
6397
6398 Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
6399   QualType T = Importer.Import(E->getType());
6400   if (T.isNull())
6401     return nullptr;
6402
6403   Expr *Operand = Importer.Import(E->getOperand());
6404   if (!Operand)
6405     return nullptr;
6406
6407   CanThrowResult CanThrow;
6408   if (E->isValueDependent())
6409     CanThrow = CT_Dependent;
6410   else
6411     CanThrow = E->getValue() ? CT_Can : CT_Cannot;
6412
6413   return new (Importer.getToContext()) CXXNoexceptExpr(
6414         T, Operand, CanThrow,
6415         Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd()));
6416 }
6417
6418 Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
6419   QualType T = Importer.Import(E->getType());
6420   if (T.isNull())
6421     return nullptr;
6422
6423   Expr *SubExpr = Importer.Import(E->getSubExpr());
6424   if (!SubExpr && E->getSubExpr())
6425     return nullptr;
6426
6427   return new (Importer.getToContext()) CXXThrowExpr(
6428         SubExpr, T, Importer.Import(E->getThrowLoc()),
6429         E->isThrownVariableInScope());
6430 }
6431
6432 Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
6433   ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
6434         Importer.Import(E->getParam()));
6435   if (!Param)
6436     return nullptr;
6437
6438   return CXXDefaultArgExpr::Create(
6439         Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
6440 }
6441
6442 Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
6443   QualType T = Importer.Import(E->getType());
6444   if (T.isNull())
6445     return nullptr;
6446
6447   TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
6448   if (!TypeInfo)
6449     return nullptr;
6450
6451   return new (Importer.getToContext()) CXXScalarValueInitExpr(
6452         T, TypeInfo, Importer.Import(E->getRParenLoc()));
6453 }
6454
6455 Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
6456   Expr *SubExpr = Importer.Import(E->getSubExpr());
6457   if (!SubExpr)
6458     return nullptr;
6459
6460   auto *Dtor = cast_or_null<CXXDestructorDecl>(
6461         Importer.Import(const_cast<CXXDestructorDecl *>(
6462                           E->getTemporary()->getDestructor())));
6463   if (!Dtor)
6464     return nullptr;
6465
6466   ASTContext &ToCtx = Importer.getToContext();
6467   CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
6468   return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
6469 }
6470
6471 Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
6472   QualType T = Importer.Import(CE->getType());
6473   if (T.isNull())
6474     return nullptr;
6475
6476   SmallVector<Expr *, 8> Args(CE->getNumArgs());
6477   if (ImportContainerChecked(CE->arguments(), Args))
6478     return nullptr;
6479
6480   auto *Ctor = cast_or_null<CXXConstructorDecl>(
6481         Importer.Import(CE->getConstructor()));
6482   if (!Ctor)
6483     return nullptr;
6484
6485   return CXXTemporaryObjectExpr::Create(
6486         Importer.getToContext(), T,
6487         Importer.Import(CE->getLocStart()),
6488         Ctor,
6489         CE->isElidable(),
6490         Args,
6491         CE->hadMultipleCandidates(),
6492         CE->isListInitialization(),
6493         CE->isStdInitListInitialization(),
6494         CE->requiresZeroInitialization(),
6495         CE->getConstructionKind(),
6496         Importer.Import(CE->getParenOrBraceRange()));
6497 }
6498
6499 Expr *
6500 ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
6501   QualType T = Importer.Import(E->getType());
6502   if (T.isNull())
6503     return nullptr;
6504
6505   Expr *TempE = Importer.Import(E->GetTemporaryExpr());
6506   if (!TempE)
6507     return nullptr;
6508
6509   ValueDecl *ExtendedBy = cast_or_null<ValueDecl>(
6510         Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
6511   if (!ExtendedBy && E->getExtendingDecl())
6512     return nullptr;
6513
6514   auto *ToMTE =  new (Importer.getToContext()) MaterializeTemporaryExpr(
6515         T, TempE, E->isBoundToLvalueReference());
6516
6517   // FIXME: Should ManglingNumber get numbers associated with 'to' context?
6518   ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
6519   return ToMTE;
6520 }
6521
6522 Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
6523   QualType T = Importer.Import(CE->getType());
6524   if (T.isNull())
6525     return nullptr;
6526
6527   SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
6528   if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
6529     return nullptr;
6530
6531   FunctionDecl *OperatorNewDecl = cast_or_null<FunctionDecl>(
6532         Importer.Import(CE->getOperatorNew()));
6533   if (!OperatorNewDecl && CE->getOperatorNew())
6534     return nullptr;
6535
6536   FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6537         Importer.Import(CE->getOperatorDelete()));
6538   if (!OperatorDeleteDecl && CE->getOperatorDelete())
6539     return nullptr;
6540
6541   Expr *ToInit = Importer.Import(CE->getInitializer());
6542   if (!ToInit && CE->getInitializer())
6543     return nullptr;
6544
6545   TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
6546   if (!TInfo)
6547     return nullptr;
6548
6549   Expr *ToArrSize = Importer.Import(CE->getArraySize());
6550   if (!ToArrSize && CE->getArraySize())
6551     return nullptr;
6552
6553   return new (Importer.getToContext()) CXXNewExpr(
6554         Importer.getToContext(),
6555         CE->isGlobalNew(),
6556         OperatorNewDecl, OperatorDeleteDecl,
6557         CE->passAlignment(),
6558         CE->doesUsualArrayDeleteWantSize(),
6559         PlacementArgs,
6560         Importer.Import(CE->getTypeIdParens()),
6561         ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
6562         Importer.Import(CE->getSourceRange()),
6563         Importer.Import(CE->getDirectInitRange()));
6564 }
6565
6566 Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
6567   QualType T = Importer.Import(E->getType());
6568   if (T.isNull())
6569     return nullptr;
6570
6571   FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6572         Importer.Import(E->getOperatorDelete()));
6573   if (!OperatorDeleteDecl && E->getOperatorDelete())
6574     return nullptr;
6575
6576   Expr *ToArg = Importer.Import(E->getArgument());
6577   if (!ToArg && E->getArgument())
6578     return nullptr;
6579
6580   return new (Importer.getToContext()) CXXDeleteExpr(
6581         T, E->isGlobalDelete(),
6582         E->isArrayForm(),
6583         E->isArrayFormAsWritten(),
6584         E->doesUsualArrayDeleteWantSize(),
6585         OperatorDeleteDecl,
6586         ToArg,
6587         Importer.Import(E->getLocStart()));
6588 }
6589
6590 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
6591   QualType T = Importer.Import(E->getType());
6592   if (T.isNull())
6593     return nullptr;
6594
6595   CXXConstructorDecl *ToCCD =
6596     dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
6597   if (!ToCCD)
6598     return nullptr;
6599
6600   SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
6601   if (ImportContainerChecked(E->arguments(), ToArgs))
6602     return nullptr;
6603
6604   return CXXConstructExpr::Create(Importer.getToContext(), T,
6605                                   Importer.Import(E->getLocation()),
6606                                   ToCCD, E->isElidable(),
6607                                   ToArgs, E->hadMultipleCandidates(),
6608                                   E->isListInitialization(),
6609                                   E->isStdInitListInitialization(),
6610                                   E->requiresZeroInitialization(),
6611                                   E->getConstructionKind(),
6612                                   Importer.Import(E->getParenOrBraceRange()));
6613 }
6614
6615 Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) {
6616   Expr *SubExpr = Importer.Import(EWC->getSubExpr());
6617   if (!SubExpr && EWC->getSubExpr())
6618     return nullptr;
6619
6620   SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects());
6621   for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
6622     if (ExprWithCleanups::CleanupObject Obj =
6623         cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
6624       Objs[I] = Obj;
6625     else
6626       return nullptr;
6627
6628   return ExprWithCleanups::Create(Importer.getToContext(),
6629                                   SubExpr, EWC->cleanupsHaveSideEffects(),
6630                                   Objs);
6631 }
6632
6633 Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
6634   QualType T = Importer.Import(E->getType());
6635   if (T.isNull())
6636     return nullptr;
6637
6638   Expr *ToFn = Importer.Import(E->getCallee());
6639   if (!ToFn)
6640     return nullptr;
6641
6642   SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
6643   if (ImportContainerChecked(E->arguments(), ToArgs))
6644     return nullptr;
6645
6646   return new (Importer.getToContext()) CXXMemberCallExpr(
6647         Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
6648         Importer.Import(E->getRParenLoc()));
6649 }
6650
6651 Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
6652   QualType T = Importer.Import(E->getType());
6653   if (T.isNull())
6654     return nullptr;
6655
6656   return new (Importer.getToContext())
6657   CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
6658 }
6659
6660 Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
6661   QualType T = Importer.Import(E->getType());
6662   if (T.isNull())
6663     return nullptr;
6664
6665   return new (Importer.getToContext())
6666   CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
6667 }
6668
6669
6670 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
6671   QualType T = Importer.Import(E->getType());
6672   if (T.isNull())
6673     return nullptr;
6674
6675   Expr *ToBase = Importer.Import(E->getBase());
6676   if (!ToBase && E->getBase())
6677     return nullptr;
6678
6679   ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
6680   if (!ToMember && E->getMemberDecl())
6681     return nullptr;
6682
6683   DeclAccessPair ToFoundDecl = DeclAccessPair::make(
6684     dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())),
6685     E->getFoundDecl().getAccess());
6686
6687   DeclarationNameInfo ToMemberNameInfo(
6688     Importer.Import(E->getMemberNameInfo().getName()),
6689     Importer.Import(E->getMemberNameInfo().getLoc()));
6690
6691   if (E->hasExplicitTemplateArgs()) {
6692     return nullptr; // FIXME: handle template arguments
6693   }
6694
6695   return MemberExpr::Create(Importer.getToContext(), ToBase,
6696                             E->isArrow(),
6697                             Importer.Import(E->getOperatorLoc()),
6698                             Importer.Import(E->getQualifierLoc()),
6699                             Importer.Import(E->getTemplateKeywordLoc()),
6700                             ToMember, ToFoundDecl, ToMemberNameInfo,
6701                             nullptr, T, E->getValueKind(),
6702                             E->getObjectKind());
6703 }
6704
6705 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
6706   QualType T = Importer.Import(E->getType());
6707   if (T.isNull())
6708     return nullptr;
6709
6710   Expr *ToCallee = Importer.Import(E->getCallee());
6711   if (!ToCallee && E->getCallee())
6712     return nullptr;
6713
6714   unsigned NumArgs = E->getNumArgs();
6715
6716   llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
6717
6718   for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) {
6719     Expr *FromArg = E->getArg(ai);
6720     Expr *ToArg = Importer.Import(FromArg);
6721     if (!ToArg)
6722       return nullptr;
6723     ToArgs[ai] = ToArg;
6724   }
6725
6726   Expr **ToArgs_Copied = new (Importer.getToContext())
6727     Expr*[NumArgs];
6728
6729   for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
6730     ToArgs_Copied[ai] = ToArgs[ai];
6731
6732   return new (Importer.getToContext())
6733     CallExpr(Importer.getToContext(), ToCallee,
6734              llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
6735              Importer.Import(E->getRParenLoc()));
6736 }
6737
6738 Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
6739   QualType T = Importer.Import(ILE->getType());
6740   if (T.isNull())
6741     return nullptr;
6742
6743   llvm::SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
6744   if (ImportContainerChecked(ILE->inits(), Exprs))
6745     return nullptr;
6746
6747   ASTContext &ToCtx = Importer.getToContext();
6748   InitListExpr *To = new (ToCtx) InitListExpr(
6749         ToCtx, Importer.Import(ILE->getLBraceLoc()),
6750         Exprs, Importer.Import(ILE->getLBraceLoc()));
6751   To->setType(T);
6752
6753   if (ILE->hasArrayFiller()) {
6754     Expr *Filler = Importer.Import(ILE->getArrayFiller());
6755     if (!Filler)
6756       return nullptr;
6757     To->setArrayFiller(Filler);
6758   }
6759
6760   if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
6761     FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
6762     if (!ToFD)
6763       return nullptr;
6764     To->setInitializedFieldInUnion(ToFD);
6765   }
6766
6767   if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
6768     InitListExpr *ToSyntForm = cast_or_null<InitListExpr>(
6769           Importer.Import(SyntForm));
6770     if (!ToSyntForm)
6771       return nullptr;
6772     To->setSyntacticForm(ToSyntForm);
6773   }
6774
6775   To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
6776   To->setValueDependent(ILE->isValueDependent());
6777   To->setInstantiationDependent(ILE->isInstantiationDependent());
6778
6779   return To;
6780 }
6781
6782 Expr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
6783   QualType ToType = Importer.Import(E->getType());
6784   if (ToType.isNull())
6785     return nullptr;
6786
6787   Expr *ToCommon = Importer.Import(E->getCommonExpr());
6788   if (!ToCommon && E->getCommonExpr())
6789     return nullptr;
6790
6791   Expr *ToSubExpr = Importer.Import(E->getSubExpr());
6792   if (!ToSubExpr && E->getSubExpr())
6793     return nullptr;
6794
6795   return new (Importer.getToContext())
6796       ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr);
6797 }
6798
6799 Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
6800   QualType ToType = Importer.Import(E->getType());
6801   if (ToType.isNull())
6802     return nullptr;
6803   return new (Importer.getToContext()) ArrayInitIndexExpr(ToType);
6804 }
6805
6806 Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
6807   FieldDecl *ToField = llvm::dyn_cast_or_null<FieldDecl>(
6808       Importer.Import(DIE->getField()));
6809   if (!ToField && DIE->getField())
6810     return nullptr;
6811
6812   return CXXDefaultInitExpr::Create(
6813       Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField);
6814 }
6815
6816 Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
6817   QualType ToType = Importer.Import(E->getType());
6818   if (ToType.isNull() && !E->getType().isNull())
6819     return nullptr;
6820   ExprValueKind VK = E->getValueKind();
6821   CastKind CK = E->getCastKind();
6822   Expr *ToOp = Importer.Import(E->getSubExpr());
6823   if (!ToOp && E->getSubExpr())
6824     return nullptr;
6825   CXXCastPath BasePath;
6826   if (ImportCastPath(E, BasePath))
6827     return nullptr;
6828   TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten());
6829   SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc());
6830   SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc());
6831   SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets());
6832
6833   if (isa<CXXStaticCastExpr>(E)) {
6834     return CXXStaticCastExpr::Create(
6835         Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6836         ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6837   } else if (isa<CXXDynamicCastExpr>(E)) {
6838     return CXXDynamicCastExpr::Create(
6839         Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6840         ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6841   } else if (isa<CXXReinterpretCastExpr>(E)) {
6842     return CXXReinterpretCastExpr::Create(
6843         Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6844         ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6845   } else {
6846     return nullptr;
6847   }
6848 }
6849
6850
6851 Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
6852     SubstNonTypeTemplateParmExpr *E) {
6853   QualType T = Importer.Import(E->getType());
6854   if (T.isNull())
6855     return nullptr;
6856
6857   NonTypeTemplateParmDecl *Param = cast_or_null<NonTypeTemplateParmDecl>(
6858         Importer.Import(E->getParameter()));
6859   if (!Param)
6860     return nullptr;
6861
6862   Expr *Replacement = Importer.Import(E->getReplacement());
6863   if (!Replacement)
6864     return nullptr;
6865
6866   return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
6867         T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param,
6868         Replacement);
6869 }
6870
6871 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
6872                          ASTContext &FromContext, FileManager &FromFileManager,
6873                          bool MinimalImport)
6874   : ToContext(ToContext), FromContext(FromContext),
6875     ToFileManager(ToFileManager), FromFileManager(FromFileManager),
6876     Minimal(MinimalImport), LastDiagFromFrom(false)
6877 {
6878   ImportedDecls[FromContext.getTranslationUnitDecl()]
6879     = ToContext.getTranslationUnitDecl();
6880 }
6881
6882 ASTImporter::~ASTImporter() { }
6883
6884 QualType ASTImporter::Import(QualType FromT) {
6885   if (FromT.isNull())
6886     return QualType();
6887
6888   const Type *fromTy = FromT.getTypePtr();
6889
6890   // Check whether we've already imported this type.
6891   llvm::DenseMap<const Type *, const Type *>::iterator Pos
6892     = ImportedTypes.find(fromTy);
6893   if (Pos != ImportedTypes.end())
6894     return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
6895
6896   // Import the type
6897   ASTNodeImporter Importer(*this);
6898   QualType ToT = Importer.Visit(fromTy);
6899   if (ToT.isNull())
6900     return ToT;
6901
6902   // Record the imported type.
6903   ImportedTypes[fromTy] = ToT.getTypePtr();
6904
6905   return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
6906 }
6907
6908 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
6909   if (!FromTSI)
6910     return FromTSI;
6911
6912   // FIXME: For now we just create a "trivial" type source info based
6913   // on the type and a single location. Implement a real version of this.
6914   QualType T = Import(FromTSI->getType());
6915   if (T.isNull())
6916     return nullptr;
6917
6918   return ToContext.getTrivialTypeSourceInfo(T,
6919            Import(FromTSI->getTypeLoc().getLocStart()));
6920 }
6921
6922 Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) {
6923   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6924   if (Pos != ImportedDecls.end()) {
6925     Decl *ToD = Pos->second;
6926     ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
6927     return ToD;
6928   } else {
6929     return nullptr;
6930   }
6931 }
6932
6933 Decl *ASTImporter::Import(Decl *FromD) {
6934   if (!FromD)
6935     return nullptr;
6936
6937   ASTNodeImporter Importer(*this);
6938
6939   // Check whether we've already imported this declaration.
6940   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6941   if (Pos != ImportedDecls.end()) {
6942     Decl *ToD = Pos->second;
6943     Importer.ImportDefinitionIfNeeded(FromD, ToD);
6944     return ToD;
6945   }
6946
6947   // Import the type
6948   Decl *ToD = Importer.Visit(FromD);
6949   if (!ToD)
6950     return nullptr;
6951
6952   // Record the imported declaration.
6953   ImportedDecls[FromD] = ToD;
6954
6955   if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
6956     // Keep track of anonymous tags that have an associated typedef.
6957     if (FromTag->getTypedefNameForAnonDecl())
6958       AnonTagsWithPendingTypedefs.push_back(FromTag);
6959   } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
6960     // When we've finished transforming a typedef, see whether it was the
6961     // typedef for an anonymous tag.
6962     for (SmallVectorImpl<TagDecl *>::iterator
6963                FromTag = AnonTagsWithPendingTypedefs.begin(),
6964             FromTagEnd = AnonTagsWithPendingTypedefs.end();
6965          FromTag != FromTagEnd; ++FromTag) {
6966       if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
6967         if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
6968           // We found the typedef for an anonymous tag; link them.
6969           ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
6970           AnonTagsWithPendingTypedefs.erase(FromTag);
6971           break;
6972         }
6973       }
6974     }
6975   }
6976
6977   return ToD;
6978 }
6979
6980 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
6981   if (!FromDC)
6982     return FromDC;
6983
6984   DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
6985   if (!ToDC)
6986     return nullptr;
6987
6988   // When we're using a record/enum/Objective-C class/protocol as a context, we
6989   // need it to have a definition.
6990   if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
6991     RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
6992     if (ToRecord->isCompleteDefinition()) {
6993       // Do nothing.
6994     } else if (FromRecord->isCompleteDefinition()) {
6995       ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
6996                                               ASTNodeImporter::IDK_Basic);
6997     } else {
6998       CompleteDecl(ToRecord);
6999     }
7000   } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
7001     EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
7002     if (ToEnum->isCompleteDefinition()) {
7003       // Do nothing.
7004     } else if (FromEnum->isCompleteDefinition()) {
7005       ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
7006                                               ASTNodeImporter::IDK_Basic);
7007     } else {
7008       CompleteDecl(ToEnum);
7009     }
7010   } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
7011     ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
7012     if (ToClass->getDefinition()) {
7013       // Do nothing.
7014     } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
7015       ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
7016                                               ASTNodeImporter::IDK_Basic);
7017     } else {
7018       CompleteDecl(ToClass);
7019     }
7020   } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
7021     ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
7022     if (ToProto->getDefinition()) {
7023       // Do nothing.
7024     } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
7025       ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
7026                                               ASTNodeImporter::IDK_Basic);
7027     } else {
7028       CompleteDecl(ToProto);
7029     }
7030   }
7031
7032   return ToDC;
7033 }
7034
7035 Expr *ASTImporter::Import(Expr *FromE) {
7036   if (!FromE)
7037     return nullptr;
7038
7039   return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
7040 }
7041
7042 Stmt *ASTImporter::Import(Stmt *FromS) {
7043   if (!FromS)
7044     return nullptr;
7045
7046   // Check whether we've already imported this declaration.
7047   llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
7048   if (Pos != ImportedStmts.end())
7049     return Pos->second;
7050
7051   // Import the type
7052   ASTNodeImporter Importer(*this);
7053   Stmt *ToS = Importer.Visit(FromS);
7054   if (!ToS)
7055     return nullptr;
7056
7057   // Record the imported declaration.
7058   ImportedStmts[FromS] = ToS;
7059   return ToS;
7060 }
7061
7062 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
7063   if (!FromNNS)
7064     return nullptr;
7065
7066   NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
7067
7068   switch (FromNNS->getKind()) {
7069   case NestedNameSpecifier::Identifier:
7070     if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
7071       return NestedNameSpecifier::Create(ToContext, prefix, II);
7072     }
7073     return nullptr;
7074
7075   case NestedNameSpecifier::Namespace:
7076     if (NamespaceDecl *NS =
7077           cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
7078       return NestedNameSpecifier::Create(ToContext, prefix, NS);
7079     }
7080     return nullptr;
7081
7082   case NestedNameSpecifier::NamespaceAlias:
7083     if (NamespaceAliasDecl *NSAD =
7084           cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
7085       return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
7086     }
7087     return nullptr;
7088
7089   case NestedNameSpecifier::Global:
7090     return NestedNameSpecifier::GlobalSpecifier(ToContext);
7091
7092   case NestedNameSpecifier::Super:
7093     if (CXXRecordDecl *RD =
7094             cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
7095       return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
7096     }
7097     return nullptr;
7098
7099   case NestedNameSpecifier::TypeSpec:
7100   case NestedNameSpecifier::TypeSpecWithTemplate: {
7101       QualType T = Import(QualType(FromNNS->getAsType(), 0u));
7102       if (!T.isNull()) {
7103         bool bTemplate = FromNNS->getKind() ==
7104                          NestedNameSpecifier::TypeSpecWithTemplate;
7105         return NestedNameSpecifier::Create(ToContext, prefix,
7106                                            bTemplate, T.getTypePtr());
7107       }
7108     }
7109       return nullptr;
7110   }
7111
7112   llvm_unreachable("Invalid nested name specifier kind");
7113 }
7114
7115 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
7116   // Copied from NestedNameSpecifier mostly.
7117   SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
7118   NestedNameSpecifierLoc NNS = FromNNS;
7119
7120   // Push each of the nested-name-specifiers's onto a stack for
7121   // serialization in reverse order.
7122   while (NNS) {
7123     NestedNames.push_back(NNS);
7124     NNS = NNS.getPrefix();
7125   }
7126
7127   NestedNameSpecifierLocBuilder Builder;
7128
7129   while (!NestedNames.empty()) {
7130     NNS = NestedNames.pop_back_val();
7131     NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier());
7132     if (!Spec)
7133       return NestedNameSpecifierLoc();
7134
7135     NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
7136     switch (Kind) {
7137     case NestedNameSpecifier::Identifier:
7138       Builder.Extend(getToContext(),
7139                      Spec->getAsIdentifier(),
7140                      Import(NNS.getLocalBeginLoc()),
7141                      Import(NNS.getLocalEndLoc()));
7142       break;
7143
7144     case NestedNameSpecifier::Namespace:
7145       Builder.Extend(getToContext(),
7146                      Spec->getAsNamespace(),
7147                      Import(NNS.getLocalBeginLoc()),
7148                      Import(NNS.getLocalEndLoc()));
7149       break;
7150
7151     case NestedNameSpecifier::NamespaceAlias:
7152       Builder.Extend(getToContext(),
7153                      Spec->getAsNamespaceAlias(),
7154                      Import(NNS.getLocalBeginLoc()),
7155                      Import(NNS.getLocalEndLoc()));
7156       break;
7157
7158     case NestedNameSpecifier::TypeSpec:
7159     case NestedNameSpecifier::TypeSpecWithTemplate: {
7160       TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
7161             QualType(Spec->getAsType(), 0));
7162       Builder.Extend(getToContext(),
7163                      Import(NNS.getLocalBeginLoc()),
7164                      TSI->getTypeLoc(),
7165                      Import(NNS.getLocalEndLoc()));
7166       break;
7167     }
7168
7169     case NestedNameSpecifier::Global:
7170       Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc()));
7171       break;
7172
7173     case NestedNameSpecifier::Super: {
7174       SourceRange ToRange = Import(NNS.getSourceRange());
7175       Builder.MakeSuper(getToContext(),
7176                         Spec->getAsRecordDecl(),
7177                         ToRange.getBegin(),
7178                         ToRange.getEnd());
7179     }
7180   }
7181   }
7182
7183   return Builder.getWithLocInContext(getToContext());
7184 }
7185
7186 TemplateName ASTImporter::Import(TemplateName From) {
7187   switch (From.getKind()) {
7188   case TemplateName::Template:
7189     if (TemplateDecl *ToTemplate
7190                 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7191       return TemplateName(ToTemplate);
7192
7193     return TemplateName();
7194
7195   case TemplateName::OverloadedTemplate: {
7196     OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
7197     UnresolvedSet<2> ToTemplates;
7198     for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
7199                                              E = FromStorage->end();
7200          I != E; ++I) {
7201       if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
7202         ToTemplates.addDecl(To);
7203       else
7204         return TemplateName();
7205     }
7206     return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
7207                                                ToTemplates.end());
7208   }
7209
7210   case TemplateName::QualifiedTemplate: {
7211     QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
7212     NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
7213     if (!Qualifier)
7214       return TemplateName();
7215
7216     if (TemplateDecl *ToTemplate
7217         = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7218       return ToContext.getQualifiedTemplateName(Qualifier,
7219                                                 QTN->hasTemplateKeyword(),
7220                                                 ToTemplate);
7221
7222     return TemplateName();
7223   }
7224
7225   case TemplateName::DependentTemplate: {
7226     DependentTemplateName *DTN = From.getAsDependentTemplateName();
7227     NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
7228     if (!Qualifier)
7229       return TemplateName();
7230
7231     if (DTN->isIdentifier()) {
7232       return ToContext.getDependentTemplateName(Qualifier,
7233                                                 Import(DTN->getIdentifier()));
7234     }
7235
7236     return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
7237   }
7238
7239   case TemplateName::SubstTemplateTemplateParm: {
7240     SubstTemplateTemplateParmStorage *subst
7241       = From.getAsSubstTemplateTemplateParm();
7242     TemplateTemplateParmDecl *param
7243       = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
7244     if (!param)
7245       return TemplateName();
7246
7247     TemplateName replacement = Import(subst->getReplacement());
7248     if (replacement.isNull()) return TemplateName();
7249
7250     return ToContext.getSubstTemplateTemplateParm(param, replacement);
7251   }
7252
7253   case TemplateName::SubstTemplateTemplateParmPack: {
7254     SubstTemplateTemplateParmPackStorage *SubstPack
7255       = From.getAsSubstTemplateTemplateParmPack();
7256     TemplateTemplateParmDecl *Param
7257       = cast_or_null<TemplateTemplateParmDecl>(
7258                                         Import(SubstPack->getParameterPack()));
7259     if (!Param)
7260       return TemplateName();
7261
7262     ASTNodeImporter Importer(*this);
7263     TemplateArgument ArgPack
7264       = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
7265     if (ArgPack.isNull())
7266       return TemplateName();
7267
7268     return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
7269   }
7270   }
7271
7272   llvm_unreachable("Invalid template name kind");
7273 }
7274
7275 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
7276   if (FromLoc.isInvalid())
7277     return SourceLocation();
7278
7279   SourceManager &FromSM = FromContext.getSourceManager();
7280
7281   // For now, map everything down to its file location, so that we
7282   // don't have to import macro expansions.
7283   // FIXME: Import macro expansions!
7284   FromLoc = FromSM.getFileLoc(FromLoc);
7285   std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
7286   SourceManager &ToSM = ToContext.getSourceManager();
7287   FileID ToFileID = Import(Decomposed.first);
7288   if (ToFileID.isInvalid())
7289     return SourceLocation();
7290   SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID)
7291                            .getLocWithOffset(Decomposed.second);
7292   return ret;
7293 }
7294
7295 SourceRange ASTImporter::Import(SourceRange FromRange) {
7296   return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
7297 }
7298
7299 FileID ASTImporter::Import(FileID FromID) {
7300   llvm::DenseMap<FileID, FileID>::iterator Pos
7301     = ImportedFileIDs.find(FromID);
7302   if (Pos != ImportedFileIDs.end())
7303     return Pos->second;
7304
7305   SourceManager &FromSM = FromContext.getSourceManager();
7306   SourceManager &ToSM = ToContext.getSourceManager();
7307   const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
7308   assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
7309
7310   // Include location of this file.
7311   SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
7312
7313   // Map the FileID for to the "to" source manager.
7314   FileID ToID;
7315   const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
7316   if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
7317     // FIXME: We probably want to use getVirtualFile(), so we don't hit the
7318     // disk again
7319     // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
7320     // than mmap the files several times.
7321     const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
7322     if (!Entry)
7323       return FileID();
7324     ToID = ToSM.createFileID(Entry, ToIncludeLoc,
7325                              FromSLoc.getFile().getFileCharacteristic());
7326   } else {
7327     // FIXME: We want to re-use the existing MemoryBuffer!
7328     const llvm::MemoryBuffer *
7329         FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
7330     std::unique_ptr<llvm::MemoryBuffer> ToBuf
7331       = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
7332                                              FromBuf->getBufferIdentifier());
7333     ToID = ToSM.createFileID(std::move(ToBuf),
7334                              FromSLoc.getFile().getFileCharacteristic());
7335   }
7336
7337
7338   ImportedFileIDs[FromID] = ToID;
7339   return ToID;
7340 }
7341
7342 CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
7343   Expr *ToExpr = Import(From->getInit());
7344   if (!ToExpr && From->getInit())
7345     return nullptr;
7346
7347   if (From->isBaseInitializer()) {
7348     TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7349     if (!ToTInfo && From->getTypeSourceInfo())
7350       return nullptr;
7351
7352     return new (ToContext) CXXCtorInitializer(
7353         ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
7354         ToExpr, Import(From->getRParenLoc()),
7355         From->isPackExpansion() ? Import(From->getEllipsisLoc())
7356                                 : SourceLocation());
7357   } else if (From->isMemberInitializer()) {
7358     FieldDecl *ToField =
7359         llvm::cast_or_null<FieldDecl>(Import(From->getMember()));
7360     if (!ToField && From->getMember())
7361       return nullptr;
7362
7363     return new (ToContext) CXXCtorInitializer(
7364         ToContext, ToField, Import(From->getMemberLocation()),
7365         Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7366   } else if (From->isIndirectMemberInitializer()) {
7367     IndirectFieldDecl *ToIField = llvm::cast_or_null<IndirectFieldDecl>(
7368         Import(From->getIndirectMember()));
7369     if (!ToIField && From->getIndirectMember())
7370       return nullptr;
7371
7372     return new (ToContext) CXXCtorInitializer(
7373         ToContext, ToIField, Import(From->getMemberLocation()),
7374         Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7375   } else if (From->isDelegatingInitializer()) {
7376     TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7377     if (!ToTInfo && From->getTypeSourceInfo())
7378       return nullptr;
7379
7380     return new (ToContext)
7381         CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
7382                            ToExpr, Import(From->getRParenLoc()));
7383   } else {
7384     return nullptr;
7385   }
7386 }
7387
7388
7389 CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
7390   auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
7391   if (Pos != ImportedCXXBaseSpecifiers.end())
7392     return Pos->second;
7393
7394   CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
7395         Import(BaseSpec->getSourceRange()),
7396         BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
7397         BaseSpec->getAccessSpecifierAsWritten(),
7398         Import(BaseSpec->getTypeSourceInfo()),
7399         Import(BaseSpec->getEllipsisLoc()));
7400   ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
7401   return Imported;
7402 }
7403
7404 void ASTImporter::ImportDefinition(Decl *From) {
7405   Decl *To = Import(From);
7406   if (!To)
7407     return;
7408
7409   if (DeclContext *FromDC = cast<DeclContext>(From)) {
7410     ASTNodeImporter Importer(*this);
7411
7412     if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
7413       if (!ToRecord->getDefinition()) {
7414         Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
7415                                   ASTNodeImporter::IDK_Everything);
7416         return;
7417       }
7418     }
7419
7420     if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
7421       if (!ToEnum->getDefinition()) {
7422         Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
7423                                   ASTNodeImporter::IDK_Everything);
7424         return;
7425       }
7426     }
7427
7428     if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
7429       if (!ToIFace->getDefinition()) {
7430         Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
7431                                   ASTNodeImporter::IDK_Everything);
7432         return;
7433       }
7434     }
7435
7436     if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
7437       if (!ToProto->getDefinition()) {
7438         Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
7439                                   ASTNodeImporter::IDK_Everything);
7440         return;
7441       }
7442     }
7443
7444     Importer.ImportDeclContext(FromDC, true);
7445   }
7446 }
7447
7448 DeclarationName ASTImporter::Import(DeclarationName FromName) {
7449   if (!FromName)
7450     return DeclarationName();
7451
7452   switch (FromName.getNameKind()) {
7453   case DeclarationName::Identifier:
7454     return Import(FromName.getAsIdentifierInfo());
7455
7456   case DeclarationName::ObjCZeroArgSelector:
7457   case DeclarationName::ObjCOneArgSelector:
7458   case DeclarationName::ObjCMultiArgSelector:
7459     return Import(FromName.getObjCSelector());
7460
7461   case DeclarationName::CXXConstructorName: {
7462     QualType T = Import(FromName.getCXXNameType());
7463     if (T.isNull())
7464       return DeclarationName();
7465
7466     return ToContext.DeclarationNames.getCXXConstructorName(
7467                                                ToContext.getCanonicalType(T));
7468   }
7469
7470   case DeclarationName::CXXDestructorName: {
7471     QualType T = Import(FromName.getCXXNameType());
7472     if (T.isNull())
7473       return DeclarationName();
7474
7475     return ToContext.DeclarationNames.getCXXDestructorName(
7476                                                ToContext.getCanonicalType(T));
7477   }
7478
7479   case DeclarationName::CXXDeductionGuideName: {
7480     TemplateDecl *Template = cast_or_null<TemplateDecl>(
7481         Import(FromName.getCXXDeductionGuideTemplate()));
7482     if (!Template)
7483       return DeclarationName();
7484     return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
7485   }
7486
7487   case DeclarationName::CXXConversionFunctionName: {
7488     QualType T = Import(FromName.getCXXNameType());
7489     if (T.isNull())
7490       return DeclarationName();
7491
7492     return ToContext.DeclarationNames.getCXXConversionFunctionName(
7493                                                ToContext.getCanonicalType(T));
7494   }
7495
7496   case DeclarationName::CXXOperatorName:
7497     return ToContext.DeclarationNames.getCXXOperatorName(
7498                                           FromName.getCXXOverloadedOperator());
7499
7500   case DeclarationName::CXXLiteralOperatorName:
7501     return ToContext.DeclarationNames.getCXXLiteralOperatorName(
7502                                    Import(FromName.getCXXLiteralIdentifier()));
7503
7504   case DeclarationName::CXXUsingDirective:
7505     // FIXME: STATICS!
7506     return DeclarationName::getUsingDirectiveName();
7507   }
7508
7509   llvm_unreachable("Invalid DeclarationName Kind!");
7510 }
7511
7512 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
7513   if (!FromId)
7514     return nullptr;
7515
7516   IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
7517
7518   if (!ToId->getBuiltinID() && FromId->getBuiltinID())
7519     ToId->setBuiltinID(FromId->getBuiltinID());
7520
7521   return ToId;
7522 }
7523
7524 Selector ASTImporter::Import(Selector FromSel) {
7525   if (FromSel.isNull())
7526     return Selector();
7527
7528   SmallVector<IdentifierInfo *, 4> Idents;
7529   Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
7530   for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
7531     Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
7532   return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
7533 }
7534
7535 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
7536                                                 DeclContext *DC,
7537                                                 unsigned IDNS,
7538                                                 NamedDecl **Decls,
7539                                                 unsigned NumDecls) {
7540   return Name;
7541 }
7542
7543 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
7544   if (LastDiagFromFrom)
7545     ToContext.getDiagnostics().notePriorDiagnosticFrom(
7546       FromContext.getDiagnostics());
7547   LastDiagFromFrom = false;
7548   return ToContext.getDiagnostics().Report(Loc, DiagID);
7549 }
7550
7551 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
7552   if (!LastDiagFromFrom)
7553     FromContext.getDiagnostics().notePriorDiagnosticFrom(
7554       ToContext.getDiagnostics());
7555   LastDiagFromFrom = true;
7556   return FromContext.getDiagnostics().Report(Loc, DiagID);
7557 }
7558
7559 void ASTImporter::CompleteDecl (Decl *D) {
7560   if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
7561     if (!ID->getDefinition())
7562       ID->startDefinition();
7563   }
7564   else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
7565     if (!PD->getDefinition())
7566       PD->startDefinition();
7567   }
7568   else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
7569     if (!TD->getDefinition() && !TD->isBeingDefined()) {
7570       TD->startDefinition();
7571       TD->setCompleteDefinition(true);
7572     }
7573   }
7574   else {
7575     assert (0 && "CompleteDecl called on a Decl that can't be completed");
7576   }
7577 }
7578
7579 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
7580   if (From->hasAttrs()) {
7581     for (Attr *FromAttr : From->getAttrs())
7582       To->addAttr(FromAttr->clone(To->getASTContext()));
7583   }
7584   if (From->isUsed()) {
7585     To->setIsUsed();
7586   }
7587   if (From->isImplicit()) {
7588     To->setImplicit();
7589   }
7590   ImportedDecls[From] = To;
7591   return To;
7592 }
7593
7594 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
7595                                            bool Complain) {
7596   llvm::DenseMap<const Type *, const Type *>::iterator Pos
7597    = ImportedTypes.find(From.getTypePtr());
7598   if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
7599     return true;
7600
7601   StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
7602                                    false, Complain);
7603   return Ctx.IsStructurallyEquivalent(From, To);
7604 }