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 "ASTCommon.h"
  16 #include "ASTReaderInternals.h"
  17 #include "clang/Serialization/ASTReader.h"
  18 #include "clang/Sema/IdentifierResolver.h"
  19 #include "clang/Sema/Sema.h"
  20 #include "clang/Sema/SemaDiagnostic.h"
  21 #include "clang/AST/ASTConsumer.h"
  22 #include "clang/AST/ASTContext.h"
  23 #include "clang/AST/DeclVisitor.h"
  24 #include "clang/AST/DeclGroup.h"
  25 #include "clang/AST/DeclCXX.h"
  26 #include "clang/AST/DeclTemplate.h"
  27 #include "clang/AST/Expr.h"
  28 using namespace clang;
  29 using namespace clang::serialization;
  30
  31 //===----------------------------------------------------------------------===//
  32 // Declaration deserialization
  33 //===----------------------------------------------------------------------===//
  34
  35 namespace clang {
  36   class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
  37     ASTReader &Reader;
  38     ModuleFile &F;
  39     llvm::BitstreamCursor &Cursor;
  40     const DeclID ThisDeclID;
  41     const unsigned RawLocation;
  42     typedef ASTReader::RecordData RecordData;
  43     const RecordData &Record;
  44     unsigned &Idx;
  45     TypeID TypeIDForTypeDecl;
  46
  47     DeclID DeclContextIDForTemplateParmDecl;
  48     DeclID LexicalDeclContextIDForTemplateParmDecl;
  49
  50     uint64_t GetCurrentCursorOffset();
  51
  52     SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
  53       return Reader.ReadSourceLocation(F, R, I);
  54     }
  55
  56     SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
  57       return Reader.ReadSourceRange(F, R, I);
  58     }
  59
  60     TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
  61       return Reader.GetTypeSourceInfo(F, R, I);
  62     }
  63
  64     serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
  65       return Reader.ReadDeclID(F, R, I);
  66     }
  67
  68     Decl *ReadDecl(const RecordData &R, unsigned &I) {
  69       return Reader.ReadDecl(F, R, I);
  70     }
  71
  72     template<typename T>
  73     T *ReadDeclAs(const RecordData &R, unsigned &I) {
  74       return Reader.ReadDeclAs<T>(F, R, I);
  75     }
  76
  77     void ReadQualifierInfo(QualifierInfo &Info,
  78                            const RecordData &R, unsigned &I) {
  79       Reader.ReadQualifierInfo(F, Info, R, I);
  80     }
  81
  82     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
  83                                 const RecordData &R, unsigned &I) {
  84       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
  85     }
  86
  87     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
  88                                 const RecordData &R, unsigned &I) {
  89       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
  90     }
  91
  92     serialization::SubmoduleID readSubmoduleID(const RecordData &R,
  93                                                unsigned &I) {
  94       if (I >= R.size())
  95         return 0;
  96
  97       return Reader.getGlobalSubmoduleID(F, R[I++]);
  98     }
  99
 100     Module *readModule(const RecordData &R, unsigned &I) {
 101       return Reader.getSubmodule(readSubmoduleID(R, I));
 102     }
 103
 104     void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
 105                                const RecordData &R, unsigned &I);
 106
 107     /// \brief RAII class used to capture the first ID within a redeclaration
 108     /// chain and to introduce it into the list of pending redeclaration chains
 109     /// on destruction.
 110     ///
 111     /// The caller can choose not to introduce this ID into the redeclaration
 112     /// chain by calling \c suppress().
 113     class RedeclarableResult {
 114       ASTReader &Reader;
 115       GlobalDeclID FirstID;
 116       mutable bool Owning;
 117
 118       RedeclarableResult &operator=(RedeclarableResult&); // DO NOT IMPLEMENT
 119
 120     public:
 121       RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID)
 122         : Reader(Reader), FirstID(FirstID), Owning(true) { }
 123
 124       RedeclarableResult(const RedeclarableResult &Other)
 125         : Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning)
 126       {
 127         Other.Owning = false;
 128       }
 129
 130       ~RedeclarableResult() {
 131         // FIXME: We want to suppress this when the declaration is local to
 132         // a function, since there's no reason to search other AST files
 133         // for redeclarations (they can't exist). However, this is hard to
 134         // do locally because the declaration hasn't necessarily loaded its
 135         // declaration context yet. Also, local externs still have the function
 136         // as their (semantic) declaration context, which is wrong and would
 137         // break this optimize.
 138
 139         if (FirstID && Owning && Reader.PendingDeclChainsKnown.insert(FirstID))
 140           Reader.PendingDeclChains.push_back(FirstID);
 141       }
 142
 143       /// \brief Retrieve the first ID.
 144       GlobalDeclID getFirstID() const { return FirstID; }
 145
 146       /// \brief Do not introduce this declaration ID into the set of pending
 147       /// declaration chains.
 148       void suppress() {
 149         Owning = false;
 150       }
 151     };
 152
 153     /// \brief Class used to capture the result of searching for an existing
 154     /// declaration of a specific kind and name, along with the ability
 155     /// to update the place where this result was found (the declaration
 156     /// chain hanging off an identifier or the DeclContext we searched in)
 157     /// if requested.
 158     class FindExistingResult {
 159       ASTReader &Reader;
 160       NamedDecl *New;
 161       NamedDecl *Existing;
 162       mutable bool AddResult;
 163
 164       FindExistingResult &operator=(FindExistingResult&); // DO NOT IMPLEMENT
 165
 166     public:
 167       FindExistingResult(ASTReader &Reader)
 168         : Reader(Reader), New(0), Existing(0), AddResult(false) { }
 169
 170       FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing)
 171         : Reader(Reader), New(New), Existing(Existing), AddResult(true) { }
 172
 173       FindExistingResult(const FindExistingResult &Other)
 174         : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
 175           AddResult(Other.AddResult)
 176       {
 177         Other.AddResult = false;
 178       }
 179
 180       ~FindExistingResult();
 181
 182       /// \brief Suppress the addition of this result into the known set of
 183       /// names.
 184       void suppress() { AddResult = false; }
 185
 186       operator NamedDecl*() const { return Existing; }
 187
 188       template<typename T>
 189       operator T*() const { return dyn_cast_or_null<T>(Existing); }
 190     };
 191
 192     FindExistingResult findExisting(NamedDecl *D);
 193
 194   public:
 195     ASTDeclReader(ASTReader &Reader, ModuleFile &F,
 196                   llvm::BitstreamCursor &Cursor, DeclID thisDeclID,
 197                   unsigned RawLocation,
 198                   const RecordData &Record, unsigned &Idx)
 199       : Reader(Reader), F(F), Cursor(Cursor), ThisDeclID(thisDeclID),
 200         RawLocation(RawLocation), Record(Record), Idx(Idx),
 201         TypeIDForTypeDecl(0) { }
 202
 203     static void attachPreviousDecl(Decl *D, Decl *previous);
 204     static void attachLatestDecl(Decl *D, Decl *latest);
 205
 206     void Visit(Decl *D);
 207
 208     void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
 209                     const RecordData &Record);
 210
 211     static void setNextObjCCategory(ObjCCategoryDecl *Cat,
 212                                     ObjCCategoryDecl *Next) {
 213       Cat->NextClassCategory = Next;
 214     }
 215
 216     void VisitDecl(Decl *D);
 217     void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
 218     void VisitNamedDecl(NamedDecl *ND);
 219     void VisitLabelDecl(LabelDecl *LD);
 220     void VisitNamespaceDecl(NamespaceDecl *D);
 221     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
 222     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
 223     void VisitTypeDecl(TypeDecl *TD);
 224     void VisitTypedefNameDecl(TypedefNameDecl *TD);
 225     void VisitTypedefDecl(TypedefDecl *TD);
 226     void VisitTypeAliasDecl(TypeAliasDecl *TD);
 227     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
 228     void VisitTagDecl(TagDecl *TD);
 229     void VisitEnumDecl(EnumDecl *ED);
 230     void VisitRecordDecl(RecordDecl *RD);
 231     void VisitCXXRecordDecl(CXXRecordDecl *D);
 232     void VisitClassTemplateSpecializationDecl(
 233                                             ClassTemplateSpecializationDecl *D);
 234     void VisitClassTemplatePartialSpecializationDecl(
 235                                      ClassTemplatePartialSpecializationDecl *D);
 236     void VisitClassScopeFunctionSpecializationDecl(
 237                                        ClassScopeFunctionSpecializationDecl *D);
 238     void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
 239     void VisitValueDecl(ValueDecl *VD);
 240     void VisitEnumConstantDecl(EnumConstantDecl *ECD);
 241     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
 242     void VisitDeclaratorDecl(DeclaratorDecl *DD);
 243     void VisitFunctionDecl(FunctionDecl *FD);
 244     void VisitCXXMethodDecl(CXXMethodDecl *D);
 245     void VisitCXXConstructorDecl(CXXConstructorDecl *D);
 246     void VisitCXXDestructorDecl(CXXDestructorDecl *D);
 247     void VisitCXXConversionDecl(CXXConversionDecl *D);
 248     void VisitFieldDecl(FieldDecl *FD);
 249     void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
 250     void VisitVarDecl(VarDecl *VD);
 251     void VisitImplicitParamDecl(ImplicitParamDecl *PD);
 252     void VisitParmVarDecl(ParmVarDecl *PD);
 253     void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
 254     void VisitTemplateDecl(TemplateDecl *D);
 255     RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
 256     void VisitClassTemplateDecl(ClassTemplateDecl *D);
 257     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
 258     void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
 259     void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
 260     void VisitUsingDecl(UsingDecl *D);
 261     void VisitUsingShadowDecl(UsingShadowDecl *D);
 262     void VisitLinkageSpecDecl(LinkageSpecDecl *D);
 263     void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
 264     void VisitImportDecl(ImportDecl *D);
 265     void VisitAccessSpecDecl(AccessSpecDecl *D);
 266     void VisitFriendDecl(FriendDecl *D);
 267     void VisitFriendTemplateDecl(FriendTemplateDecl *D);
 268     void VisitStaticAssertDecl(StaticAssertDecl *D);
 269     void VisitBlockDecl(BlockDecl *BD);
 270
 271     std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
 272
 273     template<typename T>
 274     RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
 275
 276     template<typename T>
 277     void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl);
 278
 279     // FIXME: Reorder according to DeclNodes.td?
 280     void VisitObjCMethodDecl(ObjCMethodDecl *D);
 281     void VisitObjCContainerDecl(ObjCContainerDecl *D);
 282     void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
 283     void VisitObjCIvarDecl(ObjCIvarDecl *D);
 284     void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
 285     void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
 286     void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
 287     void VisitObjCImplDecl(ObjCImplDecl *D);
 288     void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
 289     void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
 290     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
 291     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
 292     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
 293   };
 294 }
 295
 296 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
 297   return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
 298 }
 299
 300 void ASTDeclReader::Visit(Decl *D) {
 301   DeclVisitor<ASTDeclReader, void>::Visit(D);
 302
 303   if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
 304     if (DD->DeclInfo) {
 305       DeclaratorDecl::ExtInfo *Info =
 306           DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
 307       Info->TInfo =
 308           GetTypeSourceInfo(Record, Idx);
 309     }
 310     else {
 311       DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
 312     }
 313   }
 314
 315   if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
 316     // if we have a fully initialized TypeDecl, we can safely read its type now.
 317     TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
 318   } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
 319     // if we have a fully initialized TypeDecl, we can safely read its type now.
 320     ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
 321   } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 322     // FunctionDecl's body was written last after all other Stmts/Exprs.
 323     if (Record[Idx++])
 324       FD->setLazyBody(GetCurrentCursorOffset());
 325   } else if (D->isTemplateParameter()) {
 326     // If we have a fully initialized template parameter, we can now
 327     // set its DeclContext.
 328     DeclContext *SemaDC = cast<DeclContext>(
 329                               Reader.GetDecl(DeclContextIDForTemplateParmDecl));
 330     DeclContext *LexicalDC = cast<DeclContext>(
 331                        Reader.GetDecl(LexicalDeclContextIDForTemplateParmDecl));
 332     D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
 333   }
 334 }
 335
 336 void ASTDeclReader::VisitDecl(Decl *D) {
 337   if (D->isTemplateParameter()) {
 338     // We don't want to deserialize the DeclContext of a template
 339     // parameter immediately, because the template parameter might be
 340     // used in the formulation of its DeclContext. Use the translation
 341     // unit DeclContext as a placeholder.
 342     DeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
 343     LexicalDeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
 344     D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
 345   } else {
 346     DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
 347     DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
 348     // Avoid calling setLexicalDeclContext() directly because it uses
 349     // Decl::getASTContext() internally which is unsafe during derialization.
 350     D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
 351   }
 352   D->setLocation(Reader.ReadSourceLocation(F, RawLocation));
 353   D->setInvalidDecl(Record[Idx++]);
 354   if (Record[Idx++]) { // hasAttrs
 355     AttrVec Attrs;
 356     Reader.ReadAttributes(F, Attrs, Record, Idx);
 357     // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
 358     // internally which is unsafe during derialization.
 359     D->setAttrsImpl(Attrs, Reader.getContext());
 360   }
 361   D->setImplicit(Record[Idx++]);
 362   D->setUsed(Record[Idx++]);
 363   D->setReferenced(Record[Idx++]);
 364   D->setTopLevelDeclInObjCContainer(Record[Idx++]);
 365   D->setAccess((AccessSpecifier)Record[Idx++]);
 366   D->FromASTFile = true;
 367   D->setModulePrivate(Record[Idx++]);
 368   D->Hidden = D->isModulePrivate();
 369
 370   // Determine whether this declaration is part of a (sub)module. If so, it
 371   // may not yet be visible.
 372   if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
 373     // Store the owning submodule ID in the declaration.
 374     D->setOwningModuleID(SubmoduleID);
 375
 376     // Module-private declarations are never visible, so there is no work to do.
 377     if (!D->isModulePrivate()) {
 378       if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
 379         if (Owner->NameVisibility != Module::AllVisible) {
 380           // The owning module is not visible. Mark this declaration as hidden.
 381           D->Hidden = true;
 382
 383           // Note that this declaration was hidden because its owning module is
 384           // not yet visible.
 385           Reader.HiddenNamesMap[Owner].push_back(D);
 386         }
 387       }
 388     }
 389   }
 390 }
 391
 392 void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
 393   llvm_unreachable("Translation units are not serialized");
 394 }
 395
 396 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
 397   VisitDecl(ND);
 398   ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
 399 }
 400
 401 void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
 402   VisitNamedDecl(TD);
 403   TD->setLocStart(ReadSourceLocation(Record, Idx));
 404   // Delay type reading until after we have fully initialized the decl.
 405   TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
 406 }
 407
 408 void ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
 409   RedeclarableResult Redecl = VisitRedeclarable(TD);
 410   VisitTypeDecl(TD);
 411
 412   TD->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 413   mergeRedeclarable(TD, Redecl);
 414 }
 415
 416 void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
 417   VisitTypedefNameDecl(TD);
 418 }
 419
 420 void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
 421   VisitTypedefNameDecl(TD);
 422 }
 423
 424 void ASTDeclReader::VisitTagDecl(TagDecl *TD) {
 425   RedeclarableResult Redecl = VisitRedeclarable(TD);
 426   VisitTypeDecl(TD);
 427
 428   TD->IdentifierNamespace = Record[Idx++];
 429   TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
 430   TD->setCompleteDefinition(Record[Idx++]);
 431   TD->setEmbeddedInDeclarator(Record[Idx++]);
 432   TD->setFreeStanding(Record[Idx++]);
 433   TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
 434
 435   if (Record[Idx++]) { // hasExtInfo
 436     TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
 437     ReadQualifierInfo(*Info, Record, Idx);
 438     TD->TypedefNameDeclOrQualifier = Info;
 439   } else
 440     TD->setTypedefNameForAnonDecl(ReadDeclAs<TypedefNameDecl>(Record, Idx));
 441
 442   mergeRedeclarable(TD, Redecl);
 443 }
 444
 445 void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
 446   VisitTagDecl(ED);
 447   if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
 448     ED->setIntegerTypeSourceInfo(TI);
 449   else
 450     ED->setIntegerType(Reader.readType(F, Record, Idx));
 451   ED->setPromotionType(Reader.readType(F, Record, Idx));
 452   ED->setNumPositiveBits(Record[Idx++]);
 453   ED->setNumNegativeBits(Record[Idx++]);
 454   ED->IsScoped = Record[Idx++];
 455   ED->IsScopedUsingClassTag = Record[Idx++];
 456   ED->IsFixed = Record[Idx++];
 457
 458   if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
 459     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
 460     SourceLocation POI = ReadSourceLocation(Record, Idx);
 461     ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
 462     ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
 463   }
 464 }
 465
 466 void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {
 467   VisitTagDecl(RD);
 468   RD->setHasFlexibleArrayMember(Record[Idx++]);
 469   RD->setAnonymousStructOrUnion(Record[Idx++]);
 470   RD->setHasObjectMember(Record[Idx++]);
 471 }
 472
 473 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
 474   VisitNamedDecl(VD);
 475   VD->setType(Reader.readType(F, Record, Idx));
 476 }
 477
 478 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
 479   VisitValueDecl(ECD);
 480   if (Record[Idx++])
 481     ECD->setInitExpr(Reader.ReadExpr(F));
 482   ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
 483 }
 484
 485 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
 486   VisitValueDecl(DD);
 487   DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
 488   if (Record[Idx++]) { // hasExtInfo
 489     DeclaratorDecl::ExtInfo *Info
 490         = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
 491     ReadQualifierInfo(*Info, Record, Idx);
 492     DD->DeclInfo = Info;
 493   }
 494 }
 495
 496 void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
 497   RedeclarableResult Redecl = VisitRedeclarable(FD);
 498   VisitDeclaratorDecl(FD);
 499
 500   ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
 501   FD->IdentifierNamespace = Record[Idx++];
 502
 503   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
 504   // after everything else is read.
 505
 506   FD->SClass = (StorageClass)Record[Idx++];
 507   FD->SClassAsWritten = (StorageClass)Record[Idx++];
 508   FD->IsInline = Record[Idx++];
 509   FD->IsInlineSpecified = Record[Idx++];
 510   FD->IsVirtualAsWritten = Record[Idx++];
 511   FD->IsPure = Record[Idx++];
 512   FD->HasInheritedPrototype = Record[Idx++];
 513   FD->HasWrittenPrototype = Record[Idx++];
 514   FD->IsDeleted = Record[Idx++];
 515   FD->IsTrivial = Record[Idx++];
 516   FD->IsDefaulted = Record[Idx++];
 517   FD->IsExplicitlyDefaulted = Record[Idx++];
 518   FD->HasImplicitReturnZero = Record[Idx++];
 519   FD->IsConstexpr = Record[Idx++];
 520   FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
 521
 522   switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
 523   case FunctionDecl::TK_NonTemplate:
 524     mergeRedeclarable(FD, Redecl);
 525     break;
 526   case FunctionDecl::TK_FunctionTemplate:
 527     FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
 528                                                                       Idx));
 529     break;
 530   case FunctionDecl::TK_MemberSpecialization: {
 531     FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
 532     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
 533     SourceLocation POI = ReadSourceLocation(Record, Idx);
 534     FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
 535     FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
 536     break;
 537   }
 538   case FunctionDecl::TK_FunctionTemplateSpecialization: {
 539     FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
 540                                                                       Idx);
 541     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
 542
 543     // Template arguments.
 544     SmallVector<TemplateArgument, 8> TemplArgs;
 545     Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
 546
 547     // Template args as written.
 548     SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
 549     SourceLocation LAngleLoc, RAngleLoc;
 550     bool HasTemplateArgumentsAsWritten = Record[Idx++];
 551     if (HasTemplateArgumentsAsWritten) {
 552       unsigned NumTemplateArgLocs = Record[Idx++];
 553       TemplArgLocs.reserve(NumTemplateArgLocs);
 554       for (unsigned i=0; i != NumTemplateArgLocs; ++i)
 555         TemplArgLocs.push_back(
 556             Reader.ReadTemplateArgumentLoc(F, Record, Idx));
 557
 558       LAngleLoc = ReadSourceLocation(Record, Idx);
 559       RAngleLoc = ReadSourceLocation(Record, Idx);
 560     }
 561
 562     SourceLocation POI = ReadSourceLocation(Record, Idx);
 563
 564     ASTContext &C = Reader.getContext();
 565     TemplateArgumentList *TemplArgList
 566       = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
 567     TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
 568     for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
 569       TemplArgsInfo.addArgument(TemplArgLocs[i]);
 570     FunctionTemplateSpecializationInfo *FTInfo
 571         = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
 572                                                      TemplArgList,
 573                              HasTemplateArgumentsAsWritten ? &TemplArgsInfo : 0,
 574                                                      POI);
 575     FD->TemplateOrSpecialization = FTInfo;
 576
 577     if (FD->isCanonicalDecl()) { // if canonical add to template's set.
 578       // The template that contains the specializations set. It's not safe to
 579       // use getCanonicalDecl on Template since it may still be initializing.
 580       FunctionTemplateDecl *CanonTemplate
 581         = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
 582       // Get the InsertPos by FindNodeOrInsertPos() instead of calling
 583       // InsertNode(FTInfo) directly to avoid the getASTContext() call in
 584       // FunctionTemplateSpecializationInfo's Profile().
 585       // We avoid getASTContext because a decl in the parent hierarchy may
 586       // be initializing.
 587       llvm::FoldingSetNodeID ID;
 588       FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs.data(),
 589                                                   TemplArgs.size(), C);
 590       void *InsertPos = 0;
 591       CanonTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos);
 592       assert(InsertPos && "Another specialization already inserted!");
 593       CanonTemplate->getSpecializations().InsertNode(FTInfo, InsertPos);
 594     }
 595     break;
 596   }
 597   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
 598     // Templates.
 599     UnresolvedSet<8> TemplDecls;
 600     unsigned NumTemplates = Record[Idx++];
 601     while (NumTemplates--)
 602       TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
 603
 604     // Templates args.
 605     TemplateArgumentListInfo TemplArgs;
 606     unsigned NumArgs = Record[Idx++];
 607     while (NumArgs--)
 608       TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
 609     TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
 610     TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
 611
 612     FD->setDependentTemplateSpecialization(Reader.getContext(),
 613                                            TemplDecls, TemplArgs);
 614     break;
 615   }
 616   }
 617
 618   // Read in the parameters.
 619   unsigned NumParams = Record[Idx++];
 620   SmallVector<ParmVarDecl *, 16> Params;
 621   Params.reserve(NumParams);
 622   for (unsigned I = 0; I != NumParams; ++I)
 623     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
 624   FD->setParams(Reader.getContext(), Params);
 625 }
 626
 627 void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
 628   VisitNamedDecl(MD);
 629   if (Record[Idx++]) {
 630     // In practice, this won't be executed (since method definitions
 631     // don't occur in header files).
 632     MD->setBody(Reader.ReadStmt(F));
 633     MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
 634     MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
 635   }
 636   MD->setInstanceMethod(Record[Idx++]);
 637   MD->setVariadic(Record[Idx++]);
 638   MD->setSynthesized(Record[Idx++]);
 639   MD->setDefined(Record[Idx++]);
 640
 641   MD->IsRedeclaration = Record[Idx++];
 642   MD->HasRedeclaration = Record[Idx++];
 643   if (MD->HasRedeclaration)
 644     Reader.getContext().setObjCMethodRedeclaration(MD,
 645                                        ReadDeclAs<ObjCMethodDecl>(Record, Idx));
 646
 647   MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
 648   MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
 649   MD->SetRelatedResultType(Record[Idx++]);
 650   MD->setResultType(Reader.readType(F, Record, Idx));
 651   MD->setResultTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 652   MD->setEndLoc(ReadSourceLocation(Record, Idx));
 653   unsigned NumParams = Record[Idx++];
 654   SmallVector<ParmVarDecl *, 16> Params;
 655   Params.reserve(NumParams);
 656   for (unsigned I = 0; I != NumParams; ++I)
 657     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
 658
 659   MD->SelLocsKind = Record[Idx++];
 660   unsigned NumStoredSelLocs = Record[Idx++];
 661   SmallVector<SourceLocation, 16> SelLocs;
 662   SelLocs.reserve(NumStoredSelLocs);
 663   for (unsigned i = 0; i != NumStoredSelLocs; ++i)
 664     SelLocs.push_back(ReadSourceLocation(Record, Idx));
 665
 666   MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
 667 }
 668
 669 void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
 670   VisitNamedDecl(CD);
 671   CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
 672   CD->setAtEndRange(ReadSourceRange(Record, Idx));
 673 }
 674
 675 void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
 676   RedeclarableResult Redecl = VisitRedeclarable(ID);
 677   VisitObjCContainerDecl(ID);
 678   TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
 679   mergeRedeclarable(ID, Redecl);
 680
 681   if (Record[Idx++]) {
 682     // Read the definition.
 683     ID->allocateDefinitionData();
 684
 685     // Set the definition data of the canonical declaration, so other
 686     // redeclarations will see it.
 687     ID->getCanonicalDecl()->Data = ID->Data;
 688
 689     ObjCInterfaceDecl::DefinitionData &Data = ID->data();
 690
 691     // Read the superclass.
 692     Data.SuperClass = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
 693     Data.SuperClassLoc = ReadSourceLocation(Record, Idx);
 694
 695     Data.EndLoc = ReadSourceLocation(Record, Idx);
 696
 697     // Read the directly referenced protocols and their SourceLocations.
 698     unsigned NumProtocols = Record[Idx++];
 699     SmallVector<ObjCProtocolDecl *, 16> Protocols;
 700     Protocols.reserve(NumProtocols);
 701     for (unsigned I = 0; I != NumProtocols; ++I)
 702       Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
 703     SmallVector<SourceLocation, 16> ProtoLocs;
 704     ProtoLocs.reserve(NumProtocols);
 705     for (unsigned I = 0; I != NumProtocols; ++I)
 706       ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
 707     ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
 708                         Reader.getContext());
 709
 710     // Read the transitive closure of protocols referenced by this class.
 711     NumProtocols = Record[Idx++];
 712     Protocols.clear();
 713     Protocols.reserve(NumProtocols);
 714     for (unsigned I = 0; I != NumProtocols; ++I)
 715       Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
 716     ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
 717                                           Reader.getContext());
 718
 719     // We will rebuild this list lazily.
 720     ID->setIvarList(0);
 721
 722     // Note that we have deserialized a definition.
 723     Reader.PendingDefinitions.insert(ID);
 724
 725     // Note that we've loaded this Objective-C class.
 726     Reader.ObjCClassesLoaded.push_back(ID);
 727   } else {
 728     ID->Data = ID->getCanonicalDecl()->Data;
 729   }
 730 }
 731
 732 void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
 733   VisitFieldDecl(IVD);
 734   IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
 735   // This field will be built lazily.
 736   IVD->setNextIvar(0);
 737   bool synth = Record[Idx++];
 738   IVD->setSynthesize(synth);
 739 }
 740
 741 void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
 742   RedeclarableResult Redecl = VisitRedeclarable(PD);
 743   VisitObjCContainerDecl(PD);
 744   mergeRedeclarable(PD, Redecl);
 745
 746   if (Record[Idx++]) {
 747     // Read the definition.
 748     PD->allocateDefinitionData();
 749
 750     // Set the definition data of the canonical declaration, so other
 751     // redeclarations will see it.
 752     PD->getCanonicalDecl()->Data = PD->Data;
 753
 754     unsigned NumProtoRefs = Record[Idx++];
 755     SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
 756     ProtoRefs.reserve(NumProtoRefs);
 757     for (unsigned I = 0; I != NumProtoRefs; ++I)
 758       ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
 759     SmallVector<SourceLocation, 16> ProtoLocs;
 760     ProtoLocs.reserve(NumProtoRefs);
 761     for (unsigned I = 0; I != NumProtoRefs; ++I)
 762       ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
 763     PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
 764                         Reader.getContext());
 765
 766     // Note that we have deserialized a definition.
 767     Reader.PendingDefinitions.insert(PD);
 768   } else {
 769     PD->Data = PD->getCanonicalDecl()->Data;
 770   }
 771 }
 772
 773 void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
 774   VisitFieldDecl(FD);
 775 }
 776
 777 void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
 778   VisitObjCContainerDecl(CD);
 779   CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
 780   CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
 781   CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
 782
 783   // Note that this category has been deserialized. We do this before
 784   // deserializing the interface declaration, so that it will consider this
 785   /// category.
 786   Reader.CategoriesDeserialized.insert(CD);
 787
 788   CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
 789   unsigned NumProtoRefs = Record[Idx++];
 790   SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
 791   ProtoRefs.reserve(NumProtoRefs);
 792   for (unsigned I = 0; I != NumProtoRefs; ++I)
 793     ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
 794   SmallVector<SourceLocation, 16> ProtoLocs;
 795   ProtoLocs.reserve(NumProtoRefs);
 796   for (unsigned I = 0; I != NumProtoRefs; ++I)
 797     ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
 798   CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
 799                       Reader.getContext());
 800   CD->setHasSynthBitfield(Record[Idx++]);
 801 }
 802
 803 void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
 804   VisitNamedDecl(CAD);
 805   CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
 806 }
 807
 808 void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
 809   VisitNamedDecl(D);
 810   D->setAtLoc(ReadSourceLocation(Record, Idx));
 811   D->setLParenLoc(ReadSourceLocation(Record, Idx));
 812   D->setType(GetTypeSourceInfo(Record, Idx));
 813   // FIXME: stable encoding
 814   D->setPropertyAttributes(
 815                       (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
 816   D->setPropertyAttributesAsWritten(
 817                       (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
 818   // FIXME: stable encoding
 819   D->setPropertyImplementation(
 820                             (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
 821   D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
 822   D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
 823   D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
 824   D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
 825   D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
 826 }
 827
 828 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
 829   VisitObjCContainerDecl(D);
 830   D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
 831 }
 832
 833 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
 834   VisitObjCImplDecl(D);
 835   D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
 836   D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
 837 }
 838
 839 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
 840   VisitObjCImplDecl(D);
 841   D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
 842   D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
 843   D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
 844   llvm::tie(D->IvarInitializers, D->NumIvarInitializers)
 845       = Reader.ReadCXXCtorInitializers(F, Record, Idx);
 846   D->setHasSynthBitfield(Record[Idx++]);
 847 }
 848
 849
 850 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
 851   VisitDecl(D);
 852   D->setAtLoc(ReadSourceLocation(Record, Idx));
 853   D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
 854   D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
 855   D->IvarLoc = ReadSourceLocation(Record, Idx);
 856   D->setGetterCXXConstructor(Reader.ReadExpr(F));
 857   D->setSetterCXXAssignment(Reader.ReadExpr(F));
 858 }
 859
 860 void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
 861   VisitDeclaratorDecl(FD);
 862   FD->setMutable(Record[Idx++]);
 863   int BitWidthOrInitializer = Record[Idx++];
 864   if (BitWidthOrInitializer == 1)
 865     FD->setBitWidth(Reader.ReadExpr(F));
 866   else if (BitWidthOrInitializer == 2)
 867     FD->setInClassInitializer(Reader.ReadExpr(F));
 868   if (!FD->getDeclName()) {
 869     if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
 870       Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
 871   }
 872 }
 873
 874 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
 875   VisitValueDecl(FD);
 876
 877   FD->ChainingSize = Record[Idx++];
 878   assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
 879   FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
 880
 881   for (unsigned I = 0; I != FD->ChainingSize; ++I)
 882     FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
 883 }
 884
 885 void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
 886   RedeclarableResult Redecl = VisitRedeclarable(VD);
 887   VisitDeclaratorDecl(VD);
 888
 889   VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
 890   VD->VarDeclBits.SClassAsWritten = (StorageClass)Record[Idx++];
 891   VD->VarDeclBits.ThreadSpecified = Record[Idx++];
 892   VD->VarDeclBits.InitStyle = Record[Idx++];
 893   VD->VarDeclBits.ExceptionVar = Record[Idx++];
 894   VD->VarDeclBits.NRVOVariable = Record[Idx++];
 895   VD->VarDeclBits.CXXForRangeDecl = Record[Idx++];
 896   VD->VarDeclBits.ARCPseudoStrong = Record[Idx++];
 897
 898   // Only true variables (not parameters or implicit parameters) can be merged.
 899   if (VD->getKind() == Decl::Var)
 900     mergeRedeclarable(VD, Redecl);
 901
 902   if (uint64_t Val = Record[Idx++]) {
 903     VD->setInit(Reader.ReadExpr(F));
 904     if (Val > 1) {
 905       EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
 906       Eval->CheckedICE = true;
 907       Eval->IsICE = Val == 3;
 908     }
 909   }
 910
 911   if (Record[Idx++]) { // HasMemberSpecializationInfo.
 912     VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
 913     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
 914     SourceLocation POI = ReadSourceLocation(Record, Idx);
 915     Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
 916   }
 917 }
 918
 919 void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
 920   VisitVarDecl(PD);
 921 }
 922
 923 void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
 924   VisitVarDecl(PD);
 925   unsigned isObjCMethodParam = Record[Idx++];
 926   unsigned scopeDepth = Record[Idx++];
 927   unsigned scopeIndex = Record[Idx++];
 928   unsigned declQualifier = Record[Idx++];
 929   if (isObjCMethodParam) {
 930     assert(scopeDepth == 0);
 931     PD->setObjCMethodScopeInfo(scopeIndex);
 932     PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
 933   } else {
 934     PD->setScopeInfo(scopeDepth, scopeIndex);
 935   }
 936   PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
 937   PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
 938   if (Record[Idx++]) // hasUninstantiatedDefaultArg.
 939     PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
 940 }
 941
 942 void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
 943   VisitDecl(AD);
 944   AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
 945   AD->setRParenLoc(ReadSourceLocation(Record, Idx));
 946 }
 947
 948 void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
 949   VisitDecl(BD);
 950   BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
 951   BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
 952   unsigned NumParams = Record[Idx++];
 953   SmallVector<ParmVarDecl *, 16> Params;
 954   Params.reserve(NumParams);
 955   for (unsigned I = 0; I != NumParams; ++I)
 956     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
 957   BD->setParams(Params);
 958
 959   BD->setIsVariadic(Record[Idx++]);
 960   BD->setBlockMissingReturnType(Record[Idx++]);
 961   BD->setIsConversionFromLambda(Record[Idx++]);
 962
 963   bool capturesCXXThis = Record[Idx++];
 964   unsigned numCaptures = Record[Idx++];
 965   SmallVector<BlockDecl::Capture, 16> captures;
 966   captures.reserve(numCaptures);
 967   for (unsigned i = 0; i != numCaptures; ++i) {
 968     VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
 969     unsigned flags = Record[Idx++];
 970     bool byRef = (flags & 1);
 971     bool nested = (flags & 2);
 972     Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : 0);
 973
 974     captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
 975   }
 976   BD->setCaptures(Reader.getContext(), captures.begin(),
 977                   captures.end(), capturesCXXThis);
 978 }
 979
 980 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
 981   VisitDecl(D);
 982   D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
 983   D->setExternLoc(ReadSourceLocation(Record, Idx));
 984   D->setRBraceLoc(ReadSourceLocation(Record, Idx));
 985 }
 986
 987 void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
 988   VisitNamedDecl(D);
 989   D->setLocStart(ReadSourceLocation(Record, Idx));
 990 }
 991
 992
 993 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
 994   RedeclarableResult Redecl = VisitRedeclarable(D);
 995   VisitNamedDecl(D);
 996   D->setInline(Record[Idx++]);
 997   D->LocStart = ReadSourceLocation(Record, Idx);
 998   D->RBraceLoc = ReadSourceLocation(Record, Idx);
 999   mergeRedeclarable(D, Redecl);
