contrib/llvm/tools/clang/lib/Serialization/ASTReaderDecl.cpp

   1 //===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- 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 implements the ASTReader::ReadDeclRecord method, which is the
  11 // entrypoint for loading a decl.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Serialization/ASTReader.h"
  16 #include "ASTCommon.h"
  17 #include "ASTReaderInternals.h"
  18 #include "clang/AST/ASTConsumer.h"
  19 #include "clang/AST/ASTContext.h"
  20 #include "clang/AST/DeclCXX.h"
  21 #include "clang/AST/DeclGroup.h"
  22 #include "clang/AST/DeclTemplate.h"
  23 #include "clang/AST/DeclVisitor.h"
  24 #include "clang/AST/Expr.h"
  25 #include "clang/Sema/IdentifierResolver.h"
  26 #include "clang/Sema/Sema.h"
  27 #include "clang/Sema/SemaDiagnostic.h"
  28 #include "llvm/Support/SaveAndRestore.h"
  29 using namespace clang;
  30 using namespace clang::serialization;
  31
  32 //===----------------------------------------------------------------------===//
  33 // Declaration deserialization
  34 //===----------------------------------------------------------------------===//
  35
  36 namespace clang {
  37   class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
  38     ASTReader &Reader;
  39     ModuleFile &F;
  40     const DeclID ThisDeclID;
  41     const unsigned RawLocation;
  42     typedef ASTReader::RecordData RecordData;
  43     const RecordData &Record;
  44     unsigned &Idx;
  45     TypeID TypeIDForTypeDecl;
  46     unsigned AnonymousDeclNumber;
  47     GlobalDeclID NamedDeclForTagDecl;
  48     IdentifierInfo *TypedefNameForLinkage;
  49
  50     bool HasPendingBody;
  51
  52     uint64_t GetCurrentCursorOffset();
  53
  54     SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
  55       return Reader.ReadSourceLocation(F, R, I);
  56     }
  57
  58     SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
  59       return Reader.ReadSourceRange(F, R, I);
  60     }
  61
  62     TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
  63       return Reader.GetTypeSourceInfo(F, R, I);
  64     }
  65
  66     serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
  67       return Reader.ReadDeclID(F, R, I);
  68     }
  69
  70     Decl *ReadDecl(const RecordData &R, unsigned &I) {
  71       return Reader.ReadDecl(F, R, I);
  72     }
  73
  74     template<typename T>
  75     T *ReadDeclAs(const RecordData &R, unsigned &I) {
  76       return Reader.ReadDeclAs<T>(F, R, I);
  77     }
  78
  79     void ReadQualifierInfo(QualifierInfo &Info,
  80                            const RecordData &R, unsigned &I) {
  81       Reader.ReadQualifierInfo(F, Info, R, I);
  82     }
  83
  84     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
  85                                 const RecordData &R, unsigned &I) {
  86       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
  87     }
  88
  89     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
  90                                 const RecordData &R, unsigned &I) {
  91       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
  92     }
  93
  94     serialization::SubmoduleID readSubmoduleID(const RecordData &R,
  95                                                unsigned &I) {
  96       if (I >= R.size())
  97         return 0;
  98
  99       return Reader.getGlobalSubmoduleID(F, R[I++]);
 100     }
 101
 102     Module *readModule(const RecordData &R, unsigned &I) {
 103       return Reader.getSubmodule(readSubmoduleID(R, I));
 104     }
 105
 106     void ReadCXXRecordDefinition(CXXRecordDecl *D);
 107     void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
 108                                const RecordData &R, unsigned &I);
 109     void MergeDefinitionData(CXXRecordDecl *D,
 110                              struct CXXRecordDecl::DefinitionData &NewDD);
 111
 112     static NamedDecl *getAnonymousDeclForMerging(ASTReader &Reader,
 113                                                  DeclContext *DC,
 114                                                  unsigned Index);
 115     static void setAnonymousDeclForMerging(ASTReader &Reader, DeclContext *DC,
 116                                            unsigned Index, NamedDecl *D);
 117
 118     /// \brief RAII class used to capture the first ID within a redeclaration
 119     /// chain and to introduce it into the list of pending redeclaration chains
 120     /// on destruction.
 121     ///
 122     /// The caller can choose not to introduce this ID into the list of pending
 123     /// redeclaration chains by calling \c suppress().
 124     class RedeclarableResult {
 125       ASTReader &Reader;
 126       GlobalDeclID FirstID;
 127       mutable bool Owning;
 128       Decl::Kind DeclKind;
 129
 130       void operator=(RedeclarableResult &) LLVM_DELETED_FUNCTION;
 131
 132     public:
 133       RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID,
 134                          Decl::Kind DeclKind)
 135         : Reader(Reader), FirstID(FirstID), Owning(true), DeclKind(DeclKind) { }
 136
 137       RedeclarableResult(const RedeclarableResult &Other)
 138         : Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning) ,
 139           DeclKind(Other.DeclKind)
 140       {
 141         Other.Owning = false;
 142       }
 143
 144       ~RedeclarableResult() {
 145         if (FirstID && Owning && isRedeclarableDeclKind(DeclKind) &&
 146             Reader.PendingDeclChainsKnown.insert(FirstID).second)
 147           Reader.PendingDeclChains.push_back(FirstID);
 148       }
 149
 150       /// \brief Retrieve the first ID.
 151       GlobalDeclID getFirstID() const { return FirstID; }
 152
 153       /// \brief Do not introduce this declaration ID into the set of pending
 154       /// declaration chains.
 155       void suppress() {
 156         Owning = false;
 157       }
 158     };
 159
 160     /// \brief Class used to capture the result of searching for an existing
 161     /// declaration of a specific kind and name, along with the ability
 162     /// to update the place where this result was found (the declaration
 163     /// chain hanging off an identifier or the DeclContext we searched in)
 164     /// if requested.
 165     class FindExistingResult {
 166       ASTReader &Reader;
 167       NamedDecl *New;
 168       NamedDecl *Existing;
 169       mutable bool AddResult;
 170
 171       unsigned AnonymousDeclNumber;
 172       IdentifierInfo *TypedefNameForLinkage;
 173
 174       void operator=(FindExistingResult&) LLVM_DELETED_FUNCTION;
 175
 176     public:
 177       FindExistingResult(ASTReader &Reader)
 178           : Reader(Reader), New(nullptr), Existing(nullptr), AddResult(false),
 179             AnonymousDeclNumber(0), TypedefNameForLinkage(0) {}
 180
 181       FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing,
 182                          unsigned AnonymousDeclNumber,
 183                          IdentifierInfo *TypedefNameForLinkage)
 184           : Reader(Reader), New(New), Existing(Existing), AddResult(true),
 185             AnonymousDeclNumber(AnonymousDeclNumber),
 186             TypedefNameForLinkage(TypedefNameForLinkage) {}
 187
 188       FindExistingResult(const FindExistingResult &Other)
 189           : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
 190             AddResult(Other.AddResult),
 191             AnonymousDeclNumber(Other.AnonymousDeclNumber),
 192             TypedefNameForLinkage(Other.TypedefNameForLinkage) {
 193         Other.AddResult = false;
 194       }
 195
 196       ~FindExistingResult();
 197
 198       /// \brief Suppress the addition of this result into the known set of
 199       /// names.
 200       void suppress() { AddResult = false; }
 201
 202       operator NamedDecl*() const { return Existing; }
 203
 204       template<typename T>
 205       operator T*() const { return dyn_cast_or_null<T>(Existing); }
 206     };
 207
 208     FindExistingResult findExisting(NamedDecl *D);
 209
 210   public:
 211     ASTDeclReader(ASTReader &Reader, ModuleFile &F, DeclID thisDeclID,
 212                   unsigned RawLocation, const RecordData &Record, unsigned &Idx)
 213         : Reader(Reader), F(F), ThisDeclID(thisDeclID),
 214           RawLocation(RawLocation), Record(Record), Idx(Idx),
 215           TypeIDForTypeDecl(0), NamedDeclForTagDecl(0),
 216           TypedefNameForLinkage(nullptr), HasPendingBody(false) {}
 217
 218     template <typename DeclT>
 219     static void attachPreviousDeclImpl(ASTReader &Reader,
 220                                        Redeclarable<DeclT> *D, Decl *Previous);
 221     static void attachPreviousDeclImpl(ASTReader &Reader, ...);
 222     static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous);
 223
 224     template <typename DeclT>
 225     static void attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest);
 226     static void attachLatestDeclImpl(...);
 227     static void attachLatestDecl(Decl *D, Decl *latest);
 228
 229     template <typename DeclT>
 230     static void markIncompleteDeclChainImpl(Redeclarable<DeclT> *D);
 231     static void markIncompleteDeclChainImpl(...);
 232
 233     /// \brief Determine whether this declaration has a pending body.
 234     bool hasPendingBody() const { return HasPendingBody; }
 235
 236     void Visit(Decl *D);
 237
 238     void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
 239                     const RecordData &Record);
 240
 241     static void setNextObjCCategory(ObjCCategoryDecl *Cat,
 242                                     ObjCCategoryDecl *Next) {
 243       Cat->NextClassCategory = Next;
 244     }
 245
 246     void VisitDecl(Decl *D);
 247     void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
 248     void VisitNamedDecl(NamedDecl *ND);
 249     void VisitLabelDecl(LabelDecl *LD);
 250     void VisitNamespaceDecl(NamespaceDecl *D);
 251     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
 252     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
 253     void VisitTypeDecl(TypeDecl *TD);
 254     RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD);
 255     void VisitTypedefDecl(TypedefDecl *TD);
 256     void VisitTypeAliasDecl(TypeAliasDecl *TD);
 257     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
 258     RedeclarableResult VisitTagDecl(TagDecl *TD);
 259     void VisitEnumDecl(EnumDecl *ED);
 260     RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);
 261     void VisitRecordDecl(RecordDecl *RD) { VisitRecordDeclImpl(RD); }
 262     RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
 263     void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
 264     RedeclarableResult VisitClassTemplateSpecializationDeclImpl(
 265                                             ClassTemplateSpecializationDecl *D);
 266     void VisitClassTemplateSpecializationDecl(
 267         ClassTemplateSpecializationDecl *D) {
 268       VisitClassTemplateSpecializationDeclImpl(D);
 269     }
 270     void VisitClassTemplatePartialSpecializationDecl(
 271                                      ClassTemplatePartialSpecializationDecl *D);
 272     void VisitClassScopeFunctionSpecializationDecl(
 273                                        ClassScopeFunctionSpecializationDecl *D);
 274     RedeclarableResult
 275     VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);
 276     void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {
 277       VisitVarTemplateSpecializationDeclImpl(D);
 278     }
 279     void VisitVarTemplatePartialSpecializationDecl(
 280         VarTemplatePartialSpecializationDecl *D);
 281     void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
 282     void VisitValueDecl(ValueDecl *VD);
 283     void VisitEnumConstantDecl(EnumConstantDecl *ECD);
 284     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
 285     void VisitDeclaratorDecl(DeclaratorDecl *DD);
 286     void VisitFunctionDecl(FunctionDecl *FD);
 287     void VisitCXXMethodDecl(CXXMethodDecl *D);
 288     void VisitCXXConstructorDecl(CXXConstructorDecl *D);
 289     void VisitCXXDestructorDecl(CXXDestructorDecl *D);
 290     void VisitCXXConversionDecl(CXXConversionDecl *D);
 291     void VisitFieldDecl(FieldDecl *FD);
 292     void VisitMSPropertyDecl(MSPropertyDecl *FD);
 293     void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
 294     RedeclarableResult VisitVarDeclImpl(VarDecl *D);
 295     void VisitVarDecl(VarDecl *VD) { VisitVarDeclImpl(VD); }
 296     void VisitImplicitParamDecl(ImplicitParamDecl *PD);
 297     void VisitParmVarDecl(ParmVarDecl *PD);
 298     void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
 299     DeclID VisitTemplateDecl(TemplateDecl *D);
 300     RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
 301     void VisitClassTemplateDecl(ClassTemplateDecl *D);
 302     void VisitVarTemplateDecl(VarTemplateDecl *D);
 303     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
 304     void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
 305     void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
 306     void VisitUsingDecl(UsingDecl *D);
 307     void VisitUsingShadowDecl(UsingShadowDecl *D);
 308     void VisitLinkageSpecDecl(LinkageSpecDecl *D);
 309     void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
 310     void VisitImportDecl(ImportDecl *D);
 311     void VisitAccessSpecDecl(AccessSpecDecl *D);
 312     void VisitFriendDecl(FriendDecl *D);
 313     void VisitFriendTemplateDecl(FriendTemplateDecl *D);
 314     void VisitStaticAssertDecl(StaticAssertDecl *D);
 315     void VisitBlockDecl(BlockDecl *BD);
 316     void VisitCapturedDecl(CapturedDecl *CD);
 317     void VisitEmptyDecl(EmptyDecl *D);
 318
 319     std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
 320
 321     template<typename T>
 322     RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
 323
 324     template<typename T>
 325     void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl,
 326                            DeclID TemplatePatternID = 0);
 327
 328     template<typename T>
 329     void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
 330                            RedeclarableResult &Redecl,
 331                            DeclID TemplatePatternID = 0);
 332
 333     template<typename T>
 334     void mergeMergeable(Mergeable<T> *D);
 335
 336     void mergeTemplatePattern(RedeclarableTemplateDecl *D,
 337                               RedeclarableTemplateDecl *Existing,
 338                               DeclID DsID);
 339
 340     // FIXME: Reorder according to DeclNodes.td?
 341     void VisitObjCMethodDecl(ObjCMethodDecl *D);
 342     void VisitObjCContainerDecl(ObjCContainerDecl *D);
 343     void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
 344     void VisitObjCIvarDecl(ObjCIvarDecl *D);
 345     void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
 346     void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
 347     void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
 348     void VisitObjCImplDecl(ObjCImplDecl *D);
 349     void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
 350     void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
 351     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
 352     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
 353     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
 354     void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
 355   };
 356 }
 357
 358 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
 359   return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
 360 }
 361
 362 void ASTDeclReader::Visit(Decl *D) {
 363   DeclVisitor<ASTDeclReader, void>::Visit(D);
 364
 365   if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
 366     if (DD->DeclInfo) {
 367       DeclaratorDecl::ExtInfo *Info =
 368           DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
 369       Info->TInfo =
 370           GetTypeSourceInfo(Record, Idx);
 371     }
 372     else {
 373       DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
 374     }
 375   }
 376
 377   if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
 378     // We have a fully initialized TypeDecl. Read its type now.
 379     TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
 380
 381     // If this is a tag declaration with a typedef name for linkage, it's safe
 382     // to load that typedef now.
 383     if (NamedDeclForTagDecl)
 384       cast<TagDecl>(D)->NamedDeclOrQualifier =
 385           cast<NamedDecl>(Reader.GetDecl(NamedDeclForTagDecl));
 386   } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
 387     // if we have a fully initialized TypeDecl, we can safely read its type now.
 388     ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
 389   } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 390     // FunctionDecl's body was written last after all other Stmts/Exprs.
 391     // We only read it if FD doesn't already have a body (e.g., from another
 392     // module).
 393     // FIXME: Also consider = default and = delete.
 394     // FIXME: Can we diagnose ODR violations somehow?
 395     if (Record[Idx++]) {
 396       Reader.PendingBodies[FD] = GetCurrentCursorOffset();
 397       HasPendingBody = true;
 398     }
 399   }
 400 }
 401
 402 void ASTDeclReader::VisitDecl(Decl *D) {
 403   if (D->isTemplateParameter() || D->isTemplateParameterPack() ||
 404       isa<ParmVarDecl>(D)) {
 405     // We don't want to deserialize the DeclContext of a template
 406     // parameter or of a parameter of a function template immediately.   These
 407     // entities might be used in the formulation of its DeclContext (for
 408     // example, a function parameter can be used in decltype() in trailing
 409     // return type of the function).  Use the translation unit DeclContext as a
 410     // placeholder.
 411     GlobalDeclID SemaDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
 412     GlobalDeclID LexicalDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
 413     Reader.addPendingDeclContextInfo(D,
 414                                      SemaDCIDForTemplateParmDecl,
 415                                      LexicalDCIDForTemplateParmDecl);
 416     D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
 417   } else {
 418     DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
 419     DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
 420     DeclContext *MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);
 421     // Avoid calling setLexicalDeclContext() directly because it uses
 422     // Decl::getASTContext() internally which is unsafe during derialization.
 423     D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
 424                            Reader.getContext());
 425   }
 426   D->setLocation(Reader.ReadSourceLocation(F, RawLocation));
 427   D->setInvalidDecl(Record[Idx++]);
 428   if (Record[Idx++]) { // hasAttrs
 429     AttrVec Attrs;
 430     Reader.ReadAttributes(F, Attrs, Record, Idx);
 431     // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
 432     // internally which is unsafe during derialization.
 433     D->setAttrsImpl(Attrs, Reader.getContext());
 434   }
 435   D->setImplicit(Record[Idx++]);
 436   D->Used = Record[Idx++];
 437   D->setReferenced(Record[Idx++]);
 438   D->setTopLevelDeclInObjCContainer(Record[Idx++]);
 439   D->setAccess((AccessSpecifier)Record[Idx++]);
 440   D->FromASTFile = true;
 441   D->setModulePrivate(Record[Idx++]);
 442   D->Hidden = D->isModulePrivate();
 443
 444   // Determine whether this declaration is part of a (sub)module. If so, it
 445   // may not yet be visible.
 446   if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
 447     // Store the owning submodule ID in the declaration.
 448     D->setOwningModuleID(SubmoduleID);
 449
 450     // Module-private declarations are never visible, so there is no work to do.
 451     if (!D->isModulePrivate()) {
 452       if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
 453         if (Owner->NameVisibility != Module::AllVisible) {
 454           // The owning module is not visible. Mark this declaration as hidden.
 455           D->Hidden = true;
 456
 457           // Note that this declaration was hidden because its owning module is
 458           // not yet visible.
 459           Reader.HiddenNamesMap[Owner].HiddenDecls.push_back(D);
 460         }
 461       }
 462     }
 463   }
 464 }
 465
 466 void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
 467   llvm_unreachable("Translation units are not serialized");
 468 }
 469
 470 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
 471   VisitDecl(ND);
 472   ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
 473   if (needsAnonymousDeclarationNumber(ND))
 474     AnonymousDeclNumber = Record[Idx++];
 475 }
 476
 477 void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
 478   VisitNamedDecl(TD);
 479   TD->setLocStart(ReadSourceLocation(Record, Idx));
 480   // Delay type reading until after we have fully initialized the decl.
 481   TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
 482 }
 483
 484 ASTDeclReader::RedeclarableResult
 485 ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
 486   RedeclarableResult Redecl = VisitRedeclarable(TD);
 487   VisitTypeDecl(TD);
 488   TypeSourceInfo *TInfo = GetTypeSourceInfo(Record, Idx);
 489   if (Record[Idx++]) { // isModed
 490     QualType modedT = Reader.readType(F, Record, Idx);
 491     TD->setModedTypeSourceInfo(TInfo, modedT);
 492   } else
 493     TD->setTypeSourceInfo(TInfo);
 494   return Redecl;
 495 }
 496
 497 void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
 498   RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
 499   mergeRedeclarable(TD, Redecl);
 500 }
 501
 502 void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
 503   RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
 504   if (auto *Template = ReadDeclAs<TypeAliasTemplateDecl>(Record, Idx))
 505     // Merged when we merge the template.
 506     TD->setDescribedAliasTemplate(Template);
 507   else
 508     mergeRedeclarable(TD, Redecl);
 509 }
 510
 511 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
 512   RedeclarableResult Redecl = VisitRedeclarable(TD);
 513   VisitTypeDecl(TD);
 514
 515   TD->IdentifierNamespace = Record[Idx++];
 516   TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
 517   if (!isa<CXXRecordDecl>(TD))
 518     TD->setCompleteDefinition(Record[Idx++]);
 519   TD->setEmbeddedInDeclarator(Record[Idx++]);
 520   TD->setFreeStanding(Record[Idx++]);
 521   TD->setCompleteDefinitionRequired(Record[Idx++]);
 522   TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
 523
 524   switch (Record[Idx++]) {
 525   case 0:
 526     break;
 527   case 1: { // ExtInfo
 528     TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
 529     ReadQualifierInfo(*Info, Record, Idx);
 530     TD->NamedDeclOrQualifier = Info;
 531     break;
 532   }
 533   case 2: // TypedefNameForAnonDecl
 534     NamedDeclForTagDecl = ReadDeclID(Record, Idx);
 535     TypedefNameForLinkage = Reader.GetIdentifierInfo(F, Record, Idx);
 536     break;
 537   case 3: // DeclaratorForAnonDecl
 538     NamedDeclForTagDecl = ReadDeclID(Record, Idx);
 539     break;
 540   default:
 541     llvm_unreachable("unexpected tag info kind");
 542   }
 543
 544   if (!isa<CXXRecordDecl>(TD))
 545     mergeRedeclarable(TD, Redecl);
 546   return Redecl;
 547 }
 548
 549 void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
 550   VisitTagDecl(ED);
 551   if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
 552     ED->setIntegerTypeSourceInfo(TI);
 553   else
 554     ED->setIntegerType(Reader.readType(F, Record, Idx));
 555   ED->setPromotionType(Reader.readType(F, Record, Idx));
 556   ED->setNumPositiveBits(Record[Idx++]);
 557   ED->setNumNegativeBits(Record[Idx++]);
 558   ED->IsScoped = Record[Idx++];
 559   ED->IsScopedUsingClassTag = Record[Idx++];
 560   ED->IsFixed = Record[Idx++];
 561
 562   // If this is a definition subject to the ODR, and we already have a
 563   // definition, merge this one into it.
 564   if (ED->IsCompleteDefinition &&
 565       Reader.getContext().getLangOpts().Modules &&
 566       Reader.getContext().getLangOpts().CPlusPlus) {
 567     if (EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()]) {
 568       Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));
 569       ED->IsCompleteDefinition = false;
 570     } else {
 571       OldDef = ED;
 572     }
 573   }
 574
 575   if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
 576     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
 577     SourceLocation POI = ReadSourceLocation(Record, Idx);
 578     ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
 579     ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
 580   }
 581 }
 582
 583 ASTDeclReader::RedeclarableResult
 584 ASTDeclReader::VisitRecordDeclImpl(RecordDecl *RD) {
 585   RedeclarableResult Redecl = VisitTagDecl(RD);
 586   RD->setHasFlexibleArrayMember(Record[Idx++]);
 587   RD->setAnonymousStructOrUnion(Record[Idx++]);
 588   RD->setHasObjectMember(Record[Idx++]);
 589   RD->setHasVolatileMember(Record[Idx++]);
 590   return Redecl;
 591 }
 592
 593 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
 594   VisitNamedDecl(VD);
 595   VD->setType(Reader.readType(F, Record, Idx));
 596 }
 597
 598 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
 599   VisitValueDecl(ECD);
 600   if (Record[Idx++])
 601     ECD->setInitExpr(Reader.ReadExpr(F));
 602   ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
 603   mergeMergeable(ECD);
 604 }
 605
 606 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
 607   VisitValueDecl(DD);
 608   DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
 609   if (Record[Idx++]) { // hasExtInfo
 610     DeclaratorDecl::ExtInfo *Info
 611         = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
 612     ReadQualifierInfo(*Info, Record, Idx);
 613     DD->DeclInfo = Info;
 614   }
 615 }
 616
 617 void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
 618   RedeclarableResult Redecl = VisitRedeclarable(FD);
 619   VisitDeclaratorDecl(FD);
 620
 621   ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
 622   FD->IdentifierNamespace = Record[Idx++];
 623
 624   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
 625   // after everything else is read.
 626
 627   FD->SClass = (StorageClass)Record[Idx++];
 628   FD->IsInline = Record[Idx++];
 629   FD->IsInlineSpecified = Record[Idx++];
 630   FD->IsVirtualAsWritten = Record[Idx++];
 631   FD->IsPure = Record[Idx++];
 632   FD->HasInheritedPrototype = Record[Idx++];
 633   FD->HasWrittenPrototype = Record[Idx++];
 634   FD->IsDeleted = Record[Idx++];
 635   FD->IsTrivial = Record[Idx++];
 636   FD->IsDefaulted = Record[Idx++];
 637   FD->IsExplicitlyDefaulted = Record[Idx++];
 638   FD->HasImplicitReturnZero = Record[Idx++];
 639   FD->IsConstexpr = Record[Idx++];
 640   FD->HasSkippedBody = Record[Idx++];
 641   FD->IsLateTemplateParsed = Record[Idx++];
 642   FD->setCachedLinkage(Linkage(Record[Idx++]));
 643   FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
 644
 645   switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
 646   case FunctionDecl::TK_NonTemplate:
 647     mergeRedeclarable(FD, Redecl);
 648     break;
 649   case FunctionDecl::TK_FunctionTemplate:
 650     // Merged when we merge the template.
 651     FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
 652                                                                       Idx));
 653     break;
 654   case FunctionDecl::TK_MemberSpecialization: {
 655     FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
 656     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
 657     SourceLocation POI = ReadSourceLocation(Record, Idx);
 658     FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
 659     FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
 660     mergeRedeclarable(FD, Redecl);
 661     break;
 662   }
 663   case FunctionDecl::TK_FunctionTemplateSpecialization: {
 664     FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
 665                                                                       Idx);
 666     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
 667
 668     // Template arguments.
 669     SmallVector<TemplateArgument, 8> TemplArgs;
 670     Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
 671
 672     // Template args as written.
 673     SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
 674     SourceLocation LAngleLoc, RAngleLoc;
 675     bool HasTemplateArgumentsAsWritten = Record[Idx++];
 676     if (HasTemplateArgumentsAsWritten) {
 677       unsigned NumTemplateArgLocs = Record[Idx++];
 678       TemplArgLocs.reserve(NumTemplateArgLocs);
 679       for (unsigned i=0; i != NumTemplateArgLocs; ++i)
 680         TemplArgLocs.push_back(
 681             Reader.ReadTemplateArgumentLoc(F, Record, Idx));
 682
 683       LAngleLoc = ReadSourceLocation(Record, Idx);
 684       RAngleLoc = ReadSourceLocation(Record, Idx);
 685     }
 686
 687     SourceLocation POI = ReadSourceLocation(Record, Idx);
 688
 689     ASTContext &C = Reader.getContext();
 690     TemplateArgumentList *TemplArgList
 691       = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
 692     TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
 693     for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
 694       TemplArgsInfo.addArgument(TemplArgLocs[i]);
 695     FunctionTemplateSpecializationInfo *FTInfo
 696         = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
 697                                                      TemplArgList,
 698                              HasTemplateArgumentsAsWritten ? &TemplArgsInfo
 699                                                            : nullptr,
 700                                                      POI);
 701     FD->TemplateOrSpecialization = FTInfo;
 702
 703     if (FD->isCanonicalDecl()) { // if canonical add to template's set.
 704       // The template that contains the specializations set. It's not safe to
 705       // use getCanonicalDecl on Template since it may still be initializing.
 706       FunctionTemplateDecl *CanonTemplate
 707         = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
 708       // Get the InsertPos by FindNodeOrInsertPos() instead of calling
 709       // InsertNode(FTInfo) directly to avoid the getASTContext() call in
 710       // FunctionTemplateSpecializationInfo's Profile().
 711       // We avoid getASTContext because a decl in the parent hierarchy may
 712       // be initializing.
 713       llvm::FoldingSetNodeID ID;
 714       FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs, C);
 715       void *InsertPos = nullptr;
 716       FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();
 717       CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);
 718       if (InsertPos)
 719         CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
 720       else {
 721         assert(Reader.getContext().getLangOpts().Modules &&
 722                "already deserialized this template specialization");
 723         // FIXME: This specialization is a redeclaration of one from another
 724         // module. Merge it.
 725       }
 726     }
 727     break;
 728   }
 729   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
 730     // Templates.
 731     UnresolvedSet<8> TemplDecls;
 732     unsigned NumTemplates = Record[Idx++];
 733     while (NumTemplates--)
 734       TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
 735
 736     // Templates args.
 737     TemplateArgumentListInfo TemplArgs;
 738     unsigned NumArgs = Record[Idx++];
 739     while (NumArgs--)
 740       TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
 741     TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
 742     TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
 743
 744     FD->setDependentTemplateSpecialization(Reader.getContext(),
 745                                            TemplDecls, TemplArgs);
 746
 747     // FIXME: Merging.
 748     break;
 749   }
 750   }
 751
 752   // Read in the parameters.
 753   unsigned NumParams = Record[Idx++];
 754   SmallVector<ParmVarDecl *, 16> Params;
 755   Params.reserve(NumParams);
 756   for (unsigned I = 0; I != NumParams; ++I)
 757     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
 758   FD->setParams(Reader.getContext(), Params);
 759 }
 760
 761 void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
 762   VisitNamedDecl(MD);
 763   if (Record[Idx++]) {
 764     // Load the body on-demand. Most clients won't care, because method
 765     // definitions rarely show up in headers.
 766     Reader.PendingBodies[MD] = GetCurrentCursorOffset();
 767     HasPendingBody = true;
 768     MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
 769     MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
 770   }
 771   MD->setInstanceMethod(Record[Idx++]);
 772   MD->setVariadic(Record[Idx++]);
 773   MD->setPropertyAccessor(Record[Idx++]);
 774   MD->setDefined(Record[Idx++]);
 775   MD->IsOverriding = Record[Idx++];
 776   MD->HasSkippedBody = Record[Idx++];
 777
 778   MD->IsRedeclaration = Record[Idx++];
 779   MD->HasRedeclaration = Record[Idx++];
 780   if (MD->HasRedeclaration)
 781     Reader.getContext().setObjCMethodRedeclaration(MD,
 782                                        ReadDeclAs<ObjCMethodDecl>(Record, Idx));
 783
 784   MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
 785   MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
 786   MD->SetRelatedResultType(Record[Idx++]);
 787   MD->setReturnType(Reader.readType(F, Record, Idx));
 788   MD->setReturnTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 789   MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
 790   unsigned NumParams = Record[Idx++];
 791   SmallVector<ParmVarDecl *, 16> Params;
 792   Params.reserve(NumParams);
 793   for (unsigned I = 0; I != NumParams; ++I)
 794     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
 795
 796   MD->SelLocsKind = Record[Idx++];
 797   unsigned NumStoredSelLocs = Record[Idx++];
 798   SmallVector<SourceLocation, 16> SelLocs;
 799   SelLocs.reserve(NumStoredSelLocs);
 800   for (unsigned i = 0; i != NumStoredSelLocs; ++i)
 801     SelLocs.push_back(ReadSourceLocation(Record, Idx));
 802
 803   MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
 804 }
 805
 806 void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
 807   VisitNamedDecl(CD);
 808   CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
 809   CD->setAtEndRange(ReadSourceRange(Record, Idx));
 810 }
 811
 812 void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
 813   RedeclarableResult Redecl = VisitRedeclarable(ID);
 814   VisitObjCContainerDecl(ID);
 815   TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
 816   mergeRedeclarable(ID, Redecl);
 817
 818   if (Record[Idx++]) {
 819     // Read the definition.
 820     ID->allocateDefinitionData();
 821
 822     // Set the definition data of the canonical declaration, so other
 823     // redeclarations will see it.
 824     ID->getCanonicalDecl()->Data = ID->Data;
 825
 826     ObjCInterfaceDecl::DefinitionData &Data = ID->data();
 827
 828     // Read the superclass.
 829     Data.SuperClass = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
 830     Data.SuperClassLoc = ReadSourceLocation(Record, Idx);
 831
 832     Data.EndLoc = ReadSourceLocation(Record, Idx);
 833     Data.HasDesignatedInitializers = Record[Idx++];
 834
 835     // Read the directly referenced protocols and their SourceLocations.
 836     unsigned NumProtocols = Record[Idx++];
 837     SmallVector<ObjCProtocolDecl *, 16> Protocols;
 838     Protocols.reserve(NumProtocols);
 839     for (unsigned I = 0; I != NumProtocols; ++I)
 840       Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
 841     SmallVector<SourceLocation, 16> ProtoLocs;
 842     ProtoLocs.reserve(NumProtocols);
 843     for (unsigned I = 0; I != NumProtocols; ++I)
 844       ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
 845     ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
 846                         Reader.getContext());
 847
 848     // Read the transitive closure of protocols referenced by this class.
 849     NumProtocols = Record[Idx++];
 850     Protocols.clear();
 851     Protocols.reserve(NumProtocols);
 852     for (unsigned I = 0; I != NumProtocols; ++I)
 853       Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
 854     ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
 855                                           Reader.getContext());
 856
 857     // We will rebuild this list lazily.
 858     ID->setIvarList(nullptr);
 859
 860     // Note that we have deserialized a definition.
 861     Reader.PendingDefinitions.insert(ID);
 862
 863     // Note that we've loaded this Objective-C class.
 864     Reader.ObjCClassesLoaded.push_back(ID);
 865   } else {
 866     ID->Data = ID->getCanonicalDecl()->Data;
 867   }
 868 }
 869
 870 void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
 871   VisitFieldDecl(IVD);
 872   IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
 873   // This field will be built lazily.
 874   IVD->setNextIvar(nullptr);
 875   bool synth = Record[Idx++];
 876   IVD->setSynthesize(synth);
 877 }
 878
 879 void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
 880   RedeclarableResult Redecl = VisitRedeclarable(PD);
 881   VisitObjCContainerDecl(PD);
 882   mergeRedeclarable(PD, Redecl);
 883
 884   if (Record[Idx++]) {
 885     // Read the definition.
 886     PD->allocateDefinitionData();
 887
 888     // Set the definition data of the canonical declaration, so other
 889     // redeclarations will see it.
 890     PD->getCanonicalDecl()->Data = PD->Data;
 891
 892     unsigned NumProtoRefs = Record[Idx++];
 893     SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
 894     ProtoRefs.reserve(NumProtoRefs);
 895     for (unsigned I = 0; I != NumProtoRefs; ++I)
 896       ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
 897     SmallVector<SourceLocation, 16> ProtoLocs;
 898     ProtoLocs.reserve(NumProtoRefs);
 899     for (unsigned I = 0; I != NumProtoRefs; ++I)
 900       ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
 901     PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
 902                         Reader.getContext());
 903
 904     // Note that we have deserialized a definition.
 905     Reader.PendingDefinitions.insert(PD);
 906   } else {
 907     PD->Data = PD->getCanonicalDecl()->Data;
 908   }
 909 }
 910
 911 void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
 912   VisitFieldDecl(FD);
 913 }
 914
 915 void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
 916   VisitObjCContainerDecl(CD);
 917   CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
 918   CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
 919   CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
 920
 921   // Note that this category has been deserialized. We do this before
 922   // deserializing the interface declaration, so that it will consider this
 923   /// category.
 924   Reader.CategoriesDeserialized.insert(CD);
 925
 926   CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
 927   unsigned NumProtoRefs = Record[Idx++];
 928   SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
 929   ProtoRefs.reserve(NumProtoRefs);
 930   for (unsigned I = 0; I != NumProtoRefs; ++I)
 931     ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
 932   SmallVector<SourceLocation, 16> ProtoLocs;
 933   ProtoLocs.reserve(NumProtoRefs);
 934   for (unsigned I = 0; I != NumProtoRefs; ++I)
 935     ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
 936   CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
 937                       Reader.getContext());
 938 }
 939
 940 void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
 941   VisitNamedDecl(CAD);
 942   CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
 943 }
 944
 945 void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
 946   VisitNamedDecl(D);
 947   D->setAtLoc(ReadSourceLocation(Record, Idx));
 948   D->setLParenLoc(ReadSourceLocation(Record, Idx));
 949   D->setType(GetTypeSourceInfo(Record, Idx));
 950   // FIXME: stable encoding
 951   D->setPropertyAttributes(
 952                       (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
 953   D->setPropertyAttributesAsWritten(
 954                       (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
 955   // FIXME: stable encoding
 956   D->setPropertyImplementation(
 957                             (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
 958   D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
 959   D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
 960   D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
 961   D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
 962   D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
 963 }
 964
 965 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
 966   VisitObjCContainerDecl(D);
 967   D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
 968 }
 969
 970 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
 971   VisitObjCImplDecl(D);
 972   D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
 973   D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
 974 }
 975
 976 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
 977   VisitObjCImplDecl(D);
 978   D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
 979   D->SuperLoc = ReadSourceLocation(Record, Idx);
 980   D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
 981   D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
 982   D->setHasNonZeroConstructors(Record[Idx++]);
 983   D->setHasDestructors(Record[Idx++]);
 984   std::tie(D->IvarInitializers, D->NumIvarInitializers) =
 985       Reader.ReadCXXCtorInitializers(F, Record, Idx);
 986 }
 987
 988
 989 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
 990   VisitDecl(D);
 991   D->setAtLoc(ReadSourceLocation(Record, Idx));
 992   D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
 993   D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
 994   D->IvarLoc = ReadSourceLocation(Record, Idx);
 995   D->setGetterCXXConstructor(Reader.ReadExpr(F));
 996   D->setSetterCXXAssignment(Reader.ReadExpr(F));
 997 }
 998
 999 void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
1000   VisitDeclaratorDecl(FD);
1001   FD->Mutable = Record[Idx++];
1002   if (int BitWidthOrInitializer = Record[Idx++]) {
1003     FD->InitStorage.setInt(
1004           static_cast<FieldDecl::InitStorageKind>(BitWidthOrInitializer - 1));
1005     if (FD->InitStorage.getInt() == FieldDecl::ISK_CapturedVLAType) {
1006       // Read captured variable length array.
1007       FD->InitStorage.setPointer(
1008           Reader.readType(F, Record, Idx).getAsOpaquePtr());
1009     } else {
1010       FD->InitStorage.setPointer(Reader.ReadExpr(F));
1011     }
1012   }
1013   if (!FD->getDeclName()) {
1014     if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
1015       Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
1016   }
1017   mergeMergeable(FD);
1018 }
1019
1020 void ASTDeclReader::VisitMSPropertyDecl(MSPropertyDecl *PD) {
1021   VisitDeclaratorDecl(PD);
1022   PD->GetterId = Reader.GetIdentifierInfo(F, Record, Idx);
1023   PD->SetterId = Reader.GetIdentifierInfo(F, Record, Idx);
1024 }
1025
1026 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
1027   VisitValueDecl(FD);
1028
1029   FD->ChainingSize = Record[Idx++];
1030   assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
1031   FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
1032
1033   for (unsigned I = 0; I != FD->ChainingSize; ++I)
1034     FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
1035 }
1036
1037 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
1038   RedeclarableResult Redecl = VisitRedeclarable(VD);
1039   VisitDeclaratorDecl(VD);
1040
1041   VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
1042   VD->VarDeclBits.TSCSpec = Record[Idx++];
1043   VD->VarDeclBits.InitStyle = Record[Idx++];
1044   VD->VarDeclBits.ExceptionVar = Record[Idx++];
1045   VD->VarDeclBits.NRVOVariable = Record[Idx++];
1046   VD->VarDeclBits.CXXForRangeDecl = Record[Idx++];
1047   VD->VarDeclBits.ARCPseudoStrong = Record[Idx++];
1048   VD->VarDeclBits.IsConstexpr = Record[Idx++];
1049   VD->VarDeclBits.IsInitCapture = Record[Idx++];
1050   VD->VarDeclBits.PreviousDeclInSameBlockScope = Record[Idx++];
1051   Linkage VarLinkage = Linkage(Record[Idx++]);
1052   VD->setCachedLinkage(VarLinkage);
1053
1054   // Reconstruct the one piece of the IdentifierNamespace that we need.
1055   if (VD->getStorageClass() == SC_Extern && VarLinkage != NoLinkage &&
1056       VD->getLexicalDeclContext()->isFunctionOrMethod())
1057     VD->setLocalExternDecl();
1058
1059   if (uint64_t Val = Record[Idx++]) {
1060     VD->setInit(Reader.ReadExpr(F));
1061     if (Val > 1) {
1062       EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
1063       Eval->CheckedICE = true;
1064       Eval->IsICE = Val == 3;
1065     }
1066   }
1067
1068   enum VarKind {
1069     VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1070   };
1071   switch ((VarKind)Record[Idx++]) {
1072   case VarNotTemplate:
1073     // Only true variables (not parameters or implicit parameters) can be merged
1074     if (VD->getKind() != Decl::ParmVar && VD->getKind() != Decl::ImplicitParam &&
1075         !isa<VarTemplateSpecializationDecl>(VD))
1076       mergeRedeclarable(VD, Redecl);
1077     break;
1078   case VarTemplate:
1079     // Merged when we merge the template.
1080     VD->setDescribedVarTemplate(ReadDeclAs<VarTemplateDecl>(Record, Idx));
1081     break;
1082   case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.
1083     VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
1084     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1085     SourceLocation POI = ReadSourceLocation(Record, Idx);
1086     Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
1087     mergeRedeclarable(VD, Redecl);
1088     break;
1089   }
1090   }
1091
1092   return Redecl;
1093 }
1094
1095 void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
1096   VisitVarDecl(PD);
1097 }
1098
1099 void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
1100   VisitVarDecl(PD);
1101   unsigned isObjCMethodParam = Record[Idx++];
1102   unsigned scopeDepth = Record[Idx++];
1103   unsigned scopeIndex = Record[Idx++];
1104   unsigned declQualifier = Record[Idx++];
1105   if (isObjCMethodParam) {
1106     assert(scopeDepth == 0);
1107     PD->setObjCMethodScopeInfo(scopeIndex);
1108     PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
1109   } else {
1110     PD->setScopeInfo(scopeDepth, scopeIndex);
1111   }
1112   PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
1113   PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
1114   if (Record[Idx++]) // hasUninstantiatedDefaultArg.
1115     PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
1116
1117   // FIXME: If this is a redeclaration of a function from another module, handle
1118   // inheritance of default arguments.
1119 }
1120
1121 void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
1122   VisitDecl(AD);
1123   AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
1124   AD->setRParenLoc(ReadSourceLocation(Record, Idx));
1125 }
1126
1127 void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
1128   VisitDecl(BD);
1129   BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
1130   BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
1131   unsigned NumParams = Record[Idx++];
1132   SmallVector<ParmVarDecl *, 16> Params;
1133   Params.reserve(NumParams);
1134   for (unsigned I = 0; I != NumParams; ++I)
1135     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
1136   BD->setParams(Params);
1137
1138   BD->setIsVariadic(Record[Idx++]);
1139   BD->setBlockMissingReturnType(Record[Idx++]);
1140   BD->setIsConversionFromLambda(Record[Idx++]);
1141
1142   bool capturesCXXThis = Record[Idx++];
1143   unsigned numCaptures = Record[Idx++];
1144   SmallVector<BlockDecl::Capture, 16> captures;
1145   captures.reserve(numCaptures);
1146   for (unsigned i = 0; i != numCaptures; ++i) {
1147     VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
1148     unsigned flags = Record[Idx++];
1149     bool byRef = (flags & 1);
1150     bool nested = (flags & 2);
1151     Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : nullptr);
1152
1153     captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
1154   }
1155   BD->setCaptures(Reader.getContext(), captures.begin(),
1156                   captures.end(), capturesCXXThis);
1157 }
1158
1159 void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
1160   VisitDecl(CD);
1161   unsigned ContextParamPos = Record[Idx++];
1162   CD->setNothrow(Record[Idx++] != 0);
1163   // Body is set by VisitCapturedStmt.
1164   for (unsigned I = 0; I < CD->NumParams; ++I) {
1165     if (I != ContextParamPos)
1166       CD->setParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1167     else
1168       CD->setContextParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1169   }
1170 }
1171
1172 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1173   VisitDecl(D);
1174   D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
1175   D->setExternLoc(ReadSourceLocation(Record, Idx));
1176   D->setRBraceLoc(ReadSourceLocation(Record, Idx));
1177 }
1178
1179 void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
1180   VisitNamedDecl(D);
1181   D->setLocStart(ReadSourceLocation(Record, Idx));
1182 }
1183
1184
1185 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
1186   RedeclarableResult Redecl = VisitRedeclarable(D);
1187   VisitNamedDecl(D);
1188   D->setInline(Record[Idx++]);
1189   D->LocStart = ReadSourceLocation(Record, Idx);
1190   D->RBraceLoc = ReadSourceLocation(Record, Idx);
1191
1192   if (Redecl.getFirstID() == ThisDeclID) {
1193     // Each module has its own anonymous namespace, which is disjoint from
1194     // any other module's anonymous namespaces, so don't attach the anonymous
1195     // namespace at all.
1196     NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>(Record, Idx);
1197     if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule)
1198       D->setAnonymousNamespace(Anon);
1199   } else {
1200     // Link this namespace back to the first declaration, which has already
1201     // been deserialized.
1202     D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDecl());
1203   }
1204
1205   mergeRedeclarable(D, Redecl);
1206 }
1207
1208 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1209   RedeclarableResult Redecl = VisitRedeclarable(D);
1210   VisitNamedDecl(D);
1211   D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1212   D->IdentLoc = ReadSourceLocation(Record, Idx);
1213   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1214   D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
1215   mergeRedeclarable(D, Redecl);
1216 }
1217
1218 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1219   VisitNamedDecl(D);
1220   D->setUsingLoc(ReadSourceLocation(Record, Idx));
1221   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1222   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1223   D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
1224   D->setTypename(Record[Idx++]);
1225   if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
1226     Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1227   mergeMergeable(D);
1228 }
1229
1230 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1231   RedeclarableResult Redecl = VisitRedeclarable(D);
1232   VisitNamedDecl(D);
1233   D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1234   D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1235   UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1236   if (Pattern)
1237     Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1238   mergeRedeclarable(D, Redecl);
1239 }
1240
1241 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1242   VisitNamedDecl(D);
1243   D->UsingLoc = ReadSourceLocation(Record, Idx);
1244   D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1245   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1246   D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
1247   D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
1248 }
1249
1250 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1251   VisitValueDecl(D);
1252   D->setUsingLoc(ReadSourceLocation(Record, Idx));
1253   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1254   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1255   mergeMergeable(D);
1256 }
1257
1258 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1259                                                UnresolvedUsingTypenameDecl *D) {
1260   VisitTypeDecl(D);
1261   D->TypenameLocation = ReadSourceLocation(Record, Idx);
1262   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1263   mergeMergeable(D);
1264 }
1265
1266 void ASTDeclReader::ReadCXXDefinitionData(
1267                                    struct CXXRecordDecl::DefinitionData &Data,
1268                                    const RecordData &Record, unsigned &Idx) {
1269   // Note: the caller has deserialized the IsLambda bit already.
1270   Data.UserDeclaredConstructor = Record[Idx++];
1271   Data.UserDeclaredSpecialMembers = Record[Idx++];
1272   Data.Aggregate = Record[Idx++];
1273   Data.PlainOldData = Record[Idx++];
1274   Data.Empty = Record[Idx++];
1275   Data.Polymorphic = Record[Idx++];
1276   Data.Abstract = Record[Idx++];
1277   Data.IsStandardLayout = Record[Idx++];
1278   Data.HasNoNonEmptyBases = Record[Idx++];
1279   Data.HasPrivateFields = Record[Idx++];
1280   Data.HasProtectedFields = Record[Idx++];
1281   Data.HasPublicFields = Record[Idx++];
1282   Data.HasMutableFields = Record[Idx++];
1283   Data.HasVariantMembers = Record[Idx++];
1284   Data.HasOnlyCMembers = Record[Idx++];
1285   Data.HasInClassInitializer = Record[Idx++];
1286   Data.HasUninitializedReferenceMember = Record[Idx++];
1287   Data.NeedOverloadResolutionForMoveConstructor = Record[Idx++];
1288   Data.NeedOverloadResolutionForMoveAssignment = Record[Idx++];
1289   Data.NeedOverloadResolutionForDestructor = Record[Idx++];
1290   Data.DefaultedMoveConstructorIsDeleted = Record[Idx++];
1291   Data.DefaultedMoveAssignmentIsDeleted = Record[Idx++];
1292   Data.DefaultedDestructorIsDeleted = Record[Idx++];
1293   Data.HasTrivialSpecialMembers = Record[Idx++];
1294   Data.DeclaredNonTrivialSpecialMembers = Record[Idx++];
1295   Data.HasIrrelevantDestructor = Record[Idx++];
1296   Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
1297   Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
1298   Data.HasConstexprDefaultConstructor = Record[Idx++];
1299   Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
1300   Data.ComputedVisibleConversions = Record[Idx++];
1301   Data.UserProvidedDefaultConstructor = Record[Idx++];
1302   Data.DeclaredSpecialMembers = Record[Idx++];
1303   Data.ImplicitCopyConstructorHasConstParam = Record[Idx++];
1304   Data.ImplicitCopyAssignmentHasConstParam = Record[Idx++];
1305   Data.HasDeclaredCopyConstructorWithConstParam = Record[Idx++];
1306   Data.HasDeclaredCopyAssignmentWithConstParam = Record[Idx++];
1307
1308   Data.NumBases = Record[Idx++];
1309   if (Data.NumBases)
1310     Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1311   Data.NumVBases = Record[Idx++];
1312   if (Data.NumVBases)
1313     Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1314
1315   Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
1316   Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
1317   assert(Data.Definition && "Data.Definition should be already set!");
1318   Data.FirstFriend = ReadDeclID(Record, Idx);
1319
1320   if (Data.IsLambda) {
1321     typedef LambdaCapture Capture;
1322     CXXRecordDecl::LambdaDefinitionData &Lambda
1323       = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
1324     Lambda.Dependent = Record[Idx++];
1325     Lambda.IsGenericLambda = Record[Idx++];
1326     Lambda.CaptureDefault = Record[Idx++];
1327     Lambda.NumCaptures = Record[Idx++];
1328     Lambda.NumExplicitCaptures = Record[Idx++];
1329     Lambda.ManglingNumber = Record[Idx++];
1330     Lambda.ContextDecl = ReadDecl(Record, Idx);
1331     Lambda.Captures
1332       = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
1333     Capture *ToCapture = Lambda.Captures;
1334     Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
1335     for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
1336       SourceLocation Loc = ReadSourceLocation(Record, Idx);
1337       bool IsImplicit = Record[Idx++];
1338       LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
1339       switch (Kind) {
1340       case LCK_This:
1341       case LCK_VLAType:
1342         *ToCapture++ = Capture(Loc, IsImplicit, Kind, nullptr,SourceLocation());
1343         break;
1344       case LCK_ByCopy:
1345       case LCK_ByRef:
1346         VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1347         SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1348         *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1349         break;
1350       }
1351     }
1352   }
1353 }
1354
1355 void ASTDeclReader::MergeDefinitionData(
1356     CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &MergeDD) {
1357   assert(D->DefinitionData.getNotUpdated() &&
1358          "merging class definition into non-definition");
1359   auto &DD = *D->DefinitionData.getNotUpdated();
1360
1361   // If the new definition has new special members, let the name lookup
1362   // code know that it needs to look in the new definition too.
1363   //
1364   // FIXME: We only need to do this if the merged definition declares members
1365   // that this definition did not declare, or if it defines members that this
1366   // definition did not define.
1367   if (MergeDD.DeclaredSpecialMembers && DD.Definition != MergeDD.Definition) {
1368     Reader.MergedLookups[DD.Definition].push_back(MergeDD.Definition);
1369     DD.Definition->setHasExternalVisibleStorage();
1370   }
1371
1372   // FIXME: Move this out into a .def file?
1373   // FIXME: Issue a diagnostic on a mismatched MATCH_FIELD, rather than
1374   // asserting; this can happen in the case of an ODR violation.
1375   bool DetectedOdrViolation = false;
1376 #define OR_FIELD(Field) DD.Field |= MergeDD.Field;
1377 #define MATCH_FIELD(Field) \
1378     DetectedOdrViolation |= DD.Field != MergeDD.Field; \
1379     OR_FIELD(Field)
1380   MATCH_FIELD(UserDeclaredConstructor)
1381   MATCH_FIELD(UserDeclaredSpecialMembers)
1382   MATCH_FIELD(Aggregate)
1383   MATCH_FIELD(PlainOldData)
1384   MATCH_FIELD(Empty)
1385   MATCH_FIELD(Polymorphic)
1386   MATCH_FIELD(Abstract)
1387   MATCH_FIELD(IsStandardLayout)
1388   MATCH_FIELD(HasNoNonEmptyBases)
1389   MATCH_FIELD(HasPrivateFields)
1390   MATCH_FIELD(HasProtectedFields)
1391   MATCH_FIELD(HasPublicFields)
1392   MATCH_FIELD(HasMutableFields)
1393   MATCH_FIELD(HasVariantMembers)
1394   MATCH_FIELD(HasOnlyCMembers)
1395   MATCH_FIELD(HasInClassInitializer)
1396   MATCH_FIELD(HasUninitializedReferenceMember)
1397   MATCH_FIELD(NeedOverloadResolutionForMoveConstructor)
1398   MATCH_FIELD(NeedOverloadResolutionForMoveAssignment)
1399   MATCH_FIELD(NeedOverloadResolutionForDestructor)
1400   MATCH_FIELD(DefaultedMoveConstructorIsDeleted)
1401   MATCH_FIELD(DefaultedMoveAssignmentIsDeleted)
1402   MATCH_FIELD(DefaultedDestructorIsDeleted)
1403   OR_FIELD(HasTrivialSpecialMembers)
1404   OR_FIELD(DeclaredNonTrivialSpecialMembers)
1405   MATCH_FIELD(HasIrrelevantDestructor)
1406   OR_FIELD(HasConstexprNonCopyMoveConstructor)
1407   MATCH_FIELD(DefaultedDefaultConstructorIsConstexpr)
1408   OR_FIELD(HasConstexprDefaultConstructor)
1409   MATCH_FIELD(HasNonLiteralTypeFieldsOrBases)
1410   // ComputedVisibleConversions is handled below.
1411   MATCH_FIELD(UserProvidedDefaultConstructor)
1412   OR_FIELD(DeclaredSpecialMembers)
1413   MATCH_FIELD(ImplicitCopyConstructorHasConstParam)
1414   MATCH_FIELD(ImplicitCopyAssignmentHasConstParam)
1415   OR_FIELD(HasDeclaredCopyConstructorWithConstParam)
1416   OR_FIELD(HasDeclaredCopyAssignmentWithConstParam)
1417   MATCH_FIELD(IsLambda)
1418 #undef OR_FIELD
1419 #undef MATCH_FIELD
1420
1421   if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
1422     DetectedOdrViolation = true;
1423   // FIXME: Issue a diagnostic if the base classes don't match when we come
1424   // to lazily load them.
1425
1426   // FIXME: Issue a diagnostic if the list of conversion functions doesn't
1427   // match when we come to lazily load them.
1428   if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
1429     DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
1430     DD.ComputedVisibleConversions = true;
1431   }
1432
1433   // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
1434   // lazily load it.
1435
1436   if (DD.IsLambda) {
1437     // FIXME: ODR-checking for merging lambdas (this happens, for instance,
1438     // when they occur within the body of a function template specialization).
1439   }
1440
1441   if (DetectedOdrViolation)
1442     Reader.PendingOdrMergeFailures[DD.Definition].push_back(MergeDD.Definition);
1443 }
1444
1445 void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D) {
1446   struct CXXRecordDecl::DefinitionData *DD;
1447   ASTContext &C = Reader.getContext();
1448
1449   // Determine whether this is a lambda closure type, so that we can
1450   // allocate the appropriate DefinitionData structure.
1451   bool IsLambda = Record[Idx++];
1452   if (IsLambda)
1453     DD = new (C) CXXRecordDecl::LambdaDefinitionData(D, nullptr, false, false,
1454                                                      LCD_None);
1455   else
1456     DD = new (C) struct CXXRecordDecl::DefinitionData(D);
1457
1458   ReadCXXDefinitionData(*DD, Record, Idx);
1459
1460   // If we're reading an update record, we might already have a definition for
1461   // this record. If so, just merge into it.
1462   if (D->DefinitionData.getNotUpdated()) {
1463     MergeDefinitionData(D, *DD);
1464     return;
1465   }
1466
1467   // Propagate the DefinitionData pointer to the canonical declaration, so
1468   // that all other deserialized declarations will see it.
1469   CXXRecordDecl *Canon = D->getCanonicalDecl();
1470   if (Canon == D) {
1471     D->DefinitionData = DD;
1472     D->IsCompleteDefinition = true;
1473   } else if (auto *CanonDD = Canon->DefinitionData.getNotUpdated()) {
1474     // We have already deserialized a definition of this record. This
1475     // definition is no longer really a definition. Note that the pre-existing
1476     // definition is the *real* definition.
1477     Reader.MergedDeclContexts.insert(
1478         std::make_pair(D, CanonDD->Definition));
1479     D->DefinitionData = Canon->DefinitionData;
1480     D->IsCompleteDefinition = false;
1481     MergeDefinitionData(D, *DD);
1482   } else {
1483     Canon->DefinitionData = DD;
1484     D->DefinitionData = Canon->DefinitionData;
1485     D->IsCompleteDefinition = true;
1486
1487     // Note that we have deserialized a definition. Any declarations
1488     // deserialized before this one will be be given the DefinitionData
1489     // pointer at the end.
1490     Reader.PendingDefinitions.insert(D);
1491   }
1492 }
1493
1494 ASTDeclReader::RedeclarableResult
1495 ASTDeclReader::VisitCXXRecordDeclImpl(CXXRecordDecl *D) {
1496   RedeclarableResult Redecl = VisitRecordDeclImpl(D);
1497
1498   ASTContext &C = Reader.getContext();
1499
1500   enum CXXRecKind {
1501     CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1502   };
1503   switch ((CXXRecKind)Record[Idx++]) {
1504   case CXXRecNotTemplate:
1505     // Merged when we merge the folding set entry in the primary template.
1506     if (!isa<ClassTemplateSpecializationDecl>(D))
1507       mergeRedeclarable(D, Redecl);
1508     break;
1509   case CXXRecTemplate: {
1510     // Merged when we merge the template.
1511     ClassTemplateDecl *Template = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
1512     D->TemplateOrInstantiation = Template;
1513     if (!Template->getTemplatedDecl()) {
1514       // We've not actually loaded the ClassTemplateDecl yet, because we're
1515       // currently being loaded as its pattern. Rely on it to set up our
1516       // TypeForDecl (see VisitClassTemplateDecl).
1517       //
1518       // Beware: we do not yet know our canonical declaration, and may still
1519       // get merged once the surrounding class template has got off the ground.
1520       TypeIDForTypeDecl = 0;
1521     }
1522     break;
1523   }
1524   case CXXRecMemberSpecialization: {
1525     CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1526     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1527     SourceLocation POI = ReadSourceLocation(Record, Idx);
1528     MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
1529     MSI->setPointOfInstantiation(POI);
1530     D->TemplateOrInstantiation = MSI;
1531     mergeRedeclarable(D, Redecl);
1532     break;
1533   }
1534   }
1535
1536   bool WasDefinition = Record[Idx++];
1537   if (WasDefinition)
1538     ReadCXXRecordDefinition(D);
1539   else
1540     // Propagate DefinitionData pointer from the canonical declaration.
1541     D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1542
1543   // Lazily load the key function to avoid deserializing every method so we can
1544   // compute it.
1545   if (WasDefinition) {
1546     DeclID KeyFn = ReadDeclID(Record, Idx);
1547     if (KeyFn && D->IsCompleteDefinition)
1548       // FIXME: This is wrong for the ARM ABI, where some other module may have
1549       // made this function no longer be a key function. We need an update
1550       // record or similar for that case.
1551       C.KeyFunctions[D] = KeyFn;
1552   }
1553
1554   return Redecl;
1555 }
1556
1557 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
1558   VisitFunctionDecl(D);
1559
1560   unsigned NumOverridenMethods = Record[Idx++];
1561   if (D->isCanonicalDecl()) {
1562     while (NumOverridenMethods--) {
1563       // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1564       // MD may be initializing.
1565       if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1566         Reader.getContext().addOverriddenMethod(D, MD->getCanonicalDecl());
1567     }
1568   } else {
1569     // We don't care about which declarations this used to override; we get
1570     // the relevant information from the canonical declaration.
1571     Idx += NumOverridenMethods;
1572   }
1573 }
1574
1575 void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1576   VisitCXXMethodDecl(D);
1577
1578   if (auto *CD = ReadDeclAs<CXXConstructorDecl>(Record, Idx))
1579     D->setInheritedConstructor(CD);
1580   D->IsExplicitSpecified = Record[Idx++];
1581   // FIXME: We should defer loading this until we need the constructor's body.
1582   std::tie(D->CtorInitializers, D->NumCtorInitializers) =
1583       Reader.ReadCXXCtorInitializers(F, Record, Idx);
1584 }
1585
1586 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1587   VisitCXXMethodDecl(D);
1588
1589   D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1590 }
1591
1592 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1593   VisitCXXMethodDecl(D);
1594   D->IsExplicitSpecified = Record[Idx++];
1595 }
1596
1597 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
1598   VisitDecl(D);
1599   D->ImportedAndComplete.setPointer(readModule(Record, Idx));
1600   D->ImportedAndComplete.setInt(Record[Idx++]);
1601   SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(D + 1);
1602   for (unsigned I = 0, N = Record.back(); I != N; ++I)
1603     StoredLocs[I] = ReadSourceLocation(Record, Idx);
1604   ++Idx; // The number of stored source locations.
1605 }
1606
1607 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1608   VisitDecl(D);
1609   D->setColonLoc(ReadSourceLocation(Record, Idx));
1610 }
1611
1612 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1613   VisitDecl(D);
1614   if (Record[Idx++]) // hasFriendDecl
1615     D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1616   else
1617     D->Friend = GetTypeSourceInfo(Record, Idx);
1618   for (unsigned i = 0; i != D->NumTPLists; ++i)
1619     D->getTPLists()[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1620   D->NextFriend = ReadDeclID(Record, Idx);
1621   D->UnsupportedFriend = (Record[Idx++] != 0);
1622   D->FriendLoc = ReadSourceLocation(Record, Idx);
1623 }
1624
1625 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1626   VisitDecl(D);
1627   unsigned NumParams = Record[Idx++];
1628   D->NumParams = NumParams;
1629   D->Params = new TemplateParameterList*[NumParams];
1630   for (unsigned i = 0; i != NumParams; ++i)
1631     D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1632   if (Record[Idx++]) // HasFriendDecl
1633     D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1634   else
1635     D->Friend = GetTypeSourceInfo(Record, Idx);
1636   D->FriendLoc = ReadSourceLocation(Record, Idx);
1637 }
1638
1639 DeclID ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1640   VisitNamedDecl(D);
1641
1642   DeclID PatternID = ReadDeclID(Record, Idx);
1643   NamedDecl *TemplatedDecl = cast_or_null<NamedDecl>(Reader.GetDecl(PatternID));
1644   TemplateParameterList* TemplateParams
1645       = Reader.ReadTemplateParameterList(F, Record, Idx);
1646   D->init(TemplatedDecl, TemplateParams);
1647
1648   // FIXME: If this is a redeclaration of a template from another module, handle
1649   // inheritance of default template arguments.
1650
1651   return PatternID;
1652 }
1653
1654 ASTDeclReader::RedeclarableResult
1655 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1656   RedeclarableResult Redecl = VisitRedeclarable(D);
1657
1658   // Make sure we've allocated the Common pointer first. We do this before
1659   // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
1660   RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
1661   if (!CanonD->Common) {
1662     CanonD->Common = CanonD->newCommon(Reader.getContext());
1663     Reader.PendingDefinitions.insert(CanonD);
1664   }
1665   D->Common = CanonD->Common;
1666
1667   // If this is the first declaration of the template, fill in the information
1668   // for the 'common' pointer.
1669   if (ThisDeclID == Redecl.getFirstID()) {
1670     if (RedeclarableTemplateDecl *RTD
1671           = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1672       assert(RTD->getKind() == D->getKind() &&
1673              "InstantiatedFromMemberTemplate kind mismatch");
1674       D->setInstantiatedFromMemberTemplate(RTD);
1675       if (Record[Idx++])
1676         D->setMemberSpecialization();
1677     }
1678   }
1679
1680   DeclID PatternID = VisitTemplateDecl(D);
1681   D->IdentifierNamespace = Record[Idx++];
1682
1683   mergeRedeclarable(D, Redecl, PatternID);
1684
1685   // If we merged the template with a prior declaration chain, merge the common
1686   // pointer.
1687   // FIXME: Actually merge here, don't just overwrite.
1688   D->Common = D->getCanonicalDecl()->Common;
1689
1690   return Redecl;
1691 }
1692
1693 void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1694   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1695
1696   if (ThisDeclID == Redecl.getFirstID()) {
1697     // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1698     // the specializations.
1699     SmallVector<serialization::DeclID, 2> SpecIDs;
1700     SpecIDs.push_back(0);
1701
1702     // Specializations.
1703     unsigned Size = Record[Idx++];
1704     SpecIDs[0] += Size;
1705     for (unsigned I = 0; I != Size; ++I)
1706       SpecIDs.push_back(ReadDeclID(Record, Idx));
1707
1708     // Partial specializations.
1709     Size = Record[Idx++];
1710     SpecIDs[0] += Size;
1711     for (unsigned I = 0; I != Size; ++I)
1712       SpecIDs.push_back(ReadDeclID(Record, Idx));
1713
1714     ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1715     if (SpecIDs[0]) {
1716       typedef serialization::DeclID DeclID;
1717
1718       // FIXME: Append specializations!
1719       CommonPtr->LazySpecializations
1720         = new (Reader.getContext()) DeclID [SpecIDs.size()];
1721       memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1722              SpecIDs.size() * sizeof(DeclID));
1723     }
1724   }
1725
1726   if (D->getTemplatedDecl()->TemplateOrInstantiation) {
1727     // We were loaded before our templated declaration was. We've not set up
1728     // its corresponding type yet (see VisitCXXRecordDeclImpl), so reconstruct
1729     // it now.
1730     Reader.Context.getInjectedClassNameType(
1731         D->getTemplatedDecl(), D->getInjectedClassNameSpecialization());
1732   }
1733 }
1734
1735 /// TODO: Unify with ClassTemplateDecl version?
1736 ///       May require unifying ClassTemplateDecl and
1737 ///        VarTemplateDecl beyond TemplateDecl...
1738 void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {
1739   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1740
1741   if (ThisDeclID == Redecl.getFirstID()) {
1742     // This VarTemplateDecl owns a CommonPtr; read it to keep track of all of
1743     // the specializations.
1744     SmallVector<serialization::DeclID, 2> SpecIDs;
1745     SpecIDs.push_back(0);
1746
1747     // Specializations.
1748     unsigned Size = Record[Idx++];
1749     SpecIDs[0] += Size;
1750     for (unsigned I = 0; I != Size; ++I)
1751       SpecIDs.push_back(ReadDeclID(Record, Idx));
1752
1753     // Partial specializations.
1754     Size = Record[Idx++];
1755     SpecIDs[0] += Size;
1756     for (unsigned I = 0; I != Size; ++I)
1757       SpecIDs.push_back(ReadDeclID(Record, Idx));
1758
1759     VarTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1760     if (SpecIDs[0]) {
1761       typedef serialization::DeclID DeclID;
1762
1763       // FIXME: Append specializations!
1764       CommonPtr->LazySpecializations =
1765           new (Reader.getContext()) DeclID[SpecIDs.size()];
1766       memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1767              SpecIDs.size() * sizeof(DeclID));
1768     }
1769   }
1770 }
1771
1772 ASTDeclReader::RedeclarableResult
1773 ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
1774     ClassTemplateSpecializationDecl *D) {
1775   RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
1776
1777   ASTContext &C = Reader.getContext();
1778   if (Decl *InstD = ReadDecl(Record, Idx)) {
1779     if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1780       D->SpecializedTemplate = CTD;
1781     } else {
1782       SmallVector<TemplateArgument, 8> TemplArgs;
1783       Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1784       TemplateArgumentList *ArgList
1785         = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1786                                            TemplArgs.size());
1787       ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1788           = new (C) ClassTemplateSpecializationDecl::
1789                                              SpecializedPartialSpecialization();
1790       PS->PartialSpecialization
1791           = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1792       PS->TemplateArgs = ArgList;
1793       D->SpecializedTemplate = PS;
1794     }
1795   }
1796
1797   SmallVector<TemplateArgument, 8> TemplArgs;
1798   Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1799   D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1800                                                      TemplArgs.size());
1801   D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1802   D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1803
1804   bool writtenAsCanonicalDecl = Record[Idx++];
1805   if (writtenAsCanonicalDecl) {
1806     ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
1807     if (D->isCanonicalDecl()) { // It's kept in the folding set.
1808       // Set this as, or find, the canonical declaration for this specialization
1809       ClassTemplateSpecializationDecl *CanonSpec;
1810       if (ClassTemplatePartialSpecializationDecl *Partial =
1811               dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
1812         CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations
1813             .GetOrInsertNode(Partial);
1814       } else {
1815         CanonSpec =
1816             CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
1817       }
1818       // If there was already a canonical specialization, merge into it.
1819       if (CanonSpec != D) {
1820         mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);
1821
1822         // This declaration might be a definition. Merge with any existing
1823         // definition.
1824         if (auto *DDD = D->DefinitionData.getNotUpdated()) {
1825           if (auto *CanonDD = CanonSpec->DefinitionData.getNotUpdated()) {
1826             MergeDefinitionData(CanonSpec, *DDD);
1827             Reader.PendingDefinitions.erase(D);
1828             Reader.MergedDeclContexts.insert(
1829                 std::make_pair(D, CanonDD->Definition));
1830             D->IsCompleteDefinition = false;
1831           } else {
1832             CanonSpec->DefinitionData = D->DefinitionData;
1833           }
1834         }
1835         D->DefinitionData = CanonSpec->DefinitionData;
1836       }
1837     }
1838   }
1839
1840   // Explicit info.
1841   if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1842     ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
1843         = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
1844     ExplicitInfo->TypeAsWritten = TyInfo;
1845     ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1846     ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1847     D->ExplicitInfo = ExplicitInfo;
1848   }
1849
1850   return Redecl;
1851 }
1852
1853 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
1854                                     ClassTemplatePartialSpecializationDecl *D) {
1855   RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
1856
1857   D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1858   D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
1859
1860   // These are read/set from/to the first declaration.
1861   if (ThisDeclID == Redecl.getFirstID()) {
1862     D->InstantiatedFromMember.setPointer(
1863       ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
1864     D->InstantiatedFromMember.setInt(Record[Idx++]);
1865   }
1866 }
1867
1868 void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
1869                                     ClassScopeFunctionSpecializationDecl *D) {
1870   VisitDecl(D);
1871   D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
1872 }
1873
1874 void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1875   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1876
1877   if (ThisDeclID == Redecl.getFirstID()) {
1878     // This FunctionTemplateDecl owns a CommonPtr; read it.
1879
1880     // Read the function specialization declaration IDs. The specializations
1881     // themselves will be loaded if they're needed.
1882     if (unsigned NumSpecs = Record[Idx++]) {
1883       // FIXME: Append specializations!
1884       FunctionTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1885       CommonPtr->LazySpecializations = new (Reader.getContext())
1886           serialization::DeclID[NumSpecs + 1];
1887       CommonPtr->LazySpecializations[0] = NumSpecs;
1888       for (unsigned I = 0; I != NumSpecs; ++I)
1889         CommonPtr->LazySpecializations[I + 1] = ReadDeclID(Record, Idx);
1890     }
1891   }
1892 }
1893
1894 /// TODO: Unify with ClassTemplateSpecializationDecl version?
1895 ///       May require unifying ClassTemplate(Partial)SpecializationDecl and
1896 ///        VarTemplate(Partial)SpecializationDecl with a new data
1897 ///        structure Template(Partial)SpecializationDecl, and
1898 ///        using Template(Partial)SpecializationDecl as input type.
1899 ASTDeclReader::RedeclarableResult
1900 ASTDeclReader::VisitVarTemplateSpecializationDeclImpl(
1901     VarTemplateSpecializationDecl *D) {
1902   RedeclarableResult Redecl = VisitVarDeclImpl(D);
1903
1904   ASTContext &C = Reader.getContext();
1905   if (Decl *InstD = ReadDecl(Record, Idx)) {
1906     if (VarTemplateDecl *VTD = dyn_cast<VarTemplateDecl>(InstD)) {
1907       D->SpecializedTemplate = VTD;
1908     } else {
1909       SmallVector<TemplateArgument, 8> TemplArgs;
1910       Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1911       TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(
1912           C, TemplArgs.data(), TemplArgs.size());
1913       VarTemplateSpecializationDecl::SpecializedPartialSpecialization *PS =
1914           new (C)
1915           VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
1916       PS->PartialSpecialization =
1917           cast<VarTemplatePartialSpecializationDecl>(InstD);
1918       PS->TemplateArgs = ArgList;
1919       D->SpecializedTemplate = PS;
1920     }
1921   }
1922
1923   // Explicit info.
1924   if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1925     VarTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo =
1926         new (C) VarTemplateSpecializationDecl::ExplicitSpecializationInfo;
1927     ExplicitInfo->TypeAsWritten = TyInfo;
1928     ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1929     ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1930     D->ExplicitInfo = ExplicitInfo;
1931   }
1932
1933   SmallVector<TemplateArgument, 8> TemplArgs;
1934   Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1935   D->TemplateArgs =
1936       TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
1937   D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1938   D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1939
1940   bool writtenAsCanonicalDecl = Record[Idx++];
1941   if (writtenAsCanonicalDecl) {
1942     VarTemplateDecl *CanonPattern = ReadDeclAs<VarTemplateDecl>(Record, Idx);
1943     if (D->isCanonicalDecl()) { // It's kept in the folding set.
1944       if (VarTemplatePartialSpecializationDecl *Partial =
1945               dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
1946         CanonPattern->getCommonPtr()->PartialSpecializations
1947             .GetOrInsertNode(Partial);
1948       } else {
1949         CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
1950       }
1951     }
1952   }
1953
1954   return Redecl;
1955 }
1956
1957 /// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
1958 ///       May require unifying ClassTemplate(Partial)SpecializationDecl and
1959 ///        VarTemplate(Partial)SpecializationDecl with a new data
1960 ///        structure Template(Partial)SpecializationDecl, and
1961 ///        using Template(Partial)SpecializationDecl as input type.
1962 void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
1963     VarTemplatePartialSpecializationDecl *D) {
1964   RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
1965
1966   D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1967   D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
1968
1969   // These are read/set from/to the first declaration.
1970   if (ThisDeclID == Redecl.getFirstID()) {
1971     D->InstantiatedFromMember.setPointer(
1972         ReadDeclAs<VarTemplatePartialSpecializationDecl>(Record, Idx));
1973     D->InstantiatedFromMember.setInt(Record[Idx++]);
1974   }
1975 }
1976
1977 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1978   VisitTypeDecl(D);
1979
1980   D->setDeclaredWithTypename(Record[Idx++]);
1981
1982   bool Inherited = Record[Idx++];
1983   TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
1984   D->setDefaultArgument(DefArg, Inherited);
1985 }
1986
1987 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1988   VisitDeclaratorDecl(D);
1989   // TemplateParmPosition.
1990   D->setDepth(Record[Idx++]);
1991   D->setPosition(Record[Idx++]);
1992   if (D->isExpandedParameterPack()) {
1993     void **Data = reinterpret_cast<void **>(D + 1);
1994     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1995       Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr();
1996       Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
1997     }
1998   } else {
1999     // Rest of NonTypeTemplateParmDecl.
2000     D->ParameterPack = Record[Idx++];
2001     if (Record[Idx++]) {
2002       Expr *DefArg = Reader.ReadExpr(F);
2003       bool Inherited = Record[Idx++];
2004       D->setDefaultArgument(DefArg, Inherited);
2005    }
2006   }
2007 }
2008
2009 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
2010   VisitTemplateDecl(D);
2011   // TemplateParmPosition.
2012   D->setDepth(Record[Idx++]);
2013   D->setPosition(Record[Idx++]);
2014   if (D->isExpandedParameterPack()) {
2015     void **Data = reinterpret_cast<void **>(D + 1);
2016     for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2017          I != N; ++I)
2018       Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
2019   } else {
2020     // Rest of TemplateTemplateParmDecl.
2021     TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
2022     bool IsInherited = Record[Idx++];
2023     D->setDefaultArgument(Arg, IsInherited);
2024     D->ParameterPack = Record[Idx++];
2025   }
2026 }
2027
2028 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2029   VisitRedeclarableTemplateDecl(D);
2030 }
2031
2032 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
2033   VisitDecl(D);
2034   D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
2035   D->AssertExprAndFailed.setInt(Record[Idx++]);
2036   D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
2037   D->RParenLoc = ReadSourceLocation(Record, Idx);
2038 }
2039
2040 void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {
2041   VisitDecl(D);
2042 }
2043
2044 std::pair<uint64_t, uint64_t>
2045 ASTDeclReader::VisitDeclContext(DeclContext *DC) {
2046   uint64_t LexicalOffset = Record[Idx++];
2047   uint64_t VisibleOffset = Record[Idx++];
2048   return std::make_pair(LexicalOffset, VisibleOffset);
2049 }
2050
2051 template <typename T>
2052 ASTDeclReader::RedeclarableResult
2053 ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
2054   DeclID FirstDeclID = ReadDeclID(Record, Idx);
2055
2056   // 0 indicates that this declaration was the only declaration of its entity,
2057   // and is used for space optimization.
2058   if (FirstDeclID == 0)
2059     FirstDeclID = ThisDeclID;
2060
2061   T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
2062   if (FirstDecl != D) {
2063     // We delay loading of the redeclaration chain to avoid deeply nested calls.
2064     // We temporarily set the first (canonical) declaration as the previous one
2065     // which is the one that matters and mark the real previous DeclID to be
2066     // loaded & attached later on.
2067     D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
2068   }
2069
2070   // Note that this declaration has been deserialized.
2071   Reader.RedeclsDeserialized.insert(static_cast<T *>(D));
2072
2073   // The result structure takes care to note that we need to load the
2074   // other declaration chains for this ID.
2075   return RedeclarableResult(Reader, FirstDeclID,
2076                             static_cast<T *>(D)->getKind());
2077 }
2078
2079 /// \brief Attempts to merge the given declaration (D) with another declaration
2080 /// of the same entity.
2081 template<typename T>
2082 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase,
2083                                       RedeclarableResult &Redecl,
2084                                       DeclID TemplatePatternID) {
2085   T *D = static_cast<T*>(DBase);
2086   T *DCanon = D->getCanonicalDecl();
2087   if (D != DCanon &&
2088       // IDs < NUM_PREDEF_DECL_IDS are not loaded from an AST file.
2089       Redecl.getFirstID() >= NUM_PREDEF_DECL_IDS &&
2090       (!Reader.getContext().getLangOpts().Modules ||
2091        Reader.getOwningModuleFile(DCanon) == Reader.getOwningModuleFile(D))) {
2092     // All redeclarations between this declaration and its originally-canonical
2093     // declaration get pulled in when we load DCanon; we don't need to
2094     // perform any more merging now.
2095     Redecl.suppress();
2096   }
2097
2098   // If modules are not available, there is no reason to perform this merge.
2099   if (!Reader.getContext().getLangOpts().Modules)
2100     return;
2101
2102   if (FindExistingResult ExistingRes = findExisting(D))
2103     if (T *Existing = ExistingRes)
2104       mergeRedeclarable(D, Existing, Redecl, TemplatePatternID);
2105 }
2106
2107 /// \brief "Cast" to type T, asserting if we don't have an implicit conversion.
2108 /// We use this to put code in a template that will only be valid for certain
2109 /// instantiations.
2110 template<typename T> static T assert_cast(T t) { return t; }
2111 template<typename T> static T assert_cast(...) {
2112   llvm_unreachable("bad assert_cast");
2113 }
2114
2115 /// \brief Merge together the pattern declarations from two template
2116 /// declarations.
2117 void ASTDeclReader::mergeTemplatePattern(RedeclarableTemplateDecl *D,
2118                                          RedeclarableTemplateDecl *Existing,
2119                                          DeclID DsID) {
2120   auto *DPattern = D->getTemplatedDecl();
2121   auto *ExistingPattern = Existing->getTemplatedDecl();
2122   RedeclarableResult Result(Reader, DPattern->getCanonicalDecl()->getGlobalID(),
2123                             DPattern->getKind());
2124   if (auto *DClass = dyn_cast<CXXRecordDecl>(DPattern)) {
2125     // Merge with any existing definition.
2126     // FIXME: This is duplicated in several places. Refactor.
2127     auto *ExistingClass =
2128         cast<CXXRecordDecl>(ExistingPattern)->getCanonicalDecl();
2129     if (auto *DDD = DClass->DefinitionData.getNotUpdated()) {
2130       if (auto *ExistingDD = ExistingClass->DefinitionData.getNotUpdated()) {
2131         MergeDefinitionData(ExistingClass, *DDD);
2132         Reader.PendingDefinitions.erase(DClass);
2133         Reader.MergedDeclContexts.insert(
2134             std::make_pair(DClass, ExistingDD->Definition));
2135         DClass->IsCompleteDefinition = false;
2136       } else {
2137         ExistingClass->DefinitionData = DClass->DefinitionData;
2138       }
2139     }
2140     DClass->DefinitionData = ExistingClass->DefinitionData;
2141
2142     return mergeRedeclarable(DClass, cast<TagDecl>(ExistingPattern),
2143                              Result);
2144   }
2145   if (auto *DFunction = dyn_cast<FunctionDecl>(DPattern))
2146     return mergeRedeclarable(DFunction, cast<FunctionDecl>(ExistingPattern),
2147                              Result);
2148   if (auto *DVar = dyn_cast<VarDecl>(DPattern))
2149     return mergeRedeclarable(DVar, cast<VarDecl>(ExistingPattern), Result);
2150   if (auto *DAlias = dyn_cast<TypeAliasDecl>(DPattern))
2151     return mergeRedeclarable(DAlias, cast<TypedefNameDecl>(ExistingPattern),
2152                              Result);
2153   llvm_unreachable("merged an unknown kind of redeclarable template");
2154 }
2155
2156 /// \brief Attempts to merge the given declaration (D) with another declaration
2157 /// of the same entity.
2158 template<typename T>
2159 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase, T *Existing,
2160                                       RedeclarableResult &Redecl,
2161                                       DeclID TemplatePatternID) {
2162   T *D = static_cast<T*>(DBase);
2163   T *ExistingCanon = Existing->getCanonicalDecl();
2164   T *DCanon = D->getCanonicalDecl();
2165   if (ExistingCanon != DCanon) {
2166     assert(DCanon->getGlobalID() == Redecl.getFirstID());
2167
2168     // Have our redeclaration link point back at the canonical declaration
2169     // of the existing declaration, so that this declaration has the
2170     // appropriate canonical declaration.
2171     D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
2172
2173     // When we merge a namespace, update its pointer to the first namespace.
2174     if (auto *Namespace = dyn_cast<NamespaceDecl>(D))
2175       Namespace->AnonOrFirstNamespaceAndInline.setPointer(
2176           assert_cast<NamespaceDecl*>(ExistingCanon));
2177
2178     // When we merge a template, merge its pattern.
2179     if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
2180       mergeTemplatePattern(
2181           DTemplate, assert_cast<RedeclarableTemplateDecl*>(ExistingCanon),
2182           TemplatePatternID);
2183
2184     // If this declaration was the canonical declaration, make a note of
2185     // that. We accept the linear algorithm here because the number of
2186     // unique canonical declarations of an entity should always be tiny.
2187     if (DCanon == D) {
2188       SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon];
2189       if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID())
2190             == Merged.end())
2191         Merged.push_back(Redecl.getFirstID());
2192     }
2193   }
2194 }
2195
2196 /// \brief Attempts to merge the given declaration (D) with another declaration
2197 /// of the same entity, for the case where the entity is not actually
2198 /// redeclarable. This happens, for instance, when merging the fields of
2199 /// identical class definitions from two different modules.
2200 template<typename T>
2201 void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
2202   // If modules are not available, there is no reason to perform this merge.
2203   if (!Reader.getContext().getLangOpts().Modules)
2204     return;
2205
2206   // ODR-based merging is only performed in C++. In C, identically-named things
2207   // in different translation units are not redeclarations (but may still have
2208   // compatible types).
2209   if (!Reader.getContext().getLangOpts().CPlusPlus)
2210     return;
2211
2212   if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
2213     if (T *Existing = ExistingRes)
2214       Reader.Context.setPrimaryMergedDecl(static_cast<T*>(D),
2215                                           Existing->getCanonicalDecl());
2216 }
2217
2218 void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
2219   VisitDecl(D);
2220   unsigned NumVars = D->varlist_size();
2221   SmallVector<Expr *, 16> Vars;
2222   Vars.reserve(NumVars);
2223   for (unsigned i = 0; i != NumVars; ++i) {
2224     Vars.push_back(Reader.ReadExpr(F));
2225   }
2226   D->setVars(Vars);
2227 }
2228
2229 //===----------------------------------------------------------------------===//
2230 // Attribute Reading
2231 //===----------------------------------------------------------------------===//
2232
2233 /// \brief Reads attributes from the current stream position.
2234 void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
2235                                const RecordData &Record, unsigned &Idx) {
2236   for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
2237     Attr *New = nullptr;
2238     attr::Kind Kind = (attr::Kind)Record[Idx++];
2239     SourceRange Range = ReadSourceRange(F, Record, Idx);
2240
2241 #include "clang/Serialization/AttrPCHRead.inc"
2242
2243     assert(New && "Unable to decode attribute?");
2244     Attrs.push_back(New);
2245   }
2246 }
2247
2248 //===----------------------------------------------------------------------===//
2249 // ASTReader Implementation
2250 //===----------------------------------------------------------------------===//
2251
2252 /// \brief Note that we have loaded the declaration with the given
2253 /// Index.
2254 ///
2255 /// This routine notes that this declaration has already been loaded,
2256 /// so that future GetDecl calls will return this declaration rather
2257 /// than trying to load a new declaration.
2258 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
2259   assert(!DeclsLoaded[Index] && "Decl loaded twice?");
2260   DeclsLoaded[Index] = D;
2261 }
2262
2263
2264 /// \brief Determine whether the consumer will be interested in seeing
2265 /// this declaration (via HandleTopLevelDecl).
2266 ///
2267 /// This routine should return true for anything that might affect
2268 /// code generation, e.g., inline function definitions, Objective-C
2269 /// declarations with metadata, etc.
2270 static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
2271   // An ObjCMethodDecl is never considered as "interesting" because its
2272   // implementation container always is.
2273
2274   if (isa<FileScopeAsmDecl>(D) ||
2275       isa<ObjCProtocolDecl>(D) ||
2276       isa<ObjCImplDecl>(D) ||
2277       isa<ImportDecl>(D) ||
2278       isa<OMPThreadPrivateDecl>(D))
2279     return true;
2280   if (VarDecl *Var = dyn_cast<VarDecl>(D))
2281     return Var->isFileVarDecl() &&
2282            Var->isThisDeclarationADefinition() == VarDecl::Definition;
2283   if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
2284     return Func->doesThisDeclarationHaveABody() || HasBody;
2285
2286   return false;
2287 }
2288
2289 /// \brief Get the correct cursor and offset for loading a declaration.
2290 ASTReader::RecordLocation
2291 ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) {
2292   // See if there's an override.
2293   DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
2294   if (It != ReplacedDecls.end()) {
2295     RawLocation = It->second.RawLoc;
2296     return RecordLocation(It->second.Mod, It->second.Offset);
2297   }
2298
2299   GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
2300   assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
2301   ModuleFile *M = I->second;
2302   const DeclOffset &
2303     DOffs =  M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
2304   RawLocation = DOffs.Loc;
2305   return RecordLocation(M, DOffs.BitOffset);
2306 }
2307
2308 ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
2309   ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
2310     = GlobalBitOffsetsMap.find(GlobalOffset);
2311
2312   assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
2313   return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
2314 }
2315
2316 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
2317   return LocalOffset + M.GlobalBitOffset;
2318 }
2319
2320 static bool isSameTemplateParameterList(const TemplateParameterList *X,
2321                                         const TemplateParameterList *Y);
2322
2323 /// \brief Determine whether two template parameters are similar enough
2324 /// that they may be used in declarations of the same template.
2325 static bool isSameTemplateParameter(const NamedDecl *X,
2326                                     const NamedDecl *Y) {
2327   if (X->getKind() != Y->getKind())
2328     return false;
2329
2330   if (const TemplateTypeParmDecl *TX = dyn_cast<TemplateTypeParmDecl>(X)) {
2331     const TemplateTypeParmDecl *TY = cast<TemplateTypeParmDecl>(Y);
2332     return TX->isParameterPack() == TY->isParameterPack();
2333   }
2334
2335   if (const NonTypeTemplateParmDecl *TX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
2336     const NonTypeTemplateParmDecl *TY = cast<NonTypeTemplateParmDecl>(Y);
2337     return TX->isParameterPack() == TY->isParameterPack() &&
2338            TX->getASTContext().hasSameType(TX->getType(), TY->getType());
2339   }
2340
2341   const TemplateTemplateParmDecl *TX = cast<TemplateTemplateParmDecl>(X);
2342   const TemplateTemplateParmDecl *TY = cast<TemplateTemplateParmDecl>(Y);
2343   return TX->isParameterPack() == TY->isParameterPack() &&
2344          isSameTemplateParameterList(TX->getTemplateParameters(),
2345                                      TY->getTemplateParameters());
2346 }
2347
2348 static NamespaceDecl *getNamespace(const NestedNameSpecifier *X) {
2349   if (auto *NS = X->getAsNamespace())
2350     return NS;
2351   if (auto *NAS = X->getAsNamespaceAlias())
2352     return NAS->getNamespace();
2353   return nullptr;
2354 }
2355
2356 static bool isSameQualifier(const NestedNameSpecifier *X,
2357                             const NestedNameSpecifier *Y) {
2358   if (auto *NSX = getNamespace(X)) {
2359     auto *NSY = getNamespace(Y);
2360     if (!NSY || NSX->getCanonicalDecl() != NSY->getCanonicalDecl())
2361       return false;
2362   } else if (X->getKind() != Y->getKind())
2363     return false;
2364
2365   // FIXME: For namespaces and types, we're permitted to check that the entity
2366   // is named via the same tokens. We should probably do so.
2367   switch (X->getKind()) {
2368   case NestedNameSpecifier::Identifier:
2369     if (X->getAsIdentifier() != Y->getAsIdentifier())
2370       return false;
2371     break;
2372   case NestedNameSpecifier::Namespace:
2373   case NestedNameSpecifier::NamespaceAlias:
2374     // We've already checked that we named the same namespace.
2375     break;
2376   case NestedNameSpecifier::TypeSpec:
2377   case NestedNameSpecifier::TypeSpecWithTemplate:
2378     if (X->getAsType()->getCanonicalTypeInternal() !=
2379         Y->getAsType()->getCanonicalTypeInternal())
2380       return false;
2381     break;
2382   case NestedNameSpecifier::Global:
2383   case NestedNameSpecifier::Super:
2384     return true;
2385   }
2386
2387   // Recurse into earlier portion of NNS, if any.
2388   auto *PX = X->getPrefix();
2389   auto *PY = Y->getPrefix();
2390   if (PX && PY)
2391     return isSameQualifier(PX, PY);
2392   return !PX && !PY;
2393 }
2394
2395 /// \brief Determine whether two template parameter lists are similar enough
2396 /// that they may be used in declarations of the same template.
2397 static bool isSameTemplateParameterList(const TemplateParameterList *X,
2398                                         const TemplateParameterList *Y) {
2399   if (X->size() != Y->size())
2400     return false;
2401
2402   for (unsigned I = 0, N = X->size(); I != N; ++I)
2403     if (!isSameTemplateParameter(X->getParam(I), Y->getParam(I)))
2404       return false;
2405
2406   return true;
2407 }
2408
2409 /// \brief Determine whether the two declarations refer to the same entity.
2410 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
2411   assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
2412
2413   if (X == Y)
2414     return true;
2415
2416   // Must be in the same context.
2417   if (!X->getDeclContext()->getRedeclContext()->Equals(
2418          Y->getDeclContext()->getRedeclContext()))
2419     return false;
2420
2421   // Two typedefs refer to the same entity if they have the same underlying
2422   // type.
2423   if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
2424     if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
2425       return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
2426                                             TypedefY->getUnderlyingType());
2427
2428   // Must have the same kind.
2429   if (X->getKind() != Y->getKind())
2430     return false;
2431
2432   // Objective-C classes and protocols with the same name always match.
2433   if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
2434     return true;
2435
2436   if (isa<ClassTemplateSpecializationDecl>(X)) {
2437     // No need to handle these here: we merge them when adding them to the
2438     // template.
2439     return false;
2440   }
2441
2442   // Compatible tags match.
2443   if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
2444     TagDecl *TagY = cast<TagDecl>(Y);
2445     return (TagX->getTagKind() == TagY->getTagKind()) ||
2446       ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
2447         TagX->getTagKind() == TTK_Interface) &&
2448        (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
2449         TagY->getTagKind() == TTK_Interface));
2450   }
2451
2452   // Functions with the same type and linkage match.
2453   // FIXME: This needs to cope with merging of prototyped/non-prototyped
2454   // functions, etc.
2455   if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
2456     FunctionDecl *FuncY = cast<FunctionDecl>(Y);
2457     return (FuncX->getLinkageInternal() == FuncY->getLinkageInternal()) &&
2458       FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
2459   }
2460
2461   // Variables with the same type and linkage match.
2462   if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
2463     VarDecl *VarY = cast<VarDecl>(Y);
2464     return (VarX->getLinkageInternal() == VarY->getLinkageInternal()) &&
2465       VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType());
2466   }
2467
2468   // Namespaces with the same name and inlinedness match.
2469   if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
2470     NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
2471     return NamespaceX->isInline() == NamespaceY->isInline();
2472   }
2473
2474   // Identical template names and kinds match if their template parameter lists
2475   // and patterns match.
2476   if (TemplateDecl *TemplateX = dyn_cast<TemplateDecl>(X)) {
2477     TemplateDecl *TemplateY = cast<TemplateDecl>(Y);
2478     return isSameEntity(TemplateX->getTemplatedDecl(),
2479                         TemplateY->getTemplatedDecl()) &&
2480            isSameTemplateParameterList(TemplateX->getTemplateParameters(),
2481                                        TemplateY->getTemplateParameters());
2482   }
2483
2484   // Fields with the same name and the same type match.
2485   if (FieldDecl *FDX = dyn_cast<FieldDecl>(X)) {
2486     FieldDecl *FDY = cast<FieldDecl>(Y);
2487     // FIXME: Also check the bitwidth is odr-equivalent, if any.
2488     return X->getASTContext().hasSameType(FDX->getType(), FDY->getType());
2489   }
2490
2491   // Enumerators with the same name match.
2492   if (isa<EnumConstantDecl>(X))
2493     // FIXME: Also check the value is odr-equivalent.
2494     return true;
2495
2496   // Using shadow declarations with the same target match.
2497   if (UsingShadowDecl *USX = dyn_cast<UsingShadowDecl>(X)) {
2498     UsingShadowDecl *USY = cast<UsingShadowDecl>(Y);
2499     return USX->getTargetDecl() == USY->getTargetDecl();
2500   }
2501
2502   // Using declarations with the same qualifier match. (We already know that
2503   // the name matches.)
2504   if (auto *UX = dyn_cast<UsingDecl>(X)) {
2505     auto *UY = cast<UsingDecl>(Y);
2506     return isSameQualifier(UX->getQualifier(), UY->getQualifier()) &&
2507            UX->hasTypename() == UY->hasTypename() &&
2508            UX->isAccessDeclaration() == UY->isAccessDeclaration();
2509   }
2510   if (auto *UX = dyn_cast<UnresolvedUsingValueDecl>(X)) {
2511     auto *UY = cast<UnresolvedUsingValueDecl>(Y);
2512     return isSameQualifier(UX->getQualifier(), UY->getQualifier()) &&
2513            UX->isAccessDeclaration() == UY->isAccessDeclaration();
2514   }
2515   if (auto *UX = dyn_cast<UnresolvedUsingTypenameDecl>(X))
2516     return isSameQualifier(
2517         UX->getQualifier(),
2518         cast<UnresolvedUsingTypenameDecl>(Y)->getQualifier());
2519
2520   // Namespace alias definitions with the same target match.
2521   if (auto *NAX = dyn_cast<NamespaceAliasDecl>(X)) {
2522     auto *NAY = cast<NamespaceAliasDecl>(Y);
2523     return NAX->getNamespace()->Equals(NAY->getNamespace());
2524   }
2525
2526   // FIXME: Many other cases to implement.
2527   return false;
2528 }
2529
2530 /// Find the context in which we should search for previous declarations when
2531 /// looking for declarations to merge.
2532 static DeclContext *getPrimaryContextForMerging(DeclContext *DC) {
2533   if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
2534     return ND->getOriginalNamespace();
2535
2536   // There is one tricky case here: if DC is a class with no definition, then
2537   // we're merging a declaration whose definition is added by an update record,
2538   // but we've not yet loaded that update record. In this case, we use the
2539   // canonical declaration for merging until we get a real definition.
2540   // FIXME: When we add a definition, we may need to move the partial lookup
2541   // information from the canonical declaration onto the chosen definition.
2542   if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC))
2543     return RD->getPrimaryContext();
2544
2545   if (EnumDecl *ED = dyn_cast<EnumDecl>(DC))
2546     return ED->getASTContext().getLangOpts().CPlusPlus? ED->getDefinition()
2547                                                       : nullptr;
2548
2549   return nullptr;
2550 }
2551
2552 ASTDeclReader::FindExistingResult::~FindExistingResult() {
2553   if (!AddResult || Existing)
2554     return;
2555
2556   DeclarationName Name = New->getDeclName();
2557   DeclContext *DC = New->getDeclContext()->getRedeclContext();
2558   if (TypedefNameForLinkage) {
2559     Reader.ImportedTypedefNamesForLinkage.insert(
2560         std::make_pair(std::make_pair(DC, TypedefNameForLinkage), New));
2561   } else if (!Name) {
2562     assert(needsAnonymousDeclarationNumber(New));
2563     setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(),
2564                                AnonymousDeclNumber, New);
2565   } else if (DC->isTranslationUnit() && Reader.SemaObj) {
2566     Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, Name);
2567   } else if (DeclContext *MergeDC = getPrimaryContextForMerging(DC)) {
2568     // Add the declaration to its redeclaration context so later merging
2569     // lookups will find it.
2570     MergeDC->makeDeclVisibleInContextImpl(New, /*Internal*/true);
2571   }
2572 }
2573
2574 /// Find the declaration that should be merged into, given the declaration found
2575 /// by name lookup. If we're merging an anonymous declaration within a typedef,
2576 /// we need a matching typedef, and we merge with the type inside it.
2577 static NamedDecl *getDeclForMerging(NamedDecl *Found,
2578                                     bool IsTypedefNameForLinkage) {
2579   if (!IsTypedefNameForLinkage)
2580     return Found;
2581
2582   // If we found a typedef declaration that gives a name to some other
2583   // declaration, then we want that inner declaration. Declarations from
2584   // AST files are handled via ImportedTypedefNamesForLinkage.
2585   if (Found->isFromASTFile()) return 0;
2586   if (auto *TND = dyn_cast<TypedefNameDecl>(Found)) {
2587     if (auto *TT = TND->getTypeSourceInfo()->getType()->getAs<TagType>())
2588       if (TT->getDecl()->getTypedefNameForAnonDecl() == TND)
2589         return TT->getDecl();
2590   }
2591
2592   return 0;
2593 }
2594
2595 NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,
2596                                                      DeclContext *DC,
2597                                                      unsigned Index) {
2598   // If the lexical context has been merged, look into the now-canonical
2599   // definition.
2600   if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
2601     DC = Merged;
2602
2603   // If we've seen this before, return the canonical declaration.
2604   auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
2605   if (Index < Previous.size() && Previous[Index])
2606     return Previous[Index];
2607
2608   // If this is the first time, but we have parsed a declaration of the context,
2609   // build the anonymous declaration list from the parsed declaration.
2610   if (!cast<Decl>(DC)->isFromASTFile()) {
2611     unsigned Index = 0;
2612     for (Decl *LexicalD : DC->decls()) {
2613       auto *ND = dyn_cast<NamedDecl>(LexicalD);
2614       if (!ND || !needsAnonymousDeclarationNumber(ND))
2615         continue;
2616       if (Previous.size() == Index)
2617         Previous.push_back(cast<NamedDecl>(ND->getCanonicalDecl()));
2618       else
2619         Previous[Index] = cast<NamedDecl>(ND->getCanonicalDecl());
2620       ++Index;
2621     }
2622   }
2623
2624   return Index < Previous.size() ? Previous[Index] : nullptr;
2625 }
2626
2627 void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,
2628                                                DeclContext *DC, unsigned Index,
2629                                                NamedDecl *D) {
2630   if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
2631     DC = Merged;
2632
2633   auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
2634   if (Index >= Previous.size())
2635     Previous.resize(Index + 1);
2636   if (!Previous[Index])
2637     Previous[Index] = D;
2638 }
2639
2640 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
2641   DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage
2642                                                : D->getDeclName();
2643
2644   if (!Name && !needsAnonymousDeclarationNumber(D)) {
2645     // Don't bother trying to find unnamed declarations that are in
2646     // unmergeable contexts.
2647     FindExistingResult Result(Reader, D, /*Existing=*/nullptr,
2648                               AnonymousDeclNumber, TypedefNameForLinkage);
2649     // FIXME: We may still need to pull in the redeclaration chain; there can
2650     // be redeclarations via 'decltype'.
2651     Result.suppress();
2652     return Result;
2653   }
2654
2655   // FIXME: Bail out for non-canonical declarations. We will have performed any
2656   // necessary merging already.
2657
2658   DeclContext *DC = D->getDeclContext()->getRedeclContext();
2659   if (TypedefNameForLinkage) {
2660     auto It = Reader.ImportedTypedefNamesForLinkage.find(
2661         std::make_pair(DC, TypedefNameForLinkage));
2662     if (It != Reader.ImportedTypedefNamesForLinkage.end())
2663       if (isSameEntity(It->second, D))
2664         return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,
2665                                   TypedefNameForLinkage);
2666     // Go on to check in other places in case an existing typedef name
2667     // was not imported.
2668   }
2669
2670   if (!Name) {
2671     // This is an anonymous declaration that we may need to merge. Look it up
2672     // in its context by number.
2673     assert(needsAnonymousDeclarationNumber(D));
2674     if (auto *Existing = getAnonymousDeclForMerging(
2675             Reader, D->getLexicalDeclContext(), AnonymousDeclNumber))
2676       if (isSameEntity(Existing, D))
2677         return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2678                                   TypedefNameForLinkage);
2679   } else if (DC->isTranslationUnit() && Reader.SemaObj) {
2680     IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
2681
2682     // Temporarily consider the identifier to be up-to-date. We don't want to
2683     // cause additional lookups here.
2684     class UpToDateIdentifierRAII {
2685       IdentifierInfo *II;
2686       bool WasOutToDate;
2687
2688     public:
2689       explicit UpToDateIdentifierRAII(IdentifierInfo *II)
2690         : II(II), WasOutToDate(false)
2691       {
2692         if (II) {
2693           WasOutToDate = II->isOutOfDate();
2694           if (WasOutToDate)
2695             II->setOutOfDate(false);
2696         }
2697       }
2698
2699       ~UpToDateIdentifierRAII() {
2700         if (WasOutToDate)
2701           II->setOutOfDate(true);
2702       }
2703     } UpToDate(Name.getAsIdentifierInfo());
2704
2705     for (IdentifierResolver::iterator I = IdResolver.begin(Name),
2706                                    IEnd = IdResolver.end();
2707          I != IEnd; ++I) {
2708       if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
2709         if (isSameEntity(Existing, D))
2710           return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2711                                     TypedefNameForLinkage);
2712     }
2713   } else if (DeclContext *MergeDC = getPrimaryContextForMerging(DC)) {
2714     DeclContext::lookup_result R = MergeDC->noload_lookup(Name);
2715     for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
2716       if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
2717         if (isSameEntity(Existing, D))
2718           return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2719                                     TypedefNameForLinkage);
2720     }
2721   } else {
2722     // Not in a mergeable context.
2723     return FindExistingResult(Reader);
2724   }
2725
2726   // If this declaration is from a merged context, make a note that we need to
2727   // check that the canonical definition of that context contains the decl.
2728   //
2729   // FIXME: We should do something similar if we merge two definitions of the
2730   // same template specialization into the same CXXRecordDecl.
2731   auto MergedDCIt = Reader.MergedDeclContexts.find(D->getLexicalDeclContext());
2732   if (MergedDCIt != Reader.MergedDeclContexts.end() &&
2733       MergedDCIt->second == D->getDeclContext())
2734     Reader.PendingOdrMergeChecks.push_back(D);
2735
2736   return FindExistingResult(Reader, D, /*Existing=*/nullptr,
2737                             AnonymousDeclNumber, TypedefNameForLinkage);
2738 }
2739
2740 template<typename DeclT>
2741 void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
2742                                            Redeclarable<DeclT> *D,
2743                                            Decl *Previous) {
2744   D->RedeclLink.setPrevious(cast<DeclT>(Previous));
2745 }
2746 namespace clang {
2747 template<>
2748 void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
2749                                            Redeclarable<FunctionDecl> *D,
2750                                            Decl *Previous) {
2751   FunctionDecl *FD = static_cast<FunctionDecl*>(D);
2752   FunctionDecl *PrevFD = cast<FunctionDecl>(Previous);
2753
2754   FD->RedeclLink.setPrevious(PrevFD);
2755
2756   // If the previous declaration is an inline function declaration, then this
2757   // declaration is too.
2758   if (PrevFD->IsInline != FD->IsInline) {
2759     // FIXME: [dcl.fct.spec]p4:
2760     //   If a function with external linkage is declared inline in one
2761     //   translation unit, it shall be declared inline in all translation
2762     //   units in which it appears.
2763     //
2764     // Be careful of this case:
2765     //
2766     // module A:
2767     //   template<typename T> struct X { void f(); };
2768     //   template<typename T> inline void X<T>::f() {}
2769     //
2770     // module B instantiates the declaration of X<int>::f
2771     // module C instantiates the definition of X<int>::f
2772     //
2773     // If module B and C are merged, we do not have a violation of this rule.
2774     FD->IsInline = true;
2775   }
2776
2777   // If this declaration has an unresolved exception specification but the
2778   // previous declaration had a resolved one, resolve the exception
2779   // specification now.
2780   auto *FPT = FD->getType()->getAs<FunctionProtoType>();
2781   auto *PrevFPT = PrevFD->getType()->getAs<FunctionProtoType>();
2782   if (FPT && PrevFPT &&
2783       isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
2784       !isUnresolvedExceptionSpec(PrevFPT->getExceptionSpecType())) {
2785     Reader.Context.adjustExceptionSpec(
2786         FD, PrevFPT->getExtProtoInfo().ExceptionSpec);
2787   }
2788 }
2789 }
2790 void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader, ...) {
2791   llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");
2792 }
2793
2794 void ASTDeclReader::attachPreviousDecl(ASTReader &Reader, Decl *D,
2795                                        Decl *Previous) {
2796   assert(D && Previous);
2797
2798   switch (D->getKind()) {
2799 #define ABSTRACT_DECL(TYPE)
2800 #define DECL(TYPE, BASE)                                           \
2801   case Decl::TYPE:                                                 \
2802     attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous); \
2803     break;
2804 #include "clang/AST/DeclNodes.inc"
2805   }
2806
2807   // If the declaration was visible in one module, a redeclaration of it in
2808   // another module remains visible even if it wouldn't be visible by itself.
2809   //
2810   // FIXME: In this case, the declaration should only be visible if a module
2811   //        that makes it visible has been imported.
2812   D->IdentifierNamespace |=
2813       Previous->IdentifierNamespace &
2814       (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
2815
2816   // If the previous declaration is marked as used, then this declaration should
2817   // be too.
2818   if (Previous->Used)
2819     D->Used = true;
2820 }
2821
2822 template<typename DeclT>
2823 void ASTDeclReader::attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest) {
2824   D->RedeclLink.setLatest(cast<DeclT>(Latest));
2825 }
2826 void ASTDeclReader::attachLatestDeclImpl(...) {
2827   llvm_unreachable("attachLatestDecl on non-redeclarable declaration");
2828 }
2829
2830 void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
2831   assert(D && Latest);
2832
2833   switch (D->getKind()) {
2834 #define ABSTRACT_DECL(TYPE)
2835 #define DECL(TYPE, BASE)                                  \
2836   case Decl::TYPE:                                        \
2837     attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
2838     break;
2839 #include "clang/AST/DeclNodes.inc"
2840   }
2841 }
2842
2843 template<typename DeclT>
2844 void ASTDeclReader::markIncompleteDeclChainImpl(Redeclarable<DeclT> *D) {
2845   D->RedeclLink.markIncomplete();
2846 }
2847 void ASTDeclReader::markIncompleteDeclChainImpl(...) {
2848   llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");
2849 }
2850
2851 void ASTReader::markIncompleteDeclChain(Decl *D) {
2852   switch (D->getKind()) {
2853 #define ABSTRACT_DECL(TYPE)
2854 #define DECL(TYPE, BASE)                                             \
2855   case Decl::TYPE:                                                   \
2856     ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
2857     break;
2858 #include "clang/AST/DeclNodes.inc"
2859   }
2860 }
2861
2862 ASTReader::MergedDeclsMap::iterator
2863 ASTReader::combineStoredMergedDecls(Decl *Canon, GlobalDeclID CanonID) {
2864   // If we don't have any stored merged declarations, just look in the
2865   // merged declarations set.
2866   StoredMergedDeclsMap::iterator StoredPos = StoredMergedDecls.find(CanonID);
2867   if (StoredPos == StoredMergedDecls.end())
2868     return MergedDecls.find(Canon);
2869
2870   // Append the stored merged declarations to the merged declarations set.
2871   MergedDeclsMap::iterator Pos = MergedDecls.find(Canon);
2872   if (Pos == MergedDecls.end())
2873     Pos = MergedDecls.insert(std::make_pair(Canon,
2874                                             SmallVector<DeclID, 2>())).first;
2875   Pos->second.append(StoredPos->second.begin(), StoredPos->second.end());
2876   StoredMergedDecls.erase(StoredPos);
2877
2878   // Sort and uniquify the set of merged declarations.
2879   llvm::array_pod_sort(Pos->second.begin(), Pos->second.end());
2880   Pos->second.erase(std::unique(Pos->second.begin(), Pos->second.end()),
2881                     Pos->second.end());
2882   return Pos;
2883 }
2884
2885 /// \brief Read the declaration at the given offset from the AST file.
2886 Decl *ASTReader::ReadDeclRecord(DeclID ID) {
2887   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
2888   unsigned RawLocation = 0;
2889   RecordLocation Loc = DeclCursorForID(ID, RawLocation);
2890   llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
2891   // Keep track of where we are in the stream, then jump back there
2892   // after reading this declaration.
2893   SavedStreamPosition SavedPosition(DeclsCursor);
2894
2895   ReadingKindTracker ReadingKind(Read_Decl, *this);
2896
2897   // Note that we are loading a declaration record.
2898   Deserializing ADecl(this);
2899
2900   DeclsCursor.JumpToBit(Loc.Offset);
2901   RecordData Record;
2902   unsigned Code = DeclsCursor.ReadCode();
2903   unsigned Idx = 0;
2904   ASTDeclReader Reader(*this, *Loc.F, ID, RawLocation, Record,Idx);
2905
2906   Decl *D = nullptr;
2907   switch ((DeclCode)DeclsCursor.readRecord(Code, Record)) {
2908   case DECL_CONTEXT_LEXICAL:
2909   case DECL_CONTEXT_VISIBLE:
2910     llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
2911   case DECL_TYPEDEF:
2912     D = TypedefDecl::CreateDeserialized(Context, ID);
2913     break;
2914   case DECL_TYPEALIAS:
2915     D = TypeAliasDecl::CreateDeserialized(Context, ID);
2916     break;
2917   case DECL_ENUM:
2918     D = EnumDecl::CreateDeserialized(Context, ID);
2919     break;
2920   case DECL_RECORD:
2921     D = RecordDecl::CreateDeserialized(Context, ID);
2922     break;
2923   case DECL_ENUM_CONSTANT:
2924     D = EnumConstantDecl::CreateDeserialized(Context, ID);
2925     break;
2926   case DECL_FUNCTION:
2927     D = FunctionDecl::CreateDeserialized(Context, ID);
2928     break;
2929   case DECL_LINKAGE_SPEC:
2930     D = LinkageSpecDecl::CreateDeserialized(Context, ID);
2931     break;
2932   case DECL_LABEL:
2933     D = LabelDecl::CreateDeserialized(Context, ID);
2934     break;
2935   case DECL_NAMESPACE:
2936     D = NamespaceDecl::CreateDeserialized(Context, ID);
2937     break;
2938   case DECL_NAMESPACE_ALIAS:
2939     D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
2940     break;
2941   case DECL_USING:
2942     D = UsingDecl::CreateDeserialized(Context, ID);
2943     break;
2944   case DECL_USING_SHADOW:
2945     D = UsingShadowDecl::CreateDeserialized(Context, ID);
2946     break;
2947   case DECL_USING_DIRECTIVE:
2948     D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
2949     break;
2950   case DECL_UNRESOLVED_USING_VALUE:
2951     D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
2952     break;
2953   case DECL_UNRESOLVED_USING_TYPENAME:
2954     D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
2955     break;
2956   case DECL_CXX_RECORD:
2957     D = CXXRecordDecl::CreateDeserialized(Context, ID);
2958     break;
2959   case DECL_CXX_METHOD:
2960     D = CXXMethodDecl::CreateDeserialized(Context, ID);
2961     break;
2962   case DECL_CXX_CONSTRUCTOR:
2963     D = CXXConstructorDecl::CreateDeserialized(Context, ID);
2964     break;
2965   case DECL_CXX_DESTRUCTOR:
2966     D = CXXDestructorDecl::CreateDeserialized(Context, ID);
2967     break;
2968   case DECL_CXX_CONVERSION:
2969     D = CXXConversionDecl::CreateDeserialized(Context, ID);
2970     break;
2971   case DECL_ACCESS_SPEC:
2972     D = AccessSpecDecl::CreateDeserialized(Context, ID);
2973     break;
2974   case DECL_FRIEND:
2975     D = FriendDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2976     break;
2977   case DECL_FRIEND_TEMPLATE:
2978     D = FriendTemplateDecl::CreateDeserialized(Context, ID);
2979     break;
2980   case DECL_CLASS_TEMPLATE:
2981     D = ClassTemplateDecl::CreateDeserialized(Context, ID);
2982     break;
2983   case DECL_CLASS_TEMPLATE_SPECIALIZATION:
2984     D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
2985     break;
2986   case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
2987     D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
2988     break;
2989   case DECL_VAR_TEMPLATE:
2990     D = VarTemplateDecl::CreateDeserialized(Context, ID);
2991     break;
2992   case DECL_VAR_TEMPLATE_SPECIALIZATION:
2993     D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);
2994     break;
2995   case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
2996     D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
2997     break;
2998   case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
2999     D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
3000     break;
3001   case DECL_FUNCTION_TEMPLATE:
3002     D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
3003     break;
3004   case DECL_TEMPLATE_TYPE_PARM:
3005     D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
3006     break;
3007   case DECL_NON_TYPE_TEMPLATE_PARM:
3008     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
3009     break;
3010   case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
3011     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3012     break;
3013   case DECL_TEMPLATE_TEMPLATE_PARM:
3014     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
3015     break;
3016   case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
3017     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
3018                                                      Record[Idx++]);
3019     break;
3020   case DECL_TYPE_ALIAS_TEMPLATE:
3021     D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
3022     break;
3023   case DECL_STATIC_ASSERT:
3024     D = StaticAssertDecl::CreateDeserialized(Context, ID);
3025     break;
3026   case DECL_OBJC_METHOD:
3027     D = ObjCMethodDecl::CreateDeserialized(Context, ID);
3028     break;
3029   case DECL_OBJC_INTERFACE:
3030     D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
3031     break;
3032   case DECL_OBJC_IVAR:
3033     D = ObjCIvarDecl::CreateDeserialized(Context, ID);
3034     break;
3035   case DECL_OBJC_PROTOCOL:
3036     D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
3037     break;
3038   case DECL_OBJC_AT_DEFS_FIELD:
3039     D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
3040     break;
3041   case DECL_OBJC_CATEGORY:
3042     D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
3043     break;
3044   case DECL_OBJC_CATEGORY_IMPL:
3045     D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
3046     break;
3047   case DECL_OBJC_IMPLEMENTATION:
3048     D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
3049     break;
3050   case DECL_OBJC_COMPATIBLE_ALIAS:
3051     D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
3052     break;
3053   case DECL_OBJC_PROPERTY:
3054     D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
3055     break;
3056   case DECL_OBJC_PROPERTY_IMPL:
3057     D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
3058     break;
3059   case DECL_FIELD:
3060     D = FieldDecl::CreateDeserialized(Context, ID);
3061     break;
3062   case DECL_INDIRECTFIELD:
3063     D = IndirectFieldDecl::CreateDeserialized(Context, ID);
3064     break;
3065   case DECL_VAR:
3066     D = VarDecl::CreateDeserialized(Context, ID);
3067     break;
3068   case DECL_IMPLICIT_PARAM:
3069     D = ImplicitParamDecl::CreateDeserialized(Context, ID);
3070     break;
3071   case DECL_PARM_VAR:
3072     D = ParmVarDecl::CreateDeserialized(Context, ID);
3073     break;
3074   case DECL_FILE_SCOPE_ASM:
3075     D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
3076     break;
3077   case DECL_BLOCK:
3078     D = BlockDecl::CreateDeserialized(Context, ID);
3079     break;
3080   case DECL_MS_PROPERTY:
3081     D = MSPropertyDecl::CreateDeserialized(Context, ID);
3082     break;
3083   case DECL_CAPTURED:
3084     D = CapturedDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3085     break;
3086   case DECL_CXX_BASE_SPECIFIERS:
3087     Error("attempt to read a C++ base-specifier record as a declaration");
3088     return nullptr;
3089   case DECL_IMPORT:
3090     // Note: last entry of the ImportDecl record is the number of stored source
3091     // locations.
3092     D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
3093     break;
3094   case DECL_OMP_THREADPRIVATE:
3095     D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3096     break;
3097   case DECL_EMPTY:
3098     D = EmptyDecl::CreateDeserialized(Context, ID);
3099     break;
3100   }
3101
3102   assert(D && "Unknown declaration reading AST file");
3103   LoadedDecl(Index, D);
3104   // Set the DeclContext before doing any deserialization, to make sure internal
3105   // calls to Decl::getASTContext() by Decl's methods will find the
3106   // TranslationUnitDecl without crashing.
3107   D->setDeclContext(Context.getTranslationUnitDecl());
3108   Reader.Visit(D);
3109
3110   // If this declaration is also a declaration context, get the
3111   // offsets for its tables of lexical and visible declarations.
3112   if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
3113     // FIXME: This should really be
3114     //     DeclContext *LookupDC = DC->getPrimaryContext();
3115     // but that can walk the redeclaration chain, which might not work yet.
3116     DeclContext *LookupDC = DC;
3117     if (isa<NamespaceDecl>(DC))
3118       LookupDC = DC->getPrimaryContext();
3119     std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
3120     if (Offsets.first || Offsets.second) {
3121       if (Offsets.first != 0)
3122         DC->setHasExternalLexicalStorage(true);
3123       if (Offsets.second != 0)
3124         LookupDC->setHasExternalVisibleStorage(true);
3125       if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets,
3126                                  Loc.F->DeclContextInfos[DC]))
3127         return nullptr;
3128     }
3129
3130     // Now add the pending visible updates for this decl context, if it has any.
3131     DeclContextVisibleUpdatesPending::iterator I =
3132         PendingVisibleUpdates.find(ID);
3133     if (I != PendingVisibleUpdates.end()) {
3134       // There are updates. This means the context has external visible
3135       // storage, even if the original stored version didn't.
3136       LookupDC->setHasExternalVisibleStorage(true);
3137       for (const auto &Update : I->second) {
3138         DeclContextInfo &Info = Update.second->DeclContextInfos[DC];
3139         delete Info.NameLookupTableData;
3140         Info.NameLookupTableData = Update.first;
3141       }
3142       PendingVisibleUpdates.erase(I);
3143     }
3144   }
3145   assert(Idx == Record.size());
3146
3147   // Load any relevant update records.
3148   PendingUpdateRecords.push_back(std::make_pair(ID, D));
3149
3150   // Load the categories after recursive loading is finished.
3151   if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
3152     if (Class->isThisDeclarationADefinition())
3153       loadObjCCategories(ID, Class);
3154
3155   // If we have deserialized a declaration that has a definition the
3156   // AST consumer might need to know about, queue it.
3157   // We don't pass it to the consumer immediately because we may be in recursive
3158   // loading, and some declarations may still be initializing.
3159   if (isConsumerInterestedIn(D, Reader.hasPendingBody()))
3160     InterestingDecls.push_back(D);
3161
3162   return D;
3163 }
3164
3165 void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
3166   // The declaration may have been modified by files later in the chain.
3167   // If this is the case, read the record containing the updates from each file
3168   // and pass it to ASTDeclReader to make the modifications.
3169   DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
3170   if (UpdI != DeclUpdateOffsets.end()) {
3171     FileOffsetsTy &UpdateOffsets = UpdI->second;
3172     bool WasInteresting = isConsumerInterestedIn(D, false);
3173     for (FileOffsetsTy::iterator
3174          I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
3175       ModuleFile *F = I->first;
3176       uint64_t Offset = I->second;
3177       llvm::BitstreamCursor &Cursor = F->DeclsCursor;
3178       SavedStreamPosition SavedPosition(Cursor);
3179       Cursor.JumpToBit(Offset);
3180       RecordData Record;
3181       unsigned Code = Cursor.ReadCode();
3182       unsigned RecCode = Cursor.readRecord(Code, Record);
3183       (void)RecCode;
3184       assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
3185
3186       unsigned Idx = 0;
3187       ASTDeclReader Reader(*this, *F, ID, 0, Record, Idx);
3188       Reader.UpdateDecl(D, *F, Record);
3189
3190       // We might have made this declaration interesting. If so, remember that
3191       // we need to hand it off to the consumer.
3192       if (!WasInteresting &&
3193           isConsumerInterestedIn(D, Reader.hasPendingBody())) {
3194         InterestingDecls.push_back(D);
3195         WasInteresting = true;
3196       }
3197     }
3198   }
3199 }
3200
3201 namespace {
3202   /// \brief Module visitor class that finds all of the redeclarations of a
3203   ///
3204   class RedeclChainVisitor {
3205     ASTReader &Reader;
3206     SmallVectorImpl<DeclID> &SearchDecls;
3207     llvm::SmallPtrSetImpl<Decl *> &Deserialized;
3208     GlobalDeclID CanonID;
3209     SmallVector<Decl *, 4> Chain;
3210
3211   public:
3212     RedeclChainVisitor(ASTReader &Reader, SmallVectorImpl<DeclID> &SearchDecls,
3213                        llvm::SmallPtrSetImpl<Decl *> &Deserialized,
3214                        GlobalDeclID CanonID)
3215       : Reader(Reader), SearchDecls(SearchDecls), Deserialized(Deserialized),
3216         CanonID(CanonID) {
3217       for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
3218         addToChain(Reader.GetDecl(SearchDecls[I]));
3219     }
3220
3221     static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
3222       if (Preorder)
3223         return false;
3224
3225       return static_cast<RedeclChainVisitor *>(UserData)->visit(M);
3226     }
3227
3228     void addToChain(Decl *D) {
3229       if (!D)
3230         return;
3231
3232       if (Deserialized.erase(D))
3233         Chain.push_back(D);
3234     }
3235
3236     void searchForID(ModuleFile &M, GlobalDeclID GlobalID) {
3237       // Map global ID of the first declaration down to the local ID
3238       // used in this module file.
3239       DeclID ID = Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID);
3240       if (!ID)
3241         return;
3242
3243       // Perform a binary search to find the local redeclarations for this
3244       // declaration (if any).
3245       const LocalRedeclarationsInfo Compare = { ID, 0 };
3246       const LocalRedeclarationsInfo *Result
3247         = std::lower_bound(M.RedeclarationsMap,
3248                            M.RedeclarationsMap + M.LocalNumRedeclarationsInMap,
3249                            Compare);
3250       if (Result == M.RedeclarationsMap + M.LocalNumRedeclarationsInMap ||
3251           Result->FirstID != ID) {
3252         // If we have a previously-canonical singleton declaration that was
3253         // merged into another redeclaration chain, create a trivial chain
3254         // for this single declaration so that it will get wired into the
3255         // complete redeclaration chain.
3256         if (GlobalID != CanonID &&
3257             GlobalID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
3258             GlobalID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls) {
3259           addToChain(Reader.GetDecl(GlobalID));
3260         }
3261
3262         return;
3263       }
3264
3265       // Dig out all of the redeclarations.
3266       unsigned Offset = Result->Offset;
3267       unsigned N = M.RedeclarationChains[Offset];
3268       M.RedeclarationChains[Offset++] = 0; // Don't try to deserialize again
3269       for (unsigned I = 0; I != N; ++I)
3270         addToChain(Reader.GetLocalDecl(M, M.RedeclarationChains[Offset++]));
3271     }
3272
3273     bool visit(ModuleFile &M) {
3274       // Visit each of the declarations.
3275       for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
3276         searchForID(M, SearchDecls[I]);
3277       // FIXME: If none of the SearchDecls had local IDs in this module, can
3278       // we avoid searching any ancestor module files?
3279       return false;
3280     }
3281
3282     ArrayRef<Decl *> getChain() const {
3283       return Chain;
3284     }
3285   };
3286 }
3287
3288 void ASTReader::loadPendingDeclChain(serialization::GlobalDeclID ID) {
3289   Decl *D = GetDecl(ID);
3290   Decl *CanonDecl = D->getCanonicalDecl();
3291
3292   // Determine the set of declaration IDs we'll be searching for.
3293   SmallVector<DeclID, 1> SearchDecls;
3294   GlobalDeclID CanonID = 0;
3295   if (D == CanonDecl) {
3296     SearchDecls.push_back(ID); // Always first.
3297     CanonID = ID;
3298   }
3299   MergedDeclsMap::iterator MergedPos = combineStoredMergedDecls(CanonDecl, ID);
3300   if (MergedPos != MergedDecls.end())
3301     SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end());
3302
3303   // Build up the list of redeclarations.
3304   RedeclChainVisitor Visitor(*this, SearchDecls, RedeclsDeserialized, CanonID);
3305   ModuleMgr.visitDepthFirst(&RedeclChainVisitor::visit, &Visitor);
3306
3307   // Retrieve the chains.
3308   ArrayRef<Decl *> Chain = Visitor.getChain();
3309   if (Chain.empty())
3310     return;
3311
3312   // Hook up the chains.
3313   Decl *MostRecent = CanonDecl->getMostRecentDecl();
3314   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3315     if (Chain[I] == CanonDecl)
3316       continue;
3317
3318     ASTDeclReader::attachPreviousDecl(*this, Chain[I], MostRecent);
3319     MostRecent = Chain[I];
3320   }
3321
3322   ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
3323 }
3324
3325 namespace {
3326   /// \brief Given an ObjC interface, goes through the modules and links to the
3327   /// interface all the categories for it.
3328   class ObjCCategoriesVisitor {
3329     ASTReader &Reader;
3330     serialization::GlobalDeclID InterfaceID;
3331     ObjCInterfaceDecl *Interface;
3332     llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;
3333     unsigned PreviousGeneration;
3334     ObjCCategoryDecl *Tail;
3335     llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
3336
3337     void add(ObjCCategoryDecl *Cat) {
3338       // Only process each category once.
3339       if (!Deserialized.erase(Cat))
3340         return;
3341
3342       // Check for duplicate categories.
3343       if (Cat->getDeclName()) {
3344         ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
3345         if (Existing &&
3346             Reader.getOwningModuleFile(Existing)
3347                                           != Reader.getOwningModuleFile(Cat)) {
3348           // FIXME: We should not warn for duplicates in diamond:
3349           //
3350           //   MT     //
3351           //  /  \    //
3352           // ML  MR   //
3353           //  \  /    //
3354           //   MB     //
3355           //
3356           // If there are duplicates in ML/MR, there will be warning when
3357           // creating MB *and* when importing MB. We should not warn when
3358           // importing.
3359           Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
3360             << Interface->getDeclName() << Cat->getDeclName();
3361           Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
3362         } else if (!Existing) {
3363           // Record this category.
3364           Existing = Cat;
3365         }
3366       }
3367
3368       // Add this category to the end of the chain.
3369       if (Tail)
3370         ASTDeclReader::setNextObjCCategory(Tail, Cat);
3371       else
3372         Interface->setCategoryListRaw(Cat);
3373       Tail = Cat;
3374     }
3375
3376   public:
3377     ObjCCategoriesVisitor(ASTReader &Reader,
3378                           serialization::GlobalDeclID InterfaceID,
3379                           ObjCInterfaceDecl *Interface,
3380                         llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,
3381                           unsigned PreviousGeneration)
3382       : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
3383         Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
3384         Tail(nullptr)
3385     {
3386       // Populate the name -> category map with the set of known categories.
3387       for (auto *Cat : Interface->known_categories()) {
3388         if (Cat->getDeclName())
3389           NameCategoryMap[Cat->getDeclName()] = Cat;
3390
3391         // Keep track of the tail of the category list.
3392         Tail = Cat;
3393       }
3394     }
3395
3396     static bool visit(ModuleFile &M, void *UserData) {
3397       return static_cast<ObjCCategoriesVisitor *>(UserData)->visit(M);
3398     }
3399
3400     bool visit(ModuleFile &M) {
3401       // If we've loaded all of the category information we care about from
3402       // this module file, we're done.
3403       if (M.Generation <= PreviousGeneration)
3404         return true;
3405
3406       // Map global ID of the definition down to the local ID used in this
3407       // module file. If there is no such mapping, we'll find nothing here
3408       // (or in any module it imports).
3409       DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
3410       if (!LocalID)
3411         return true;
3412
3413       // Perform a binary search to find the local redeclarations for this
3414       // declaration (if any).
3415       const ObjCCategoriesInfo Compare = { LocalID, 0 };
3416       const ObjCCategoriesInfo *Result
3417         = std::lower_bound(M.ObjCCategoriesMap,
3418                            M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
3419                            Compare);
3420       if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
3421           Result->DefinitionID != LocalID) {
3422         // We didn't find anything. If the class definition is in this module
3423         // file, then the module files it depends on cannot have any categories,
3424         // so suppress further lookup.
3425         return Reader.isDeclIDFromModule(InterfaceID, M);
3426       }
3427
3428       // We found something. Dig out all of the categories.
3429       unsigned Offset = Result->Offset;
3430       unsigned N = M.ObjCCategories[Offset];
3431       M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
3432       for (unsigned I = 0; I != N; ++I)
3433         add(cast_or_null<ObjCCategoryDecl>(
3434               Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
3435       return true;
3436     }
3437   };
3438 }
3439
3440 void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
3441                                    ObjCInterfaceDecl *D,
3442                                    unsigned PreviousGeneration) {
3443   ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
3444                                 PreviousGeneration);
3445   ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor);
3446 }
3447
3448 namespace {
3449 /// Iterator over the redeclarations of a declaration that have already
3450 /// been merged into the same redeclaration chain.
3451 template<typename DeclT>
3452 class MergedRedeclIterator {
3453   DeclT *Start, *Canonical, *Current;
3454 public:
3455   MergedRedeclIterator() : Current(nullptr) {}
3456   MergedRedeclIterator(DeclT *Start)
3457       : Start(Start), Canonical(nullptr), Current(Start) {}
3458
3459   DeclT *operator*() { return Current; }
3460
3461   MergedRedeclIterator &operator++() {
3462     if (Current->isFirstDecl()) {
3463       Canonical = Current;
3464       Current = Current->getMostRecentDecl();
3465     } else
3466       Current = Current->getPreviousDecl();
3467
3468     // If we started in the merged portion, we'll reach our start position
3469     // eventually. Otherwise, we'll never reach it, but the second declaration
3470     // we reached was the canonical declaration, so stop when we see that one
3471     // again.
3472     if (Current == Start || Current == Canonical)
3473       Current = nullptr;
3474     return *this;
3475   }
3476
3477   friend bool operator!=(const MergedRedeclIterator &A,
3478                          const MergedRedeclIterator &B) {
3479     return A.Current != B.Current;
3480   }
3481 };
3482 }
3483 template<typename DeclT>
3484 llvm::iterator_range<MergedRedeclIterator<DeclT>> merged_redecls(DeclT *D) {
3485   return llvm::iterator_range<MergedRedeclIterator<DeclT>>(
3486       MergedRedeclIterator<DeclT>(D),
3487       MergedRedeclIterator<DeclT>());
3488 }
3489
3490 template<typename DeclT, typename Fn>
3491 static void forAllLaterRedecls(DeclT *D, Fn F) {
3492   F(D);
3493
3494   // Check whether we've already merged D into its redeclaration chain.
3495   // MostRecent may or may not be nullptr if D has not been merged. If
3496   // not, walk the merged redecl chain and see if it's there.
3497   auto *MostRecent = D->getMostRecentDecl();
3498   bool Found = false;
3499   for (auto *Redecl = MostRecent; Redecl && !Found;
3500        Redecl = Redecl->getPreviousDecl())
3501     Found = (Redecl == D);
3502
3503   // If this declaration is merged, apply the functor to all later decls.
3504   if (Found) {
3505     for (auto *Redecl = MostRecent; Redecl != D;
3506          Redecl = Redecl->getPreviousDecl())
3507       F(Redecl);
3508   }
3509 }
3510
3511 void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
3512                                const RecordData &Record) {
3513   while (Idx < Record.size()) {
3514     switch ((DeclUpdateKind)Record[Idx++]) {
3515     case UPD_CXX_ADDED_IMPLICIT_MEMBER: {
3516       // FIXME: If we also have an update record for instantiating the
3517       // definition of D, we need that to happen before we get here.
3518       Decl *MD = Reader.ReadDecl(ModuleFile, Record, Idx);
3519       assert(MD && "couldn't read decl from update record");
3520       // FIXME: We should call addHiddenDecl instead, to add the member
3521       // to its DeclContext.
3522       cast<CXXRecordDecl>(D)->addedMember(MD);
3523       break;
3524     }
3525
3526     case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
3527       // It will be added to the template's specializations set when loaded.
3528       (void)Reader.ReadDecl(ModuleFile, Record, Idx);
3529       break;
3530
3531     case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
3532       NamespaceDecl *Anon
3533         = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
3534
3535       // Each module has its own anonymous namespace, which is disjoint from
3536       // any other module's anonymous namespaces, so don't attach the anonymous
3537       // namespace at all.
3538       if (ModuleFile.Kind != MK_ImplicitModule &&
3539           ModuleFile.Kind != MK_ExplicitModule) {
3540         if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
3541           TU->setAnonymousNamespace(Anon);
3542         else
3543           cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
3544       }
3545       break;
3546     }
3547
3548     case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
3549       cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
3550           Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3551       break;
3552
3553     case UPD_CXX_ADDED_FUNCTION_DEFINITION: {
3554       FunctionDecl *FD = cast<FunctionDecl>(D);
3555       if (Reader.PendingBodies[FD]) {
3556         // FIXME: Maybe check for ODR violations.
3557         // It's safe to stop now because this update record is always last.
3558         return;
3559       }
3560
3561       if (Record[Idx++]) {
3562         // Maintain AST consistency: any later redeclarations of this function
3563         // are inline if this one is. (We might have merged another declaration
3564         // into this one.)
3565         forAllLaterRedecls(FD, [](FunctionDecl *FD) {
3566           FD->setImplicitlyInline();
3567         });
3568       }
3569       FD->setInnerLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3570       if (auto *CD = dyn_cast<CXXConstructorDecl>(FD))
3571         std::tie(CD->CtorInitializers, CD->NumCtorInitializers) =
3572             Reader.ReadCXXCtorInitializers(ModuleFile, Record, Idx);
3573       if (auto *DD = dyn_cast<CXXDestructorDecl>(FD))
3574         // FIXME: Check consistency.
3575         DD->setOperatorDelete(Reader.ReadDeclAs<FunctionDecl>(ModuleFile,
3576                                                               Record, Idx));
3577       // Store the offset of the body so we can lazily load it later.
3578       Reader.PendingBodies[FD] = GetCurrentCursorOffset();
3579       HasPendingBody = true;
3580       assert(Idx == Record.size() && "lazy body must be last");
3581       break;
3582     }
3583
3584     case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
3585       auto *RD = cast<CXXRecordDecl>(D);
3586       bool HadDefinition = RD->getDefinition();
3587       ReadCXXRecordDefinition(RD);
3588       // Visible update is handled separately.
3589       uint64_t LexicalOffset = Record[Idx++];
3590       if (!HadDefinition && LexicalOffset) {
3591         RD->setHasExternalLexicalStorage(true);
3592         Reader.ReadDeclContextStorage(ModuleFile, ModuleFile.DeclsCursor,
3593                                           std::make_pair(LexicalOffset, 0),
3594                                           ModuleFile.DeclContextInfos[RD]);
3595         Reader.PendingDefinitions.insert(RD);
3596       }
3597
3598       auto TSK = (TemplateSpecializationKind)Record[Idx++];
3599       SourceLocation POI = Reader.ReadSourceLocation(ModuleFile, Record, Idx);
3600       if (MemberSpecializationInfo *MSInfo =
3601               RD->getMemberSpecializationInfo()) {
3602         MSInfo->setTemplateSpecializationKind(TSK);
3603         MSInfo->setPointOfInstantiation(POI);
3604       } else {
3605         ClassTemplateSpecializationDecl *Spec =
3606             cast<ClassTemplateSpecializationDecl>(RD);
3607         Spec->setTemplateSpecializationKind(TSK);
3608         Spec->setPointOfInstantiation(POI);
3609
3610         if (Record[Idx++]) {
3611           auto PartialSpec =
3612               ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx);
3613           SmallVector<TemplateArgument, 8> TemplArgs;
3614           Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
3615           auto *TemplArgList = TemplateArgumentList::CreateCopy(
3616               Reader.getContext(), TemplArgs.data(), TemplArgs.size());
3617
3618           // FIXME: If we already have a partial specialization set,
3619           // check that it matches.
3620           if (!Spec->getSpecializedTemplateOrPartial()
3621                    .is<ClassTemplatePartialSpecializationDecl *>())
3622             Spec->setInstantiationOf(PartialSpec, TemplArgList);
3623         }
3624       }
3625
3626       RD->setTagKind((TagTypeKind)Record[Idx++]);
3627       RD->setLocation(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3628       RD->setLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3629       RD->setRBraceLoc(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3630
3631       if (Record[Idx++]) {
3632         AttrVec Attrs;
3633         Reader.ReadAttributes(F, Attrs, Record, Idx);
3634         D->setAttrsImpl(Attrs, Reader.getContext());
3635       }
3636       break;
3637     }
3638
3639     case UPD_CXX_RESOLVED_EXCEPTION_SPEC: {
3640       // FIXME: This doesn't send the right notifications if there are
3641       // ASTMutationListeners other than an ASTWriter.
3642       FunctionProtoType::ExceptionSpecInfo ESI;
3643       SmallVector<QualType, 8> ExceptionStorage;
3644       Reader.readExceptionSpec(ModuleFile, ExceptionStorage, ESI, Record, Idx);
3645       for (auto *Redecl : merged_redecls(D)) {
3646         auto *FD = cast<FunctionDecl>(Redecl);
3647         auto *FPT = FD->getType()->castAs<FunctionProtoType>();
3648         if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
3649           // AST invariant: if any exception spec in the redecl chain is
3650           // resolved, all are resolved. We don't need to go any further.
3651           // FIXME: If the exception spec is resolved, check that it matches.
3652           break;
3653         }
3654         FD->setType(Reader.Context.getFunctionType(
3655             FPT->getReturnType(), FPT->getParamTypes(),
3656             FPT->getExtProtoInfo().withExceptionSpec(ESI)));
3657       }
3658       break;
3659     }
3660
3661     case UPD_CXX_DEDUCED_RETURN_TYPE: {
3662       // FIXME: Also do this when merging redecls.
3663       QualType DeducedResultType = Reader.readType(ModuleFile, Record, Idx);
3664       for (auto *Redecl : merged_redecls(D)) {
3665         // FIXME: If the return type is already deduced, check that it matches.
3666         FunctionDecl *FD = cast<FunctionDecl>(Redecl);
3667         Reader.Context.adjustDeducedFunctionResultType(FD, DeducedResultType);
3668       }
3669       break;
3670     }
3671
3672     case UPD_DECL_MARKED_USED: {
3673       // FIXME: This doesn't send the right notifications if there are
3674       // ASTMutationListeners other than an ASTWriter.
3675
3676       // Maintain AST consistency: any later redeclarations are used too.
3677       forAllLaterRedecls(D, [](Decl *D) { D->Used = true; });
3678       break;
3679     }
3680
3681     case UPD_MANGLING_NUMBER:
3682       Reader.Context.setManglingNumber(cast<NamedDecl>(D), Record[Idx++]);
3683       break;
3684
3685     case UPD_STATIC_LOCAL_NUMBER:
3686       Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), Record[Idx++]);
3687       break;
3688     case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
3689       D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
3690           Reader.Context, ReadSourceRange(Record, Idx)));
3691       break;
3692     }
3693   }
3694 }