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