1000
1001   if (Redecl.getFirstID() == ThisDeclID) {
1002     // Each module has its own anonymous namespace, which is disjoint from
1003     // any other module's anonymous namespaces, so don't attach the anonymous
1004     // namespace at all.
1005     NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>(Record, Idx);
1006     if (F.Kind != MK_Module)
1007       D->setAnonymousNamespace(Anon);
1008   } else {
1009     // Link this namespace back to the first declaration, which has already
1010     // been deserialized.
1011     D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDeclaration());
1012   }
1013 }
1014
1015 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1016   VisitNamedDecl(D);
1017   D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1018   D->IdentLoc = ReadSourceLocation(Record, Idx);
1019   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1020   D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
1021 }
1022
1023 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1024   VisitNamedDecl(D);
1025   D->setUsingLocation(ReadSourceLocation(Record, Idx));
1026   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1027   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1028   D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
1029   D->setTypeName(Record[Idx++]);
1030   if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
1031     Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1032 }
1033
1034 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1035   VisitNamedDecl(D);
1036   D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1037   D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1038   UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1039   if (Pattern)
1040     Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1041 }
1042
1043 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1044   VisitNamedDecl(D);
1045   D->UsingLoc = ReadSourceLocation(Record, Idx);
1046   D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1047   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1048   D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
1049   D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
1050 }
1051
1052 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1053   VisitValueDecl(D);
1054   D->setUsingLoc(ReadSourceLocation(Record, Idx));
1055   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1056   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1057 }
1058
1059 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1060                                                UnresolvedUsingTypenameDecl *D) {
1061   VisitTypeDecl(D);
1062   D->TypenameLocation = ReadSourceLocation(Record, Idx);
1063   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1064 }
1065
1066 void ASTDeclReader::ReadCXXDefinitionData(
1067                                    struct CXXRecordDecl::DefinitionData &Data,
1068                                    const RecordData &Record, unsigned &Idx) {
1069   // Note: the caller has deserialized the IsLambda bit already.
1070   Data.UserDeclaredConstructor = Record[Idx++];
1071   Data.UserDeclaredCopyConstructor = Record[Idx++];
1072   Data.UserDeclaredMoveConstructor = Record[Idx++];
1073   Data.UserDeclaredCopyAssignment = Record[Idx++];
1074   Data.UserDeclaredMoveAssignment = Record[Idx++];
1075   Data.UserDeclaredDestructor = Record[Idx++];
1076   Data.Aggregate = Record[Idx++];
1077   Data.PlainOldData = Record[Idx++];
1078   Data.Empty = Record[Idx++];
1079   Data.Polymorphic = Record[Idx++];
1080   Data.Abstract = Record[Idx++];
1081   Data.IsStandardLayout = Record[Idx++];
1082   Data.HasNoNonEmptyBases = Record[Idx++];
1083   Data.HasPrivateFields = Record[Idx++];
1084   Data.HasProtectedFields = Record[Idx++];
1085   Data.HasPublicFields = Record[Idx++];
1086   Data.HasMutableFields = Record[Idx++];
1087   Data.HasOnlyCMembers = Record[Idx++];
1088   Data.HasTrivialDefaultConstructor = Record[Idx++];
1089   Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
1090   Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
1091   Data.DefaultedCopyConstructorIsConstexpr = Record[Idx++];
1092   Data.DefaultedMoveConstructorIsConstexpr = Record[Idx++];
1093   Data.HasConstexprDefaultConstructor = Record[Idx++];
1094   Data.HasConstexprCopyConstructor = Record[Idx++];
1095   Data.HasConstexprMoveConstructor = Record[Idx++];
1096   Data.HasTrivialCopyConstructor = Record[Idx++];
1097   Data.HasTrivialMoveConstructor = Record[Idx++];
1098   Data.HasTrivialCopyAssignment = Record[Idx++];
1099   Data.HasTrivialMoveAssignment = Record[Idx++];
1100   Data.HasTrivialDestructor = Record[Idx++];
1101   Data.HasIrrelevantDestructor = Record[Idx++];
1102   Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
1103   Data.ComputedVisibleConversions = Record[Idx++];
1104   Data.UserProvidedDefaultConstructor = Record[Idx++];
1105   Data.DeclaredDefaultConstructor = Record[Idx++];
1106   Data.DeclaredCopyConstructor = Record[Idx++];
1107   Data.DeclaredMoveConstructor = Record[Idx++];
1108   Data.DeclaredCopyAssignment = Record[Idx++];
1109   Data.DeclaredMoveAssignment = Record[Idx++];
1110   Data.DeclaredDestructor = Record[Idx++];
1111   Data.FailedImplicitMoveConstructor = Record[Idx++];
1112   Data.FailedImplicitMoveAssignment = Record[Idx++];
1113
1114   Data.NumBases = Record[Idx++];
1115   if (Data.NumBases)
1116     Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1117   Data.NumVBases = Record[Idx++];
1118   if (Data.NumVBases)
1119     Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1120
1121   Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
1122   Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
1123   assert(Data.Definition && "Data.Definition should be already set!");
1124   Data.FirstFriend = ReadDeclAs<FriendDecl>(Record, Idx);
1125
1126   if (Data.IsLambda) {
1127     typedef LambdaExpr::Capture Capture;
1128     CXXRecordDecl::LambdaDefinitionData &Lambda
1129       = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
1130     Lambda.Dependent = Record[Idx++];
1131     Lambda.NumCaptures = Record[Idx++];
1132     Lambda.NumExplicitCaptures = Record[Idx++];
1133     Lambda.ManglingNumber = Record[Idx++];
1134     Lambda.ContextDecl = ReadDecl(Record, Idx);
1135     Lambda.Captures
1136       = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
1137     Capture *ToCapture = Lambda.Captures;
1138     for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
1139       SourceLocation Loc = ReadSourceLocation(Record, Idx);
1140       bool IsImplicit = Record[Idx++];
1141       LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
1142       VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1143       SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1144       *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1145     }
1146   }
1147 }
1148
1149 void ASTDeclReader::VisitCXXRecordDecl(CXXRecordDecl *D) {
1150   VisitRecordDecl(D);
1151
1152   ASTContext &C = Reader.getContext();
1153   if (Record[Idx++]) {
1154     // Determine whether this is a lambda closure type, so that we can
1155     // allocate the appropriate DefinitionData structure.
1156     bool IsLambda = Record[Idx++];
1157     if (IsLambda)
1158       D->DefinitionData = new (C) CXXRecordDecl::LambdaDefinitionData(D, false);
1159     else
1160       D->DefinitionData = new (C) struct CXXRecordDecl::DefinitionData(D);
1161
1162     // Propagate the DefinitionData pointer to the canonical declaration, so
1163     // that all other deserialized declarations will see it.
1164     // FIXME: Complain if there already is a DefinitionData!
1165     D->getCanonicalDecl()->DefinitionData = D->DefinitionData;
1166
1167     ReadCXXDefinitionData(*D->DefinitionData, Record, Idx);
1168
1169     // Note that we have deserialized a definition. Any declarations
1170     // deserialized before this one will be be given the DefinitionData pointer
1171     // at the end.
1172     Reader.PendingDefinitions.insert(D);
1173   } else {
1174     // Propagate DefinitionData pointer from the canonical declaration.
1175     D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1176   }
1177
1178   enum CXXRecKind {
1179     CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1180   };
1181   switch ((CXXRecKind)Record[Idx++]) {
1182   case CXXRecNotTemplate:
1183     break;
1184   case CXXRecTemplate:
1185     D->TemplateOrInstantiation = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
1186     break;
1187   case CXXRecMemberSpecialization: {
1188     CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1189     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1190     SourceLocation POI = ReadSourceLocation(Record, Idx);
1191     MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
1192     MSI->setPointOfInstantiation(POI);
1193     D->TemplateOrInstantiation = MSI;
1194     break;
1195   }
1196   }
1197
1198   // Load the key function to avoid deserializing every method so we can
1199   // compute it.
1200   if (D->IsCompleteDefinition) {
1201     if (CXXMethodDecl *Key = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1202       C.KeyFunctions[D] = Key;
1203   }
1204 }
1205
1206 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
1207   VisitFunctionDecl(D);
1208   unsigned NumOverridenMethods = Record[Idx++];
1209   while (NumOverridenMethods--) {
1210     // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1211     // MD may be initializing.
1212     if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1213       Reader.getContext().addOverriddenMethod(D, MD);
1214   }
1215 }
1216
1217 void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1218   VisitCXXMethodDecl(D);
1219
1220   D->IsExplicitSpecified = Record[Idx++];
1221   D->ImplicitlyDefined = Record[Idx++];
1222   llvm::tie(D->CtorInitializers, D->NumCtorInitializers)
1223       = Reader.ReadCXXCtorInitializers(F, Record, Idx);
1224 }
1225
1226 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1227   VisitCXXMethodDecl(D);
1228
1229   D->ImplicitlyDefined = Record[Idx++];
1230   D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1231 }
1232
1233 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1234   VisitCXXMethodDecl(D);
1235   D->IsExplicitSpecified = Record[Idx++];
1236 }
1237
1238 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
1239   VisitDecl(D);
1240   D->ImportedAndComplete.setPointer(readModule(Record, Idx));
1241   D->ImportedAndComplete.setInt(Record[Idx++]);
1242   SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(D + 1);
1243   for (unsigned I = 0, N = Record.back(); I != N; ++I)
1244     StoredLocs[I] = ReadSourceLocation(Record, Idx);
1245   ++Idx;
1246 }
1247
1248 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1249   VisitDecl(D);
1250   D->setColonLoc(ReadSourceLocation(Record, Idx));
1251 }
1252
1253 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1254   VisitDecl(D);
1255   if (Record[Idx++])
1256     D->Friend = GetTypeSourceInfo(Record, Idx);
1257   else
1258     D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1259   D->NextFriend = Record[Idx++];
1260   D->UnsupportedFriend = (Record[Idx++] != 0);
1261   D->FriendLoc = ReadSourceLocation(Record, Idx);
1262 }
1263
1264 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1265   VisitDecl(D);
1266   unsigned NumParams = Record[Idx++];
1267   D->NumParams = NumParams;
1268   D->Params = new TemplateParameterList*[NumParams];
1269   for (unsigned i = 0; i != NumParams; ++i)
1270     D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1271   if (Record[Idx++]) // HasFriendDecl
1272     D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1273   else
1274     D->Friend = GetTypeSourceInfo(Record, Idx);
1275   D->FriendLoc = ReadSourceLocation(Record, Idx);
1276 }
1277
1278 void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1279   VisitNamedDecl(D);
1280
1281   NamedDecl *TemplatedDecl = ReadDeclAs<NamedDecl>(Record, Idx);
1282   TemplateParameterList* TemplateParams
1283       = Reader.ReadTemplateParameterList(F, Record, Idx);
1284   D->init(TemplatedDecl, TemplateParams);
1285 }
1286
1287 ASTDeclReader::RedeclarableResult
1288 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1289   RedeclarableResult Redecl = VisitRedeclarable(D);
1290
1291   // Make sure we've allocated the Common pointer first. We do this before
1292   // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
1293   RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
1294   if (!CanonD->Common) {
1295     CanonD->Common = CanonD->newCommon(Reader.getContext());
1296     Reader.PendingDefinitions.insert(CanonD);
1297   }
1298   D->Common = CanonD->Common;
1299
1300   // If this is the first declaration of the template, fill in the information
1301   // for the 'common' pointer.
1302   if (ThisDeclID == Redecl.getFirstID()) {
1303     if (RedeclarableTemplateDecl *RTD
1304           = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1305       assert(RTD->getKind() == D->getKind() &&
1306              "InstantiatedFromMemberTemplate kind mismatch");
1307       D->setInstantiatedFromMemberTemplate(RTD);
1308       if (Record[Idx++])
1309         D->setMemberSpecialization();
1310     }
1311   }
1312
1313   VisitTemplateDecl(D);
1314   D->IdentifierNamespace = Record[Idx++];
1315
1316   return Redecl;
1317 }
1318
1319 void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1320   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1321
1322   if (ThisDeclID == Redecl.getFirstID()) {
1323     // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1324     // the specializations.
1325     SmallVector<serialization::DeclID, 2> SpecIDs;
1326     SpecIDs.push_back(0);
1327
1328     // Specializations.
1329     unsigned Size = Record[Idx++];
1330     SpecIDs[0] += Size;
1331     for (unsigned I = 0; I != Size; ++I)
1332       SpecIDs.push_back(ReadDeclID(Record, Idx));
1333
1334     // Partial specializations.
1335     Size = Record[Idx++];
1336     SpecIDs[0] += Size;
1337     for (unsigned I = 0; I != Size; ++I)
1338       SpecIDs.push_back(ReadDeclID(Record, Idx));
1339
1340     if (SpecIDs[0]) {
1341       typedef serialization::DeclID DeclID;
1342
1343       ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1344       // FIXME: Append specializations!
1345       CommonPtr->LazySpecializations
1346         = new (Reader.getContext()) DeclID [SpecIDs.size()];
1347       memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1348              SpecIDs.size() * sizeof(DeclID));
1349     }
1350
1351     // InjectedClassNameType is computed.
1352   }
1353 }
1354
1355 void ASTDeclReader::VisitClassTemplateSpecializationDecl(
1356                                            ClassTemplateSpecializationDecl *D) {
1357   VisitCXXRecordDecl(D);
1358
1359   ASTContext &C = Reader.getContext();
1360   if (Decl *InstD = ReadDecl(Record, Idx)) {
1361     if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1362       D->SpecializedTemplate = CTD;
1363     } else {
1364       SmallVector<TemplateArgument, 8> TemplArgs;
1365       Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1366       TemplateArgumentList *ArgList
1367         = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1368                                            TemplArgs.size());
1369       ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1370           = new (C) ClassTemplateSpecializationDecl::
1371                                              SpecializedPartialSpecialization();
1372       PS->PartialSpecialization
1373           = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1374       PS->TemplateArgs = ArgList;
1375       D->SpecializedTemplate = PS;
1376     }
1377   }
1378
1379   // Explicit info.
1380   if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1381     ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
1382         = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
1383     ExplicitInfo->TypeAsWritten = TyInfo;
1384     ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1385     ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1386     D->ExplicitInfo = ExplicitInfo;
1387   }
1388
1389   SmallVector<TemplateArgument, 8> TemplArgs;
1390   Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1391   D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1392                                                      TemplArgs.size());
1393   D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1394   D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1395
1396   if (D->isCanonicalDecl()) { // It's kept in the folding set.
1397     ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
1398     if (ClassTemplatePartialSpecializationDecl *Partial
1399                        = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
1400       CanonPattern->getCommonPtr()->PartialSpecializations.InsertNode(Partial);
1401     } else {
1402       CanonPattern->getCommonPtr()->Specializations.InsertNode(D);
1403     }
1404   }
1405 }
1406
1407 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
1408                                     ClassTemplatePartialSpecializationDecl *D) {
1409   VisitClassTemplateSpecializationDecl(D);
1410
1411   ASTContext &C = Reader.getContext();
1412   D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1413
1414   unsigned NumArgs = Record[Idx++];
1415   if (NumArgs) {
1416     D->NumArgsAsWritten = NumArgs;
1417     D->ArgsAsWritten = new (C) TemplateArgumentLoc[NumArgs];
1418     for (unsigned i=0; i != NumArgs; ++i)
1419       D->ArgsAsWritten[i] = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1420   }
1421
1422   D->SequenceNumber = Record[Idx++];
1423
1424   // These are read/set from/to the first declaration.
1425   if (D->getPreviousDecl() == 0) {
1426     D->InstantiatedFromMember.setPointer(
1427       ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
1428     D->InstantiatedFromMember.setInt(Record[Idx++]);
1429   }
1430 }
1431
1432 void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
1433                                     ClassScopeFunctionSpecializationDecl *D) {
1434   VisitDecl(D);
1435   D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
1436 }
1437
1438 void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1439   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1440
1441   if (ThisDeclID == Redecl.getFirstID()) {
1442     // This FunctionTemplateDecl owns a CommonPtr; read it.
1443
1444     // Read the function specialization declarations.
1445     // FunctionTemplateDecl's FunctionTemplateSpecializationInfos are filled
1446     // when reading the specialized FunctionDecl.
1447     unsigned NumSpecs = Record[Idx++];
1448     while (NumSpecs--)
1449       (void)ReadDecl(Record, Idx);
1450   }
1451 }
1452
1453 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1454   VisitTypeDecl(D);
1455
1456   D->setDeclaredWithTypename(Record[Idx++]);
1457
1458   bool Inherited = Record[Idx++];
1459   TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
1460   D->setDefaultArgument(DefArg, Inherited);
1461 }
1462
1463 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1464   VisitDeclaratorDecl(D);
1465   // TemplateParmPosition.
1466   D->setDepth(Record[Idx++]);
1467   D->setPosition(Record[Idx++]);
1468   if (D->isExpandedParameterPack()) {
1469     void **Data = reinterpret_cast<void **>(D + 1);
1470     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1471       Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr();
1472       Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
1473     }
1474   } else {
1475     // Rest of NonTypeTemplateParmDecl.
1476     D->ParameterPack = Record[Idx++];
1477     if (Record[Idx++]) {
1478       Expr *DefArg = Reader.ReadExpr(F);
1479       bool Inherited = Record[Idx++];
1480       D->setDefaultArgument(DefArg, Inherited);
1481    }
1482   }
1483 }
1484
1485 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1486   VisitTemplateDecl(D);
1487   // TemplateParmPosition.
1488   D->setDepth(Record[Idx++]);
1489   D->setPosition(Record[Idx++]);
1490   // Rest of TemplateTemplateParmDecl.
1491   TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1492   bool IsInherited = Record[Idx++];
1493   D->setDefaultArgument(Arg, IsInherited);
1494   D->ParameterPack = Record[Idx++];
1495 }
1496
1497 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1498   VisitRedeclarableTemplateDecl(D);
1499 }
1500
1501 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
1502   VisitDecl(D);
1503   D->AssertExpr = Reader.ReadExpr(F);
1504   D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
1505   D->RParenLoc = ReadSourceLocation(Record, Idx);
1506 }
1507
1508 std::pair<uint64_t, uint64_t>
1509 ASTDeclReader::VisitDeclContext(DeclContext *DC) {
1510   uint64_t LexicalOffset = Record[Idx++];
1511   uint64_t VisibleOffset = Record[Idx++];
1512   return std::make_pair(LexicalOffset, VisibleOffset);
1513 }
1514
1515 template <typename T>
1516 ASTDeclReader::RedeclarableResult
1517 ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
1518   DeclID FirstDeclID = ReadDeclID(Record, Idx);
1519
1520   // 0 indicates that this declaration was the only declaration of its entity,
1521   // and is used for space optimization.
1522   if (FirstDeclID == 0)
1523     FirstDeclID = ThisDeclID;
1524
1525   T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
1526   if (FirstDecl != D) {
1527     // We delay loading of the redeclaration chain to avoid deeply nested calls.
1528     // We temporarily set the first (canonical) declaration as the previous one
1529     // which is the one that matters and mark the real previous DeclID to be
1530     // loaded & attached later on.
1531     D->RedeclLink = typename Redeclarable<T>::PreviousDeclLink(FirstDecl);
1532   }
1533
1534   // Note that this declaration has been deserialized.
1535   Reader.RedeclsDeserialized.insert(static_cast<T *>(D));
1536
1537   // The result structure takes care to note that we need to load the
1538   // other declaration chains for this ID.
1539   return RedeclarableResult(Reader, FirstDeclID);
1540 }
1541
1542 /// \brief Attempts to merge the given declaration (D) with another declaration
1543 /// of the same entity.
1544 template<typename T>
1545 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *D,
1546                                       RedeclarableResult &Redecl) {
1547   // If modules are not available, there is no reason to perform this merge.
1548   if (!Reader.getContext().getLangOpts().Modules)
1549     return;
1550
1551   if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D))) {
1552     if (T *Existing = ExistingRes) {
1553       T *ExistingCanon = Existing->getCanonicalDecl();
1554       T *DCanon = static_cast<T*>(D)->getCanonicalDecl();
1555       if (ExistingCanon != DCanon) {
1556         // Have our redeclaration link point back at the canonical declaration
1557         // of the existing declaration, so that this declaration has the
1558         // appropriate canonical declaration.
1559         D->RedeclLink
1560           = typename Redeclarable<T>::PreviousDeclLink(ExistingCanon);
1561
1562         // When we merge a namespace, update its pointer to the first namespace.
1563         if (NamespaceDecl *Namespace
1564               = dyn_cast<NamespaceDecl>(static_cast<T*>(D))) {
1565           Namespace->AnonOrFirstNamespaceAndInline.setPointer(
1566             static_cast<NamespaceDecl *>(static_cast<void*>(ExistingCanon)));
1567         }
1568
1569         // Don't introduce DCanon into the set of pending declaration chains.
1570         Redecl.suppress();
1571
1572         // Introduce ExistingCanon into the set of pending declaration chains,
1573         // if in fact it came from a module file.
1574         if (ExistingCanon->isFromASTFile()) {
1575           GlobalDeclID ExistingCanonID = ExistingCanon->getGlobalID();
1576           assert(ExistingCanonID && "Unrecorded canonical declaration ID?");
1577           if (Reader.PendingDeclChainsKnown.insert(ExistingCanonID))
1578             Reader.PendingDeclChains.push_back(ExistingCanonID);
1579         }
1580
1581         // If this declaration was the canonical declaration, make a note of
1582         // that. We accept the linear algorithm here because the number of
1583         // unique canonical declarations of an entity should always be tiny.
1584         if (DCanon == static_cast<T*>(D)) {
1585           SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon];
1586           if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID())
1587                 == Merged.end())
1588             Merged.push_back(Redecl.getFirstID());
1589
1590           // If ExistingCanon did not come from a module file, introduce the
1591           // first declaration that *does* come from a module file to the
1592           // set of pending declaration chains, so that we merge this
1593           // declaration.
1594           if (!ExistingCanon->isFromASTFile() &&
1595               Reader.PendingDeclChainsKnown.insert(Redecl.getFirstID()))
1596             Reader.PendingDeclChains.push_back(Merged[0]);
1597         }
1598       }
1599     }
1600   }
1601 }
1602
1603 //===----------------------------------------------------------------------===//
1604 // Attribute Reading
1605 //===----------------------------------------------------------------------===//
1606
1607 /// \brief Reads attributes from the current stream position.
1608 void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
1609                                const RecordData &Record, unsigned &Idx) {
1610   for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
1611     Attr *New = 0;
1612     attr::Kind Kind = (attr::Kind)Record[Idx++];
1613     SourceRange Range = ReadSourceRange(F, Record, Idx);
1614
1615 #include "clang/Serialization/AttrPCHRead.inc"
1616
1617     assert(New && "Unable to decode attribute?");
1618     Attrs.push_back(New);
1619   }
1620 }
1621
1622 //===----------------------------------------------------------------------===//
1623 // ASTReader Implementation
1624 //===----------------------------------------------------------------------===//
1625
1626 /// \brief Note that we have loaded the declaration with the given
1627 /// Index.
1628 ///
1629 /// This routine notes that this declaration has already been loaded,
1630 /// so that future GetDecl calls will return this declaration rather
1631 /// than trying to load a new declaration.
1632 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
1633   assert(!DeclsLoaded[Index] && "Decl loaded twice?");
1634   DeclsLoaded[Index] = D;
1635 }
1636
1637
1638 /// \brief Determine whether the consumer will be interested in seeing
1639 /// this declaration (via HandleTopLevelDecl).
1640 ///
1641 /// This routine should return true for anything that might affect
1642 /// code generation, e.g., inline function definitions, Objective-C
1643 /// declarations with metadata, etc.
1644 static bool isConsumerInterestedIn(Decl *D) {
1645   // An ObjCMethodDecl is never considered as "interesting" because its
1646   // implementation container always is.
1647
1648   if (isa<FileScopeAsmDecl>(D) ||
1649       isa<ObjCProtocolDecl>(D) ||
1650       isa<ObjCImplDecl>(D))
1651     return true;
1652   if (VarDecl *Var = dyn_cast<VarDecl>(D))
1653     return Var->isFileVarDecl() &&
1654            Var->isThisDeclarationADefinition() == VarDecl::Definition;
1655   if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
1656     return Func->doesThisDeclarationHaveABody();
1657
1658   return false;
1659 }
1660
1661 /// \brief Get the correct cursor and offset for loading a declaration.
1662 ASTReader::RecordLocation
1663 ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) {
1664   // See if there's an override.
1665   DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
1666   if (It != ReplacedDecls.end()) {
1667     RawLocation = It->second.RawLoc;
1668     return RecordLocation(It->second.Mod, It->second.Offset);
1669   }
1670
1671   GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
1672   assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
1673   ModuleFile *M = I->second;
1674   const DeclOffset &
1675     DOffs =  M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
1676   RawLocation = DOffs.Loc;
1677   return RecordLocation(M, DOffs.BitOffset);
1678 }
1679
1680 ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
1681   ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
1682     = GlobalBitOffsetsMap.find(GlobalOffset);
1683
1684   assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
1685   return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
1686 }
1687
1688 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
1689   return LocalOffset + M.GlobalBitOffset;
1690 }
1691
1692 /// \brief Determine whether the two declarations refer to the same entity.
1693 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
1694   assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
1695
1696   if (X == Y)
1697     return true;
1698
1699   // Must be in the same context.
1700   if (!X->getDeclContext()->getRedeclContext()->Equals(
1701          Y->getDeclContext()->getRedeclContext()))
1702     return false;
1703
1704   // Two typedefs refer to the same entity if they have the same underlying
1705   // type.
1706   if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
1707     if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
1708       return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
1709                                             TypedefY->getUnderlyingType());
1710
1711   // Must have the same kind.
1712   if (X->getKind() != Y->getKind())
1713     return false;
1714
1715   // Objective-C classes and protocols with the same name always match.
1716   if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
1717     return true;
1718
1719   // Compatible tags match.
1720   if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
1721     TagDecl *TagY = cast<TagDecl>(Y);
1722     return (TagX->getTagKind() == TagY->getTagKind()) ||
1723       ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class) &&
1724        (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class));
1725   }
1726
1727   // Functions with the same type and linkage match.
1728   // FIXME: This needs to cope with function templates, merging of
1729   //prototyped/non-prototyped functions, etc.
1730   if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
1731     FunctionDecl *FuncY = cast<FunctionDecl>(Y);
1732     return (FuncX->getLinkage() == FuncY->getLinkage()) &&
1733       FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
1734   }
1735
1736   // Variables with the same type and linkage match.
1737   if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
1738     VarDecl *VarY = cast<VarDecl>(Y);
1739     return (VarX->getLinkage() == VarY->getLinkage()) &&
1740       VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType());
1741   }
1742
1743   // Namespaces with the same name and inlinedness match.
1744   if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
1745     NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
1746     return NamespaceX->isInline() == NamespaceY->isInline();
1747   }
1748
1749   // FIXME: Many other cases to implement.
1750   return false;
1751 }
1752
1753 ASTDeclReader::FindExistingResult::~FindExistingResult() {
1754   if (!AddResult || Existing)
1755     return;
1756
1757   DeclContext *DC = New->getDeclContext()->getRedeclContext();
1758   if (DC->isTranslationUnit() && Reader.SemaObj) {
1759     Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, New->getDeclName());
1760   } else if (DC->isNamespace()) {
1761     DC->addDecl(New);
1762   }
1763 }
1764
1765 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
1766   DeclarationName Name = D->getDeclName();
1767   if (!Name) {
1768     // Don't bother trying to find unnamed declarations.
1769     FindExistingResult Result(Reader, D, /*Existing=*/0);
1770     Result.suppress();
1771     return Result;
1772   }
1773
1774   DeclContext *DC = D->getDeclContext()->getRedeclContext();
1775   if (!DC->isFileContext())
1776     return FindExistingResult(Reader);
1777
1778   if (DC->isTranslationUnit() && Reader.SemaObj) {
1779     IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
1780     for (IdentifierResolver::iterator I = IdResolver.begin(Name),
1781                                    IEnd = IdResolver.end();
1782          I != IEnd; ++I) {
1783       if (isSameEntity(*I, D))
1784         return FindExistingResult(Reader, D, *I);
1785     }
1786   }
1787
1788   if (DC->isNamespace()) {
1789     for (DeclContext::lookup_result R = DC->lookup(Name);
1790          R.first != R.second; ++R.first) {
1791       if (isSameEntity(*R.first, D))
1792         return FindExistingResult(Reader, D, *R.first);
1793     }
1794   }
1795
1796   return FindExistingResult(Reader, D, /*Existing=*/0);
1797 }
1798
1799 void ASTDeclReader::attachPreviousDecl(Decl *D, Decl *previous) {
1800   assert(D && previous);
1801   if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1802     TD->RedeclLink.setPointer(cast<TagDecl>(previous));
1803   } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1804     FD->RedeclLink.setPointer(cast<FunctionDecl>(previous));
1805   } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1806     VD->RedeclLink.setPointer(cast<VarDecl>(previous));
1807   } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1808     TD->RedeclLink.setPointer(cast<TypedefNameDecl>(previous));
1809   } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
1810     ID->RedeclLink.setPointer(cast<ObjCInterfaceDecl>(previous));
1811   } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
1812     PD->RedeclLink.setPointer(cast<ObjCProtocolDecl>(previous));
1813   } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
1814     ND->RedeclLink.setPointer(cast<NamespaceDecl>(previous));
1815   } else {
1816     RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1817     TD->RedeclLink.setPointer(cast<RedeclarableTemplateDecl>(previous));
1818   }
1819 }
1820
1821 void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
1822   assert(D && Latest);
1823   if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1824     TD->RedeclLink
1825       = Redeclarable<TagDecl>::LatestDeclLink(cast<TagDecl>(Latest));
1826   } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1827     FD->RedeclLink
1828       = Redeclarable<FunctionDecl>::LatestDeclLink(cast<FunctionDecl>(Latest));
1829   } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1830     VD->RedeclLink
1831       = Redeclarable<VarDecl>::LatestDeclLink(cast<VarDecl>(Latest));
1832   } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1833     TD->RedeclLink
1834       = Redeclarable<TypedefNameDecl>::LatestDeclLink(
1835                                                 cast<TypedefNameDecl>(Latest));
1836   } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
1837     ID->RedeclLink
1838       = Redeclarable<ObjCInterfaceDecl>::LatestDeclLink(
1839                                               cast<ObjCInterfaceDecl>(Latest));
1840   } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
1841     PD->RedeclLink
1842       = Redeclarable<ObjCProtocolDecl>::LatestDeclLink(
1843                                                 cast<ObjCProtocolDecl>(Latest));
1844   } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
1845     ND->RedeclLink
1846       = Redeclarable<NamespaceDecl>::LatestDeclLink(
1847                                                    cast<NamespaceDecl>(Latest));
1848   } else {
1849     RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1850     TD->RedeclLink
1851       = Redeclarable<RedeclarableTemplateDecl>::LatestDeclLink(
1852                                         cast<RedeclarableTemplateDecl>(Latest));
1853   }
1854 }
1855
1856 ASTReader::MergedDeclsMap::iterator
1857 ASTReader::combineStoredMergedDecls(Decl *Canon, GlobalDeclID CanonID) {
1858   // If we don't have any stored merged declarations, just look in the
1859   // merged declarations set.
1860   StoredMergedDeclsMap::iterator StoredPos = StoredMergedDecls.find(CanonID);
1861   if (StoredPos == StoredMergedDecls.end())
1862     return MergedDecls.find(Canon);
1863
1864   // Append the stored merged declarations to the merged declarations set.
1865   MergedDeclsMap::iterator Pos = MergedDecls.find(Canon);
1866   if (Pos == MergedDecls.end())
1867     Pos = MergedDecls.insert(std::make_pair(Canon,
1868                                             SmallVector<DeclID, 2>())).first;
1869   Pos->second.append(StoredPos->second.begin(), StoredPos->second.end());
1870   StoredMergedDecls.erase(StoredPos);
1871
1872   // Sort and uniquify the set of merged declarations.
1873   llvm::array_pod_sort(Pos->second.begin(), Pos->second.end());
1874   Pos->second.erase(std::unique(Pos->second.begin(), Pos->second.end()),
1875                     Pos->second.end());
1876   return Pos;
1877 }
1878
1879 void ASTReader::loadAndAttachPreviousDecl(Decl *D, serialization::DeclID ID) {
1880   Decl *previous = GetDecl(ID);
1881   ASTDeclReader::attachPreviousDecl(D, previous);
1882 }
1883
1884 /// \brief Read the declaration at the given offset from the AST file.
1885 Decl *ASTReader::ReadDeclRecord(DeclID ID) {
1886   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
1887   unsigned RawLocation = 0;
1888   RecordLocation Loc = DeclCursorForID(ID, RawLocation);
1889   llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
1890   // Keep track of where we are in the stream, then jump back there
1891   // after reading this declaration.
1892   SavedStreamPosition SavedPosition(DeclsCursor);
1893
1894   ReadingKindTracker ReadingKind(Read_Decl, *this);
1895
1896   // Note that we are loading a declaration record.
1897   Deserializing ADecl(this);
1898
1899   DeclsCursor.JumpToBit(Loc.Offset);
1900   RecordData Record;
1901   unsigned Code = DeclsCursor.ReadCode();
1902   unsigned Idx = 0;
1903   ASTDeclReader Reader(*this, *Loc.F, DeclsCursor, ID, RawLocation, Record,Idx);
1904
1905   Decl *D = 0;
1906   switch ((DeclCode)DeclsCursor.ReadRecord(Code, Record)) {
1907   case DECL_CONTEXT_LEXICAL:
1908   case DECL_CONTEXT_VISIBLE:
1909     llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
1910   case DECL_TYPEDEF:
1911     D = TypedefDecl::CreateDeserialized(Context, ID);
1912     break;
1913   case DECL_TYPEALIAS:
1914     D = TypeAliasDecl::CreateDeserialized(Context, ID);
1915     break;
1916   case DECL_ENUM:
1917     D = EnumDecl::CreateDeserialized(Context, ID);
1918     break;
1919   case DECL_RECORD:
1920     D = RecordDecl::CreateDeserialized(Context, ID);
1921     break;
1922   case DECL_ENUM_CONSTANT:
1923     D = EnumConstantDecl::CreateDeserialized(Context, ID);
1924     break;
1925   case DECL_FUNCTION:
1926     D = FunctionDecl::CreateDeserialized(Context, ID);
1927     break;
1928   case DECL_LINKAGE_SPEC:
1929     D = LinkageSpecDecl::CreateDeserialized(Context, ID);
1930     break;
1931   case DECL_LABEL:
1932     D = LabelDecl::CreateDeserialized(Context, ID);
1933     break;
1934   case DECL_NAMESPACE:
1935     D = NamespaceDecl::CreateDeserialized(Context, ID);
1936     break;
1937   case DECL_NAMESPACE_ALIAS:
1938     D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
1939     break;
1940   case DECL_USING:
1941     D = UsingDecl::CreateDeserialized(Context, ID);
1942     break;
1943   case DECL_USING_SHADOW:
1944     D = UsingShadowDecl::CreateDeserialized(Context, ID);
1945     break;
1946   case DECL_USING_DIRECTIVE:
1947     D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
1948     break;
1949   case DECL_UNRESOLVED_USING_VALUE:
1950     D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
1951     break;
1952   case DECL_UNRESOLVED_USING_TYPENAME:
1953     D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
1954     break;
1955   case DECL_CXX_RECORD:
1956     D = CXXRecordDecl::CreateDeserialized(Context, ID);
1957     break;
1958   case DECL_CXX_METHOD:
1959     D = CXXMethodDecl::CreateDeserialized(Context, ID);
1960     break;
1961   case DECL_CXX_CONSTRUCTOR:
1962     D = CXXConstructorDecl::CreateDeserialized(Context, ID);
1963     break;
1964   case DECL_CXX_DESTRUCTOR:
1965     D = CXXDestructorDecl::CreateDeserialized(Context, ID);
1966     break;
1967   case DECL_CXX_CONVERSION:
1968     D = CXXConversionDecl::CreateDeserialized(Context, ID);
1969     break;
1970   case DECL_ACCESS_SPEC:
1971     D = AccessSpecDecl::CreateDeserialized(Context, ID);
1972     break;
1973   case DECL_FRIEND:
1974     D = FriendDecl::CreateDeserialized(Context, ID);
1975     break;
1976   case DECL_FRIEND_TEMPLATE:
1977     D = FriendTemplateDecl::CreateDeserialized(Context, ID);
1978     break;
1979   case DECL_CLASS_TEMPLATE:
1980     D = ClassTemplateDecl::CreateDeserialized(Context, ID);
1981     break;
1982   case DECL_CLASS_TEMPLATE_SPECIALIZATION:
1983     D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
1984     break;
1985   case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
1986     D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
1987     break;
1988   case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
1989     D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
1990     break;
1991   case DECL_FUNCTION_TEMPLATE:
1992     D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
1993     break;
1994   case DECL_TEMPLATE_TYPE_PARM:
1995     D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
1996     break;
1997   case DECL_NON_TYPE_TEMPLATE_PARM:
1998     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
1999     break;
2000   case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
2001     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2002     break;
2003   case DECL_TEMPLATE_TEMPLATE_PARM:
2004     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
2005     break;
2006   case DECL_TYPE_ALIAS_TEMPLATE:
2007     D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
2008     break;
2009   case DECL_STATIC_ASSERT:
2010     D = StaticAssertDecl::CreateDeserialized(Context, ID);
2011     break;
2012   case DECL_OBJC_METHOD:
2013     D = ObjCMethodDecl::CreateDeserialized(Context, ID);
2014     break;
2015   case DECL_OBJC_INTERFACE:
2016     D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
2017     break;
2018   case DECL_OBJC_IVAR:
2019     D = ObjCIvarDecl::CreateDeserialized(Context, ID);
2020     break;
2021   case DECL_OBJC_PROTOCOL:
2022     D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
2023     break;
2024   case DECL_OBJC_AT_DEFS_FIELD:
2025     D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
2026     break;
2027   case DECL_OBJC_CATEGORY:
2028     D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
2029     break;
2030   case DECL_OBJC_CATEGORY_IMPL:
2031     D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
2032     break;
2033   case DECL_OBJC_IMPLEMENTATION:
2034     D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
2035     break;
2036   case DECL_OBJC_COMPATIBLE_ALIAS:
2037     D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
2038     break;
2039   case DECL_OBJC_PROPERTY:
2040     D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
2041     break;
2042   case DECL_OBJC_PROPERTY_IMPL:
2043     D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
2044     break;
2045   case DECL_FIELD:
2046     D = FieldDecl::CreateDeserialized(Context, ID);
2047     break;
2048   case DECL_INDIRECTFIELD:
2049     D = IndirectFieldDecl::CreateDeserialized(Context, ID);
2050     break;
2051   case DECL_VAR:
2052     D = VarDecl::CreateDeserialized(Context, ID);
2053     break;
2054   case DECL_IMPLICIT_PARAM:
2055     D = ImplicitParamDecl::CreateDeserialized(Context, ID);
2056     break;
2057   case DECL_PARM_VAR:
2058     D = ParmVarDecl::CreateDeserialized(Context, ID);
2059     break;
2060   case DECL_FILE_SCOPE_ASM:
2061     D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
2062     break;
2063   case DECL_BLOCK:
2064     D = BlockDecl::CreateDeserialized(Context, ID);
2065     break;
2066   case DECL_CXX_BASE_SPECIFIERS:
2067     Error("attempt to read a C++ base-specifier record as a declaration");
2068     return 0;
2069   case DECL_IMPORT:
2070     // Note: last entry of the ImportDecl record is the number of stored source
2071     // locations.
2072     D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
2073     break;
2074   }
2075
2076   assert(D && "Unknown declaration reading AST file");
2077   LoadedDecl(Index, D);
2078   // Set the DeclContext before doing any deserialization, to make sure internal
2079   // calls to Decl::getASTContext() by Decl's methods will find the
2080   // TranslationUnitDecl without crashing.
2081   D->setDeclContext(Context.getTranslationUnitDecl());
2082   Reader.Visit(D);
2083
2084   // If this declaration is also a declaration context, get the
2085   // offsets for its tables of lexical and visible declarations.
2086   if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
2087     std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
2088     if (Offsets.first || Offsets.second) {
2089       if (Offsets.first != 0)
2090         DC->setHasExternalLexicalStorage(true);
2091       if (Offsets.second != 0)
2092         DC->setHasExternalVisibleStorage(true);
2093       if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets,
2094                                  Loc.F->DeclContextInfos[DC]))
2095         return 0;
2096     }
2097
2098     // Now add the pending visible updates for this decl context, if it has any.
2099     DeclContextVisibleUpdatesPending::iterator I =
2100         PendingVisibleUpdates.find(ID);
2101     if (I != PendingVisibleUpdates.end()) {
2102       // There are updates. This means the context has external visible
2103       // storage, even if the original stored version didn't.
2104       DC->setHasExternalVisibleStorage(true);
2105       DeclContextVisibleUpdates &U = I->second;
2106       for (DeclContextVisibleUpdates::iterator UI = U.begin(), UE = U.end();
2107            UI != UE; ++UI) {
2108         DeclContextInfo &Info = UI->second->DeclContextInfos[DC];
2109         delete Info.NameLookupTableData;
2110         Info.NameLookupTableData = UI->first;
2111       }
2112       PendingVisibleUpdates.erase(I);
2113     }
2114   }
2115   assert(Idx == Record.size());
2116
2117   // Load any relevant update records.
2118   loadDeclUpdateRecords(ID, D);
2119
2120   // Load the categories after recursive loading is finished.
2121   if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
2122     if (Class->isThisDeclarationADefinition())
2123       loadObjCCategories(ID, Class);
2124
2125   // If we have deserialized a declaration that has a definition the
2126   // AST consumer might need to know about, queue it.
2127   // We don't pass it to the consumer immediately because we may be in recursive
2128   // loading, and some declarations may still be initializing.
2129   if (isConsumerInterestedIn(D))
2130     InterestingDecls.push_back(D);
2131
2132   return D;
2133 }
2134
2135 void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
2136   // The declaration may have been modified by files later in the chain.
2137   // If this is the case, read the record containing the updates from each file
2138   // and pass it to ASTDeclReader to make the modifications.
2139   DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
2140   if (UpdI != DeclUpdateOffsets.end()) {
2141     FileOffsetsTy &UpdateOffsets = UpdI->second;
2142     for (FileOffsetsTy::iterator
2143          I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
2144       ModuleFile *F = I->first;
2145       uint64_t Offset = I->second;
2146       llvm::BitstreamCursor &Cursor = F->DeclsCursor;
2147       SavedStreamPosition SavedPosition(Cursor);
2148       Cursor.JumpToBit(Offset);
2149       RecordData Record;
2150       unsigned Code = Cursor.ReadCode();
2151       unsigned RecCode = Cursor.ReadRecord(Code, Record);
2152       (void)RecCode;
2153       assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
2154
2155       unsigned Idx = 0;
2156       ASTDeclReader Reader(*this, *F, Cursor, ID, 0, Record, Idx);
2157       Reader.UpdateDecl(D, *F, Record);
2158     }
2159   }
2160 }
2161
2162 namespace {
2163   struct CompareLocalRedeclarationsInfoToID {
2164     bool operator()(const LocalRedeclarationsInfo &X, DeclID Y) {
2165       return X.FirstID < Y;
2166     }
2167
2168     bool operator()(DeclID X, const LocalRedeclarationsInfo &Y) {
2169       return X < Y.FirstID;
2170     }
2171
2172     bool operator()(const LocalRedeclarationsInfo &X,
2173                     const LocalRedeclarationsInfo &Y) {
2174       return X.FirstID < Y.FirstID;
2175     }
2176     bool operator()(DeclID X, DeclID Y) {
2177       return X < Y;
2178     }
2179   };
2180
2181   /// \brief Module visitor class that finds all of the redeclarations of a
2182   ///
2183   class RedeclChainVisitor {
2184     ASTReader &Reader;
2185     SmallVectorImpl<DeclID> &SearchDecls;
2186     llvm::SmallPtrSet<Decl *, 16> &Deserialized;
2187     GlobalDeclID CanonID;
2188     llvm::SmallVector<Decl *, 4> Chain;
2189
2190   public:
2191     RedeclChainVisitor(ASTReader &Reader, SmallVectorImpl<DeclID> &SearchDecls,
2192                        llvm::SmallPtrSet<Decl *, 16> &Deserialized,
2193                        GlobalDeclID CanonID)
2194       : Reader(Reader), SearchDecls(SearchDecls), Deserialized(Deserialized),
2195         CanonID(CanonID) {
2196       for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2197         addToChain(Reader.GetDecl(SearchDecls[I]));
2198     }
2199
2200     static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
2201       if (Preorder)
2202         return false;
2203
2204       return static_cast<RedeclChainVisitor *>(UserData)->visit(M);
2205     }
2206
2207     void addToChain(Decl *D) {
2208       if (!D)
2209         return;
2210
2211       if (Deserialized.count(D)) {
2212         Deserialized.erase(D);
2213         Chain.push_back(D);
2214       }
2215     }
2216
2217     void searchForID(ModuleFile &M, GlobalDeclID GlobalID) {
2218       // Map global ID of the first declaration down to the local ID
2219       // used in this module file.
2220       DeclID ID = Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID);
2221       if (!ID)
2222         return;
2223
2224       // Perform a binary search to find the local redeclarations for this
2225       // declaration (if any).
2226       const LocalRedeclarationsInfo *Result
2227         = std::lower_bound(M.RedeclarationsMap,
2228                            M.RedeclarationsMap + M.LocalNumRedeclarationsInMap,
2229                            ID, CompareLocalRedeclarationsInfoToID());
2230       if (Result == M.RedeclarationsMap + M.LocalNumRedeclarationsInMap ||
2231           Result->FirstID != ID) {
2232         // If we have a previously-canonical singleton declaration that was
2233         // merged into another redeclaration chain, create a trivial chain
2234         // for this single declaration so that it will get wired into the
2235         // complete redeclaration chain.
2236         if (GlobalID != CanonID &&
2237             GlobalID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
2238             GlobalID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls) {
2239           addToChain(Reader.GetDecl(GlobalID));
2240         }
2241
2242         return;
2243       }
2244
2245       // Dig out all of the redeclarations.
2246       unsigned Offset = Result->Offset;
2247       unsigned N = M.RedeclarationChains[Offset];
2248       M.RedeclarationChains[Offset++] = 0; // Don't try to deserialize again
2249       for (unsigned I = 0; I != N; ++I)
2250         addToChain(Reader.GetLocalDecl(M, M.RedeclarationChains[Offset++]));
2251     }
2252
2253     bool visit(ModuleFile &M) {
2254       // Visit each of the declarations.
2255       for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2256         searchForID(M, SearchDecls[I]);
2257       return false;
2258     }
2259
2260     ArrayRef<Decl *> getChain() const {
2261       return Chain;
2262     }
2263   };
2264 }
2265
2266 void ASTReader::loadPendingDeclChain(serialization::GlobalDeclID ID) {
2267   Decl *D = GetDecl(ID);
2268   Decl *CanonDecl = D->getCanonicalDecl();
2269
2270   // Determine the set of declaration IDs we'll be searching for.
2271   llvm::SmallVector<DeclID, 1> SearchDecls;
2272   GlobalDeclID CanonID = 0;
2273   if (D == CanonDecl) {
2274     SearchDecls.push_back(ID); // Always first.
2275     CanonID = ID;
2276   }
2277   MergedDeclsMap::iterator MergedPos = combineStoredMergedDecls(CanonDecl, ID);
2278   if (MergedPos != MergedDecls.end())
2279     SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end());
2280
2281   // Build up the list of redeclarations.
2282   RedeclChainVisitor Visitor(*this, SearchDecls, RedeclsDeserialized, CanonID);
2283   ModuleMgr.visitDepthFirst(&RedeclChainVisitor::visit, &Visitor);
2284
2285   // Retrieve the chains.
2286   ArrayRef<Decl *> Chain = Visitor.getChain();
2287   if (Chain.empty())
2288     return;
2289
2290   // Hook up the chains.
2291   Decl *MostRecent = CanonDecl->getMostRecentDecl();
2292   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2293     if (Chain[I] == CanonDecl)
2294       continue;
2295
2296     ASTDeclReader::attachPreviousDecl(Chain[I], MostRecent);
2297     MostRecent = Chain[I];
2298   }
2299
2300   ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
2301 }
2302
2303 namespace {
2304   struct CompareObjCCategoriesInfo {
2305     bool operator()(const ObjCCategoriesInfo &X, DeclID Y) {
2306       return X.DefinitionID < Y;
2307     }
2308
2309     bool operator()(DeclID X, const ObjCCategoriesInfo &Y) {
2310       return X < Y.DefinitionID;
2311     }
2312
2313     bool operator()(const ObjCCategoriesInfo &X,
2314                     const ObjCCategoriesInfo &Y) {
2315       return X.DefinitionID < Y.DefinitionID;
2316     }
2317     bool operator()(DeclID X, DeclID Y) {
2318       return X < Y;
2319     }
2320   };
2321
2322   /// \brief Given an ObjC interface, goes through the modules and links to the
2323   /// interface all the categories for it.
2324   class ObjCCategoriesVisitor {
2325     ASTReader &Reader;
2326     serialization::GlobalDeclID InterfaceID;
2327     ObjCInterfaceDecl *Interface;
2328     llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized;
2329     unsigned PreviousGeneration;
2330     ObjCCategoryDecl *Tail;
2331     llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
2332
2333     void add(ObjCCategoryDecl *Cat) {
2334       // Only process each category once.
2335       if (!Deserialized.count(Cat))
2336         return;
2337       Deserialized.erase(Cat);
2338
2339       // Check for duplicate categories.
2340       if (Cat->getDeclName()) {
2341         ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
2342         if (Existing &&
2343             Reader.getOwningModuleFile(Existing)
2344                                           != Reader.getOwningModuleFile(Cat)) {
2345           // FIXME: We should not warn for duplicates in diamond:
2346           //
2347           //   MT     //
2348           //  /  \    //
2349           // ML  MR   //
2350           //  \  /    //
2351           //   MB     //
2352           //
2353           // If there are duplicates in ML/MR, there will be warning when
2354           // creating MB *and* when importing MB. We should not warn when
2355           // importing.
2356           Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
2357             << Interface->getDeclName() << Cat->getDeclName();
2358           Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
2359         } else if (!Existing) {
2360           // Record this category.
2361           Existing = Cat;
2362         }
2363       }
2364
2365       // Add this category to the end of the chain.
2366       if (Tail)
2367         ASTDeclReader::setNextObjCCategory(Tail, Cat);
2368       else
2369         Interface->setCategoryList(Cat);
2370       Tail = Cat;
2371     }
2372
2373   public:
2374     ObjCCategoriesVisitor(ASTReader &Reader,
2375                           serialization::GlobalDeclID InterfaceID,
2376                           ObjCInterfaceDecl *Interface,
2377                         llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized,
2378                           unsigned PreviousGeneration)
2379       : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
2380         Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
2381         Tail(0)
2382     {
2383       // Populate the name -> category map with the set of known categories.
2384       for (ObjCCategoryDecl *Cat = Interface->getCategoryList(); Cat;
2385            Cat = Cat->getNextClassCategory()) {
2386         if (Cat->getDeclName())
2387           NameCategoryMap[Cat->getDeclName()] = Cat;
2388
2389         // Keep track of the tail of the category list.
2390         Tail = Cat;
2391       }
2392     }
2393
2394     static bool visit(ModuleFile &M, void *UserData) {
2395       return static_cast<ObjCCategoriesVisitor *>(UserData)->visit(M);
2396     }
2397
2398     bool visit(ModuleFile &M) {
2399       // If we've loaded all of the category information we care about from
2400       // this module file, we're done.
2401       if (M.Generation <= PreviousGeneration)
2402         return true;
2403
2404       // Map global ID of the definition down to the local ID used in this
2405       // module file. If there is no such mapping, we'll find nothing here
2406       // (or in any module it imports).
2407       DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
2408       if (!LocalID)
2409         return true;
2410
2411       // Perform a binary search to find the local redeclarations for this
2412       // declaration (if any).
2413       const ObjCCategoriesInfo *Result
2414         = std::lower_bound(M.ObjCCategoriesMap,
2415                            M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
2416                            LocalID, CompareObjCCategoriesInfo());
2417       if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
2418           Result->DefinitionID != LocalID) {
2419         // We didn't find anything. If the class definition is in this module
2420         // file, then the module files it depends on cannot have any categories,
2421         // so suppress further lookup.
2422         return Reader.isDeclIDFromModule(InterfaceID, M);
2423       }
2424
2425       // We found something. Dig out all of the categories.
2426       unsigned Offset = Result->Offset;
2427       unsigned N = M.ObjCCategories[Offset];
2428       M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
2429       for (unsigned I = 0; I != N; ++I)
2430         add(cast_or_null<ObjCCategoryDecl>(
2431               Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
2432       return true;
2433     }
2434   };
2435 }
2436
2437 void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
2438                                    ObjCInterfaceDecl *D,
2439                                    unsigned PreviousGeneration) {
2440   ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
2441                                 PreviousGeneration);
2442   ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor);
2443 }
2444
2445 void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
2446                                const RecordData &Record) {
2447   unsigned Idx = 0;
2448   while (Idx < Record.size()) {
2449     switch ((DeclUpdateKind)Record[Idx++]) {
2450     case UPD_CXX_ADDED_IMPLICIT_MEMBER:
2451       cast<CXXRecordDecl>(D)->addedMember(Reader.ReadDecl(ModuleFile, Record, Idx));
2452       break;
2453
2454     case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
2455       // It will be added to the template's specializations set when loaded.
2456       (void)Reader.ReadDecl(ModuleFile, Record, Idx);
2457       break;
2458
2459     case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
2460       NamespaceDecl *Anon
2461         = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
2462
2463       // Each module has its own anonymous namespace, which is disjoint from
2464       // any other module's anonymous namespaces, so don't attach the anonymous
2465       // namespace at all.
2466       if (ModuleFile.Kind != MK_Module) {
2467         if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
2468           TU->setAnonymousNamespace(Anon);
2469         else
2470           cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
2471       }
2472       break;
2473     }
2474
2475     case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
2476       cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
2477           Reader.ReadSourceLocation(ModuleFile, Record, Idx));
2478       break;
2479     }
2480   }
2481 }