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