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

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