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

   1 //===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===//
   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 serialization for Declarations.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Serialization/ASTWriter.h"
  15 #include "clang/Serialization/ASTReader.h"
  16 #include "ASTCommon.h"
  17 #include "clang/AST/DeclVisitor.h"
  18 #include "clang/AST/DeclCXX.h"
  19 #include "clang/AST/DeclTemplate.h"
  20 #include "clang/AST/Expr.h"
  21 #include "clang/AST/DeclContextInternals.h"
  22 #include "clang/Basic/SourceManager.h"
  23 #include "llvm/ADT/Twine.h"
  24 #include "llvm/Bitcode/BitstreamWriter.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26 using namespace clang;
  27 using namespace serialization;
  28
  29 //===----------------------------------------------------------------------===//
  30 // Declaration serialization
  31 //===----------------------------------------------------------------------===//
  32
  33 namespace clang {
  34   class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
  35
  36     ASTWriter &Writer;
  37     ASTContext &Context;
  38     typedef ASTWriter::RecordData RecordData;
  39     RecordData &Record;
  40
  41   public:
  42     serialization::DeclCode Code;
  43     unsigned AbbrevToUse;
  44
  45     ASTDeclWriter(ASTWriter &Writer, ASTContext &Context, RecordData &Record)
  46       : Writer(Writer), Context(Context), Record(Record) {
  47     }
  48
  49     void Visit(Decl *D);
  50
  51     void VisitDecl(Decl *D);
  52     void VisitTranslationUnitDecl(TranslationUnitDecl *D);
  53     void VisitNamedDecl(NamedDecl *D);
  54     void VisitLabelDecl(LabelDecl *LD);
  55     void VisitNamespaceDecl(NamespaceDecl *D);
  56     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
  57     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
  58     void VisitTypeDecl(TypeDecl *D);
  59     void VisitTypedefNameDecl(TypedefNameDecl *D);
  60     void VisitTypedefDecl(TypedefDecl *D);
  61     void VisitTypeAliasDecl(TypeAliasDecl *D);
  62     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
  63     void VisitTagDecl(TagDecl *D);
  64     void VisitEnumDecl(EnumDecl *D);
  65     void VisitRecordDecl(RecordDecl *D);
  66     void VisitCXXRecordDecl(CXXRecordDecl *D);
  67     void VisitClassTemplateSpecializationDecl(
  68                                             ClassTemplateSpecializationDecl *D);
  69     void VisitClassTemplatePartialSpecializationDecl(
  70                                      ClassTemplatePartialSpecializationDecl *D);
  71     void VisitClassScopeFunctionSpecializationDecl(
  72                                        ClassScopeFunctionSpecializationDecl *D);
  73     void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
  74     void VisitValueDecl(ValueDecl *D);
  75     void VisitEnumConstantDecl(EnumConstantDecl *D);
  76     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
  77     void VisitDeclaratorDecl(DeclaratorDecl *D);
  78     void VisitFunctionDecl(FunctionDecl *D);
  79     void VisitCXXMethodDecl(CXXMethodDecl *D);
  80     void VisitCXXConstructorDecl(CXXConstructorDecl *D);
  81     void VisitCXXDestructorDecl(CXXDestructorDecl *D);
  82     void VisitCXXConversionDecl(CXXConversionDecl *D);
  83     void VisitFieldDecl(FieldDecl *D);
  84     void VisitIndirectFieldDecl(IndirectFieldDecl *D);
  85     void VisitVarDecl(VarDecl *D);
  86     void VisitImplicitParamDecl(ImplicitParamDecl *D);
  87     void VisitParmVarDecl(ParmVarDecl *D);
  88     void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
  89     void VisitTemplateDecl(TemplateDecl *D);
  90     void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
  91     void VisitClassTemplateDecl(ClassTemplateDecl *D);
  92     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
  93     void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
  94     void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
  95     void VisitUsingDecl(UsingDecl *D);
  96     void VisitUsingShadowDecl(UsingShadowDecl *D);
  97     void VisitLinkageSpecDecl(LinkageSpecDecl *D);
  98     void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
  99     void VisitImportDecl(ImportDecl *D);
 100     void VisitAccessSpecDecl(AccessSpecDecl *D);
 101     void VisitFriendDecl(FriendDecl *D);
 102     void VisitFriendTemplateDecl(FriendTemplateDecl *D);
 103     void VisitStaticAssertDecl(StaticAssertDecl *D);
 104     void VisitBlockDecl(BlockDecl *D);
 105
 106     void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
 107                           uint64_t VisibleOffset);
 108     template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
 109
 110
 111     // FIXME: Put in the same order is DeclNodes.td?
 112     void VisitObjCMethodDecl(ObjCMethodDecl *D);
 113     void VisitObjCContainerDecl(ObjCContainerDecl *D);
 114     void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
 115     void VisitObjCIvarDecl(ObjCIvarDecl *D);
 116     void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
 117     void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
 118     void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
 119     void VisitObjCImplDecl(ObjCImplDecl *D);
 120     void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
 121     void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
 122     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
 123     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
 124     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
 125   };
 126 }
 127
 128 void ASTDeclWriter::Visit(Decl *D) {
 129   DeclVisitor<ASTDeclWriter>::Visit(D);
 130
 131   // Source locations require array (variable-length) abbreviations.  The
 132   // abbreviation infrastructure requires that arrays are encoded last, so
 133   // we handle it here in the case of those classes derived from DeclaratorDecl
 134   if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)){
 135     Writer.AddTypeSourceInfo(DD->getTypeSourceInfo(), Record);
 136   }
 137
 138   // Handle FunctionDecl's body here and write it after all other Stmts/Exprs
 139   // have been written. We want it last because we will not read it back when
 140   // retrieving it from the AST, we'll just lazily set the offset.
 141   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 142     Record.push_back(FD->doesThisDeclarationHaveABody());
 143     if (FD->doesThisDeclarationHaveABody())
 144       Writer.AddStmt(FD->getBody());
 145   }
 146 }
 147
 148 void ASTDeclWriter::VisitDecl(Decl *D) {
 149   Writer.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()), Record);
 150   Writer.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()), Record);
 151   Record.push_back(D->isInvalidDecl());
 152   Record.push_back(D->hasAttrs());
 153   if (D->hasAttrs())
 154     Writer.WriteAttributes(ArrayRef<const Attr*>(D->getAttrs().begin(),
 155                                                  D->getAttrs().size()), Record);
 156   Record.push_back(D->isImplicit());
 157   Record.push_back(D->isUsed(false));
 158   Record.push_back(D->isReferenced());
 159   Record.push_back(D->isTopLevelDeclInObjCContainer());
 160   Record.push_back(D->getAccess());
 161   Record.push_back(D->isModulePrivate());
 162   Record.push_back(Writer.inferSubmoduleIDFromLocation(D->getLocation()));
 163 }
 164
 165 void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
 166   llvm_unreachable("Translation units aren't directly serialized");
 167 }
 168
 169 void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
 170   VisitDecl(D);
 171   Writer.AddDeclarationName(D->getDeclName(), Record);
 172 }
 173
 174 void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
 175   VisitNamedDecl(D);
 176   Writer.AddSourceLocation(D->getLocStart(), Record);
 177   Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
 178 }
 179
 180 void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
 181   VisitRedeclarable(D);
 182   VisitTypeDecl(D);
 183   Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
 184 }
 185
 186 void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
 187   VisitTypedefNameDecl(D);
 188   if (!D->hasAttrs() &&
 189       !D->isImplicit() &&
 190       !D->isUsed(false) &&
 191       D->getFirstDeclaration() == D->getMostRecentDecl() &&
 192       !D->isInvalidDecl() &&
 193       !D->isReferenced() &&
 194       !D->isTopLevelDeclInObjCContainer() &&
 195       D->getAccess() == AS_none &&
 196       !D->isModulePrivate() &&
 197       D->getDeclName().getNameKind() == DeclarationName::Identifier)
 198     AbbrevToUse = Writer.getDeclTypedefAbbrev();
 199
 200   Code = serialization::DECL_TYPEDEF;
 201 }
 202
 203 void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
 204   VisitTypedefNameDecl(D);
 205   Code = serialization::DECL_TYPEALIAS;
 206 }
 207
 208 void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
 209   VisitRedeclarable(D);
 210   VisitTypeDecl(D);
 211   Record.push_back(D->getIdentifierNamespace());
 212   Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
 213   Record.push_back(D->isCompleteDefinition());
 214   Record.push_back(D->isEmbeddedInDeclarator());
 215   Record.push_back(D->isFreeStanding());
 216   Writer.AddSourceLocation(D->getRBraceLoc(), Record);
 217   Record.push_back(D->hasExtInfo());
 218   if (D->hasExtInfo())
 219     Writer.AddQualifierInfo(*D->getExtInfo(), Record);
 220   else
 221     Writer.AddDeclRef(D->getTypedefNameForAnonDecl(), Record);
 222 }
 223
 224 void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
 225   VisitTagDecl(D);
 226   Writer.AddTypeSourceInfo(D->getIntegerTypeSourceInfo(), Record);
 227   if (!D->getIntegerTypeSourceInfo())
 228     Writer.AddTypeRef(D->getIntegerType(), Record);
 229   Writer.AddTypeRef(D->getPromotionType(), Record);
 230   Record.push_back(D->getNumPositiveBits());
 231   Record.push_back(D->getNumNegativeBits());
 232   Record.push_back(D->isScoped());
 233   Record.push_back(D->isScopedUsingClassTag());
 234   Record.push_back(D->isFixed());
 235   if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
 236     Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
 237     Record.push_back(MemberInfo->getTemplateSpecializationKind());
 238     Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
 239   } else {
 240     Writer.AddDeclRef(0, Record);
 241   }
 242
 243   if (!D->hasAttrs() &&
 244       !D->isImplicit() &&
 245       !D->isUsed(false) &&
 246       !D->hasExtInfo() &&
 247       D->getFirstDeclaration() == D->getMostRecentDecl() &&
 248       !D->isInvalidDecl() &&
 249       !D->isReferenced() &&
 250       !D->isTopLevelDeclInObjCContainer() &&
 251       D->getAccess() == AS_none &&
 252       !D->isModulePrivate() &&
 253       !CXXRecordDecl::classofKind(D->getKind()) &&
 254       !D->getIntegerTypeSourceInfo() &&
 255       D->getDeclName().getNameKind() == DeclarationName::Identifier)
 256     AbbrevToUse = Writer.getDeclEnumAbbrev();
 257
 258   Code = serialization::DECL_ENUM;
 259 }
 260
 261 void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
 262   VisitTagDecl(D);
 263   Record.push_back(D->hasFlexibleArrayMember());
 264   Record.push_back(D->isAnonymousStructOrUnion());
 265   Record.push_back(D->hasObjectMember());
 266
 267   if (!D->hasAttrs() &&
 268       !D->isImplicit() &&
 269       !D->isUsed(false) &&
 270       !D->hasExtInfo() &&
 271       D->getFirstDeclaration() == D->getMostRecentDecl() &&
 272       !D->isInvalidDecl() &&
 273       !D->isReferenced() &&
 274       !D->isTopLevelDeclInObjCContainer() &&
 275       D->getAccess() == AS_none &&
 276       !D->isModulePrivate() &&
 277       !CXXRecordDecl::classofKind(D->getKind()) &&
 278       D->getDeclName().getNameKind() == DeclarationName::Identifier)
 279     AbbrevToUse = Writer.getDeclRecordAbbrev();
 280
 281   Code = serialization::DECL_RECORD;
 282 }
 283
 284 void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
 285   VisitNamedDecl(D);
 286   Writer.AddTypeRef(D->getType(), Record);
 287 }
 288
 289 void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
 290   VisitValueDecl(D);
 291   Record.push_back(D->getInitExpr()? 1 : 0);
 292   if (D->getInitExpr())
 293     Writer.AddStmt(D->getInitExpr());
 294   Writer.AddAPSInt(D->getInitVal(), Record);
 295
 296   Code = serialization::DECL_ENUM_CONSTANT;
 297 }
 298
 299 void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
 300   VisitValueDecl(D);
 301   Writer.AddSourceLocation(D->getInnerLocStart(), Record);
 302   Record.push_back(D->hasExtInfo());
 303   if (D->hasExtInfo())
 304     Writer.AddQualifierInfo(*D->getExtInfo(), Record);
 305 }
 306
 307 void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
 308   VisitRedeclarable(D);
 309   VisitDeclaratorDecl(D);
 310
 311   Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
 312   Record.push_back(D->getIdentifierNamespace());
 313
 314   // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
 315   // after everything else is written.
 316
 317   Record.push_back(D->getStorageClass()); // FIXME: stable encoding
 318   Record.push_back(D->getStorageClassAsWritten());
 319   Record.push_back(D->IsInline);
 320   Record.push_back(D->isInlineSpecified());
 321   Record.push_back(D->isVirtualAsWritten());
 322   Record.push_back(D->isPure());
 323   Record.push_back(D->hasInheritedPrototype());
 324   Record.push_back(D->hasWrittenPrototype());
 325   Record.push_back(D->isDeletedAsWritten());
 326   Record.push_back(D->isTrivial());
 327   Record.push_back(D->isDefaulted());
 328   Record.push_back(D->isExplicitlyDefaulted());
 329   Record.push_back(D->hasImplicitReturnZero());
 330   Record.push_back(D->isConstexpr());
 331   Writer.AddSourceLocation(D->getLocEnd(), Record);
 332
 333   Record.push_back(D->getTemplatedKind());
 334   switch (D->getTemplatedKind()) {
 335   case FunctionDecl::TK_NonTemplate:
 336     break;
 337   case FunctionDecl::TK_FunctionTemplate:
 338     Writer.AddDeclRef(D->getDescribedFunctionTemplate(), Record);
 339     break;
 340   case FunctionDecl::TK_MemberSpecialization: {
 341     MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
 342     Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
 343     Record.push_back(MemberInfo->getTemplateSpecializationKind());
 344     Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
 345     break;
 346   }
 347   case FunctionDecl::TK_FunctionTemplateSpecialization: {
 348     FunctionTemplateSpecializationInfo *
 349       FTSInfo = D->getTemplateSpecializationInfo();
 350     Writer.AddDeclRef(FTSInfo->getTemplate(), Record);
 351     Record.push_back(FTSInfo->getTemplateSpecializationKind());
 352
 353     // Template arguments.
 354     Writer.AddTemplateArgumentList(FTSInfo->TemplateArguments, Record);
 355
 356     // Template args as written.
 357     Record.push_back(FTSInfo->TemplateArgumentsAsWritten != 0);
 358     if (FTSInfo->TemplateArgumentsAsWritten) {
 359       Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
 360       for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
 361              i!=e; ++i)
 362         Writer.AddTemplateArgumentLoc((*FTSInfo->TemplateArgumentsAsWritten)[i],
 363                                       Record);
 364       Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc,
 365                                Record);
 366       Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc,
 367                                Record);
 368     }
 369
 370     Writer.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Record);
 371
 372     if (D->isCanonicalDecl()) {
 373       // Write the template that contains the specializations set. We will
 374       // add a FunctionTemplateSpecializationInfo to it when reading.
 375       Writer.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl(), Record);
 376     }
 377     break;
 378   }
 379   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
 380     DependentFunctionTemplateSpecializationInfo *
 381       DFTSInfo = D->getDependentSpecializationInfo();
 382
 383     // Templates.
 384     Record.push_back(DFTSInfo->getNumTemplates());
 385     for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
 386       Writer.AddDeclRef(DFTSInfo->getTemplate(i), Record);
 387
 388     // Templates args.
 389     Record.push_back(DFTSInfo->getNumTemplateArgs());
 390     for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
 391       Writer.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i), Record);
 392     Writer.AddSourceLocation(DFTSInfo->getLAngleLoc(), Record);
 393     Writer.AddSourceLocation(DFTSInfo->getRAngleLoc(), Record);
 394     break;
 395   }
 396   }
 397
 398   Record.push_back(D->param_size());
 399   for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
 400        P != PEnd; ++P)
 401     Writer.AddDeclRef(*P, Record);
 402   Code = serialization::DECL_FUNCTION;
 403 }
 404
 405 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
 406   VisitNamedDecl(D);
 407   // FIXME: convert to LazyStmtPtr?
 408   // Unlike C/C++, method bodies will never be in header files.
 409   bool HasBodyStuff = D->getBody() != 0     ||
 410                       D->getSelfDecl() != 0 || D->getCmdDecl() != 0;
 411   Record.push_back(HasBodyStuff);
 412   if (HasBodyStuff) {
 413     Writer.AddStmt(D->getBody());
 414     Writer.AddDeclRef(D->getSelfDecl(), Record);
 415     Writer.AddDeclRef(D->getCmdDecl(), Record);
 416   }
 417   Record.push_back(D->isInstanceMethod());
 418   Record.push_back(D->isVariadic());
 419   Record.push_back(D->isPropertyAccessor());
 420   Record.push_back(D->isDefined());
 421   Record.push_back(D->IsOverriding);
 422
 423   Record.push_back(D->IsRedeclaration);
 424   Record.push_back(D->HasRedeclaration);
 425   if (D->HasRedeclaration) {
 426     assert(Context.getObjCMethodRedeclaration(D));
 427     Writer.AddDeclRef(Context.getObjCMethodRedeclaration(D), Record);
 428   }
 429
 430   // FIXME: stable encoding for @required/@optional
 431   Record.push_back(D->getImplementationControl());
 432   // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway
 433   Record.push_back(D->getObjCDeclQualifier());
 434   Record.push_back(D->hasRelatedResultType());
 435   Writer.AddTypeRef(D->getResultType(), Record);
 436   Writer.AddTypeSourceInfo(D->getResultTypeSourceInfo(), Record);
 437   Writer.AddSourceLocation(D->getLocEnd(), Record);
 438   Record.push_back(D->param_size());
 439   for (ObjCMethodDecl::param_iterator P = D->param_begin(),
 440                                    PEnd = D->param_end(); P != PEnd; ++P)
 441     Writer.AddDeclRef(*P, Record);
 442
 443   Record.push_back(D->SelLocsKind);
 444   unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
 445   SourceLocation *SelLocs = D->getStoredSelLocs();
 446   Record.push_back(NumStoredSelLocs);
 447   for (unsigned i = 0; i != NumStoredSelLocs; ++i)
 448     Writer.AddSourceLocation(SelLocs[i], Record);
 449
 450   Code = serialization::DECL_OBJC_METHOD;
 451 }
 452
 453 void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
 454   VisitNamedDecl(D);
 455   Writer.AddSourceLocation(D->getAtStartLoc(), Record);
 456   Writer.AddSourceRange(D->getAtEndRange(), Record);
 457   // Abstract class (no need to define a stable serialization::DECL code).
 458 }
 459
 460 void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
 461   VisitRedeclarable(D);
 462   VisitObjCContainerDecl(D);
 463   Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
 464
 465   Record.push_back(D->isThisDeclarationADefinition());
 466   if (D->isThisDeclarationADefinition()) {
 467     // Write the DefinitionData
 468     ObjCInterfaceDecl::DefinitionData &Data = D->data();
 469
 470     Writer.AddDeclRef(D->getSuperClass(), Record);
 471     Writer.AddSourceLocation(D->getSuperClassLoc(), Record);
 472     Writer.AddSourceLocation(D->getEndOfDefinitionLoc(), Record);
 473
 474     // Write out the protocols that are directly referenced by the @interface.
 475     Record.push_back(Data.ReferencedProtocols.size());
 476     for (ObjCInterfaceDecl::protocol_iterator P = D->protocol_begin(),
 477                                            PEnd = D->protocol_end();
 478          P != PEnd; ++P)
 479       Writer.AddDeclRef(*P, Record);
 480     for (ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
 481          PLEnd = D->protocol_loc_end();
 482          PL != PLEnd; ++PL)
 483       Writer.AddSourceLocation(*PL, Record);
 484
 485     // Write out the protocols that are transitively referenced.
 486     Record.push_back(Data.AllReferencedProtocols.size());
 487     for (ObjCList<ObjCProtocolDecl>::iterator
 488               P = Data.AllReferencedProtocols.begin(),
 489            PEnd = Data.AllReferencedProtocols.end();
 490          P != PEnd; ++P)
 491       Writer.AddDeclRef(*P, Record);
 492
 493     if (ObjCCategoryDecl *Cat = D->getCategoryList()) {
 494       // Ensure that we write out the set of categories for this class.
 495       Writer.ObjCClassesWithCategories.insert(D);
 496
 497       // Make sure that the categories get serialized.
 498       for (; Cat; Cat = Cat->getNextClassCategory())
 499         (void)Writer.GetDeclRef(Cat);
 500     }
 501   }
 502
 503   Code = serialization::DECL_OBJC_INTERFACE;
 504 }
 505
 506 void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
 507   VisitFieldDecl(D);
 508   // FIXME: stable encoding for @public/@private/@protected/@package
 509   Record.push_back(D->getAccessControl());
 510   Record.push_back(D->getSynthesize());
 511
 512   if (!D->hasAttrs() &&
 513       !D->isImplicit() &&
 514       !D->isUsed(false) &&
 515       !D->isInvalidDecl() &&
 516       !D->isReferenced() &&
 517       !D->isModulePrivate() &&
 518       !D->getBitWidth() &&
 519       !D->hasExtInfo() &&
 520       D->getDeclName())
 521     AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
 522
 523   Code = serialization::DECL_OBJC_IVAR;
 524 }
 525
 526 void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
 527   VisitRedeclarable(D);
 528   VisitObjCContainerDecl(D);
 529
 530   Record.push_back(D->isThisDeclarationADefinition());
 531   if (D->isThisDeclarationADefinition()) {
 532     Record.push_back(D->protocol_size());
 533     for (ObjCProtocolDecl::protocol_iterator
 534          I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
 535       Writer.AddDeclRef(*I, Record);
 536     for (ObjCProtocolDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
 537            PLEnd = D->protocol_loc_end();
 538          PL != PLEnd; ++PL)
 539       Writer.AddSourceLocation(*PL, Record);
 540   }
 541
 542   Code = serialization::DECL_OBJC_PROTOCOL;
 543 }
 544
 545 void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
 546   VisitFieldDecl(D);
 547   Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
 548 }
 549
 550 void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
 551   VisitObjCContainerDecl(D);
 552   Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
 553   Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
 554   Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
 555   Writer.AddDeclRef(D->getClassInterface(), Record);
 556   Record.push_back(D->protocol_size());
 557   for (ObjCCategoryDecl::protocol_iterator
 558        I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
 559     Writer.AddDeclRef(*I, Record);
 560   for (ObjCCategoryDecl::protocol_loc_iterator
 561          PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end();
 562        PL != PLEnd; ++PL)
 563     Writer.AddSourceLocation(*PL, Record);
 564   Code = serialization::DECL_OBJC_CATEGORY;
 565 }
 566
 567 void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
 568   VisitNamedDecl(D);
 569   Writer.AddDeclRef(D->getClassInterface(), Record);
 570   Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
 571 }
 572
 573 void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
 574   VisitNamedDecl(D);
 575   Writer.AddSourceLocation(D->getAtLoc(), Record);
 576   Writer.AddSourceLocation(D->getLParenLoc(), Record);
 577   Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
 578   // FIXME: stable encoding
 579   Record.push_back((unsigned)D->getPropertyAttributes());
 580   Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
 581   // FIXME: stable encoding
 582   Record.push_back((unsigned)D->getPropertyImplementation());
 583   Writer.AddDeclarationName(D->getGetterName(), Record);
 584   Writer.AddDeclarationName(D->getSetterName(), Record);
 585   Writer.AddDeclRef(D->getGetterMethodDecl(), Record);
 586   Writer.AddDeclRef(D->getSetterMethodDecl(), Record);
 587   Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
 588   Code = serialization::DECL_OBJC_PROPERTY;
 589 }
 590
 591 void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
 592   VisitObjCContainerDecl(D);
 593   Writer.AddDeclRef(D->getClassInterface(), Record);
 594   // Abstract class (no need to define a stable serialization::DECL code).
 595 }
 596
 597 void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
 598   VisitObjCImplDecl(D);
 599   Writer.AddIdentifierRef(D->getIdentifier(), Record);
 600   Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
 601   Code = serialization::DECL_OBJC_CATEGORY_IMPL;
 602 }
 603
 604 void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
 605   VisitObjCImplDecl(D);
 606   Writer.AddDeclRef(D->getSuperClass(), Record);
 607   Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
 608   Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
 609   Record.push_back(D->hasNonZeroConstructors());
 610   Record.push_back(D->hasDestructors());
 611   Writer.AddCXXCtorInitializers(D->IvarInitializers, D->NumIvarInitializers,
 612                                 Record);
 613   Code = serialization::DECL_OBJC_IMPLEMENTATION;
 614 }
 615
 616 void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
 617   VisitDecl(D);
 618   Writer.AddSourceLocation(D->getLocStart(), Record);
 619   Writer.AddDeclRef(D->getPropertyDecl(), Record);
 620   Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
 621   Writer.AddSourceLocation(D->getPropertyIvarDeclLoc(), Record);
 622   Writer.AddStmt(D->getGetterCXXConstructor());
 623   Writer.AddStmt(D->getSetterCXXAssignment());
 624   Code = serialization::DECL_OBJC_PROPERTY_IMPL;
 625 }
 626
 627 void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
 628   VisitDeclaratorDecl(D);
 629   Record.push_back(D->isMutable());
 630   if (D->InitializerOrBitWidth.getInt() != ICIS_NoInit ||
 631       D->InitializerOrBitWidth.getPointer()) {
 632     Record.push_back(D->InitializerOrBitWidth.getInt() + 1);
 633     Writer.AddStmt(D->InitializerOrBitWidth.getPointer());
 634   } else {
 635     Record.push_back(0);
 636   }
 637   if (!D->getDeclName())
 638     Writer.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D), Record);
 639
 640   if (!D->hasAttrs() &&
 641       !D->isImplicit() &&
 642       !D->isUsed(false) &&
 643       !D->isInvalidDecl() &&
 644       !D->isReferenced() &&
 645       !D->isTopLevelDeclInObjCContainer() &&
 646       !D->isModulePrivate() &&
 647       !D->getBitWidth() &&
 648       !D->hasInClassInitializer() &&
 649       !D->hasExtInfo() &&
 650       !ObjCIvarDecl::classofKind(D->getKind()) &&
 651       !ObjCAtDefsFieldDecl::classofKind(D->getKind()) &&
 652       D->getDeclName())
 653     AbbrevToUse = Writer.getDeclFieldAbbrev();
 654
 655   Code = serialization::DECL_FIELD;
 656 }
 657
 658 void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
 659   VisitValueDecl(D);
 660   Record.push_back(D->getChainingSize());
 661
 662   for (IndirectFieldDecl::chain_iterator
 663        P = D->chain_begin(),
 664        PEnd = D->chain_end(); P != PEnd; ++P)
 665     Writer.AddDeclRef(*P, Record);
 666   Code = serialization::DECL_INDIRECTFIELD;
 667 }
 668
 669 void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
 670   VisitRedeclarable(D);
 671   VisitDeclaratorDecl(D);
 672   Record.push_back(D->getStorageClass()); // FIXME: stable encoding
 673   Record.push_back(D->getStorageClassAsWritten());
 674   Record.push_back(D->isThreadSpecified());
 675   Record.push_back(D->getInitStyle());
 676   Record.push_back(D->isExceptionVariable());
 677   Record.push_back(D->isNRVOVariable());
 678   Record.push_back(D->isCXXForRangeDecl());
 679   Record.push_back(D->isARCPseudoStrong());
 680   Record.push_back(D->isConstexpr());
 681
 682   if (D->getInit()) {
 683     Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2));
 684     Writer.AddStmt(D->getInit());
 685   } else {
 686     Record.push_back(0);
 687   }
 688
 689   MemberSpecializationInfo *SpecInfo
 690     = D->isStaticDataMember() ? D->getMemberSpecializationInfo() : 0;
 691   Record.push_back(SpecInfo != 0);
 692   if (SpecInfo) {
 693     Writer.AddDeclRef(SpecInfo->getInstantiatedFrom(), Record);
 694     Record.push_back(SpecInfo->getTemplateSpecializationKind());
 695     Writer.AddSourceLocation(SpecInfo->getPointOfInstantiation(), Record);
 696   }
 697
 698   if (!D->hasAttrs() &&
 699       !D->isImplicit() &&
 700       !D->isUsed(false) &&
 701       !D->isInvalidDecl() &&
 702       !D->isReferenced() &&
 703       !D->isTopLevelDeclInObjCContainer() &&
 704       D->getAccess() == AS_none &&
 705       !D->isModulePrivate() &&
 706       D->getDeclName().getNameKind() == DeclarationName::Identifier &&
 707       !D->hasExtInfo() &&
 708       D->getFirstDeclaration() == D->getMostRecentDecl() &&
 709       D->getInitStyle() == VarDecl::CInit &&
 710       D->getInit() == 0 &&
 711       !isa<ParmVarDecl>(D) &&
 712       !D->isConstexpr() &&
 713       !SpecInfo)
 714     AbbrevToUse = Writer.getDeclVarAbbrev();
 715
 716   Code = serialization::DECL_VAR;
 717 }
 718
 719 void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
 720   VisitVarDecl(D);
 721   Code = serialization::DECL_IMPLICIT_PARAM;
 722 }
 723
 724 void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
 725   VisitVarDecl(D);
 726   Record.push_back(D->isObjCMethodParameter());
 727   Record.push_back(D->getFunctionScopeDepth());
 728   Record.push_back(D->getFunctionScopeIndex());
 729   Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
 730   Record.push_back(D->isKNRPromoted());
 731   Record.push_back(D->hasInheritedDefaultArg());
 732   Record.push_back(D->hasUninstantiatedDefaultArg());
 733   if (D->hasUninstantiatedDefaultArg())
 734     Writer.AddStmt(D->getUninstantiatedDefaultArg());
 735   Code = serialization::DECL_PARM_VAR;
 736
 737   assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl
 738
 739   // If the assumptions about the DECL_PARM_VAR abbrev are true, use it.  Here
 740   // we dynamically check for the properties that we optimize for, but don't
 741   // know are true of all PARM_VAR_DECLs.
 742   if (!D->hasAttrs() &&
 743       !D->hasExtInfo() &&
 744       !D->isImplicit() &&
 745       !D->isUsed(false) &&
 746       !D->isInvalidDecl() &&
 747       !D->isReferenced() &&
 748       D->getAccess() == AS_none &&
 749       !D->isModulePrivate() &&
 750       D->getStorageClass() == 0 &&
 751       D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
 752       D->getFunctionScopeDepth() == 0 &&
 753       D->getObjCDeclQualifier() == 0 &&
 754       !D->isKNRPromoted() &&
 755       !D->hasInheritedDefaultArg() &&
 756       D->getInit() == 0 &&
 757       !D->hasUninstantiatedDefaultArg())  // No default expr.
 758     AbbrevToUse = Writer.getDeclParmVarAbbrev();
 759
 760   // Check things we know are true of *every* PARM_VAR_DECL, which is more than
 761   // just us assuming it.
 762   assert(!D->isThreadSpecified() && "PARM_VAR_DECL can't be __thread");
 763   assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
 764   assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
 765   assert(D->getPreviousDecl() == 0 && "PARM_VAR_DECL can't be redecl");
 766   assert(!D->isStaticDataMember() &&
 767          "PARM_VAR_DECL can't be static data member");
 768 }
 769
 770 void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
 771   VisitDecl(D);
 772   Writer.AddStmt(D->getAsmString());
 773   Writer.AddSourceLocation(D->getRParenLoc(), Record);
 774   Code = serialization::DECL_FILE_SCOPE_ASM;
 775 }
 776
 777 void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
 778   VisitDecl(D);
 779   Writer.AddStmt(D->getBody());
 780   Writer.AddTypeSourceInfo(D->getSignatureAsWritten(), Record);
 781   Record.push_back(D->param_size());
 782   for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
 783        P != PEnd; ++P)
 784     Writer.AddDeclRef(*P, Record);
 785   Record.push_back(D->isVariadic());
 786   Record.push_back(D->blockMissingReturnType());
 787   Record.push_back(D->isConversionFromLambda());
 788   Record.push_back(D->capturesCXXThis());
 789   Record.push_back(D->getNumCaptures());
 790   for (BlockDecl::capture_iterator
 791          i = D->capture_begin(), e = D->capture_end(); i != e; ++i) {
 792     const BlockDecl::Capture &capture = *i;
 793     Writer.AddDeclRef(capture.getVariable(), Record);
 794
 795     unsigned flags = 0;
 796     if (capture.isByRef()) flags |= 1;
 797     if (capture.isNested()) flags |= 2;
 798     if (capture.hasCopyExpr()) flags |= 4;
 799     Record.push_back(flags);
 800
 801     if (capture.hasCopyExpr()) Writer.AddStmt(capture.getCopyExpr());
 802   }
 803
 804   Code = serialization::DECL_BLOCK;
 805 }
 806
 807 void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
 808   VisitDecl(D);
 809   Record.push_back(D->getLanguage());
 810   Writer.AddSourceLocation(D->getExternLoc(), Record);
 811   Writer.AddSourceLocation(D->getRBraceLoc(), Record);
 812   Code = serialization::DECL_LINKAGE_SPEC;
 813 }
 814
 815 void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
 816   VisitNamedDecl(D);
 817   Writer.AddSourceLocation(D->getLocStart(), Record);
 818   Code = serialization::DECL_LABEL;
 819 }
 820
 821
 822 void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
 823   VisitRedeclarable(D);
 824   VisitNamedDecl(D);
 825   Record.push_back(D->isInline());
 826   Writer.AddSourceLocation(D->getLocStart(), Record);
 827   Writer.AddSourceLocation(D->getRBraceLoc(), Record);
 828
 829   if (D->isOriginalNamespace())
 830     Writer.AddDeclRef(D->getAnonymousNamespace(), Record);
 831   Code = serialization::DECL_NAMESPACE;
 832
 833   if (Writer.hasChain() && !D->isOriginalNamespace() &&
 834       D->getOriginalNamespace()->isFromASTFile()) {
 835     NamespaceDecl *NS = D->getOriginalNamespace();
 836     Writer.AddUpdatedDeclContext(NS);
 837
 838     // Make sure all visible decls are written. They will be recorded later.
 839     if (StoredDeclsMap *Map = NS->buildLookup()) {
 840       for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
 841            D != DEnd; ++D) {
 842         DeclContext::lookup_result Result = D->second.getLookupResult();
 843         while (Result.first != Result.second) {
 844           Writer.GetDeclRef(*Result.first);
 845           ++Result.first;
 846         }
 847       }
 848     }
 849   }
 850
 851   if (Writer.hasChain() && D->isAnonymousNamespace() &&
 852       D == D->getMostRecentDecl()) {
 853     // This is a most recent reopening of the anonymous namespace. If its parent
 854     // is in a previous PCH (or is the TU), mark that parent for update, because
 855     // the original namespace always points to the latest re-opening of its
 856     // anonymous namespace.
 857     Decl *Parent = cast<Decl>(
 858         D->getParent()->getRedeclContext()->getPrimaryContext());
 859     if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
 860       ASTWriter::UpdateRecord &Record = Writer.DeclUpdates[Parent];
 861       Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE);
 862       Writer.AddDeclRef(D, Record);
 863     }
 864   }
 865 }
 866
 867 void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
 868   VisitNamedDecl(D);
 869   Writer.AddSourceLocation(D->getNamespaceLoc(), Record);
 870   Writer.AddSourceLocation(D->getTargetNameLoc(), Record);
 871   Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
 872   Writer.AddDeclRef(D->getNamespace(), Record);
 873   Code = serialization::DECL_NAMESPACE_ALIAS;
 874 }
 875
 876 void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
 877   VisitNamedDecl(D);
 878   Writer.AddSourceLocation(D->getUsingLocation(), Record);
 879   Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
 880   Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
 881   Writer.AddDeclRef(D->FirstUsingShadow.getPointer(), Record);
 882   Record.push_back(D->isTypeName());
 883   Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record);
 884   Code = serialization::DECL_USING;
 885 }
 886
 887 void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
 888   VisitNamedDecl(D);
 889   Writer.AddDeclRef(D->getTargetDecl(), Record);
 890   Writer.AddDeclRef(D->UsingOrNextShadow, Record);
 891   Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record);
 892   Code = serialization::DECL_USING_SHADOW;
 893 }
 894
 895 void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
 896   VisitNamedDecl(D);
 897   Writer.AddSourceLocation(D->getUsingLoc(), Record);
 898   Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record);
 899   Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
 900   Writer.AddDeclRef(D->getNominatedNamespace(), Record);
 901   Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record);
 902   Code = serialization::DECL_USING_DIRECTIVE;
 903 }
 904
 905 void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
 906   VisitValueDecl(D);
 907   Writer.AddSourceLocation(D->getUsingLoc(), Record);
 908   Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
 909   Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
 910   Code = serialization::DECL_UNRESOLVED_USING_VALUE;
 911 }
 912
 913 void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
 914                                                UnresolvedUsingTypenameDecl *D) {
 915   VisitTypeDecl(D);
 916   Writer.AddSourceLocation(D->getTypenameLoc(), Record);
 917   Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
 918   Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
 919 }
 920
 921 void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
 922   VisitRecordDecl(D);
 923   Record.push_back(D->isThisDeclarationADefinition());
 924   if (D->isThisDeclarationADefinition())
 925     Writer.AddCXXDefinitionData(D, Record);
 926
 927   enum {
 928     CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
 929   };
 930   if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
 931     Record.push_back(CXXRecTemplate);
 932     Writer.AddDeclRef(TemplD, Record);
 933   } else if (MemberSpecializationInfo *MSInfo
 934                = D->getMemberSpecializationInfo()) {
 935     Record.push_back(CXXRecMemberSpecialization);
 936     Writer.AddDeclRef(MSInfo->getInstantiatedFrom(), Record);
 937     Record.push_back(MSInfo->getTemplateSpecializationKind());
 938     Writer.AddSourceLocation(MSInfo->getPointOfInstantiation(), Record);
 939   } else {
 940     Record.push_back(CXXRecNotTemplate);
 941   }
 942
 943   // Store the key function to avoid deserializing every method so we can
 944   // compute it.
 945   if (D->IsCompleteDefinition)
 946     Writer.AddDeclRef(Context.getKeyFunction(D), Record);
 947
 948   Code = serialization::DECL_CXX_RECORD;
 949 }
 950
 951 void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
 952   VisitFunctionDecl(D);
 953   if (D->isCanonicalDecl()) {
 954     Record.push_back(D->size_overridden_methods());
 955     for (CXXMethodDecl::method_iterator
 956            I = D->begin_overridden_methods(), E = D->end_overridden_methods();
 957            I != E; ++I)
 958       Writer.AddDeclRef(*I, Record);
 959   } else {
 960     // We only need to record overridden methods once for the canonical decl.
 961     Record.push_back(0);
 962   }
 963   Code = serialization::DECL_CXX_METHOD;
 964 }
 965
 966 void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
 967   VisitCXXMethodDecl(D);
 968
 969   Record.push_back(D->IsExplicitSpecified);
 970   Record.push_back(D->ImplicitlyDefined);
 971   Writer.AddCXXCtorInitializers(D->CtorInitializers, D->NumCtorInitializers,
 972                                 Record);
 973
 974   Code = serialization::DECL_CXX_CONSTRUCTOR;
 975 }
 976
 977 void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
 978   VisitCXXMethodDecl(D);
 979
 980   Record.push_back(D->ImplicitlyDefined);
 981   Writer.AddDeclRef(D->OperatorDelete, Record);
 982
 983   Code = serialization::DECL_CXX_DESTRUCTOR;
 984 }
 985
 986 void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
 987   VisitCXXMethodDecl(D);
 988   Record.push_back(D->IsExplicitSpecified);
 989   Code = serialization::DECL_CXX_CONVERSION;
 990 }
 991
 992 void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
 993   VisitDecl(D);
 994   Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
 995   ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
 996   Record.push_back(!IdentifierLocs.empty());
 997   if (IdentifierLocs.empty()) {
 998     Writer.AddSourceLocation(D->getLocEnd(), Record);
 999     Record.push_back(1);
1000   } else {
1001     for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1002       Writer.AddSourceLocation(IdentifierLocs[I], Record);
1003     Record.push_back(IdentifierLocs.size());
1004   }
1005   // Note: the number of source locations must always be the last element in
1006   // the record.
1007   Code = serialization::DECL_IMPORT;
1008 }
1009
1010 void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1011   VisitDecl(D);
1012   Writer.AddSourceLocation(D->getColonLoc(), Record);
1013   Code = serialization::DECL_ACCESS_SPEC;
1014 }
1015
1016 void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
1017   VisitDecl(D);
1018   Record.push_back(D->Friend.is<TypeSourceInfo*>());
1019   if (D->Friend.is<TypeSourceInfo*>())
1020     Writer.AddTypeSourceInfo(D->Friend.get<TypeSourceInfo*>(), Record);
1021   else
1022     Writer.AddDeclRef(D->Friend.get<NamedDecl*>(), Record);
1023   Writer.AddDeclRef(D->getNextFriend(), Record);
1024   Record.push_back(D->UnsupportedFriend);
1025   Writer.AddSourceLocation(D->FriendLoc, Record);
1026   Code = serialization::DECL_FRIEND;
1027 }
1028
1029 void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1030   VisitDecl(D);
1031   Record.push_back(D->getNumTemplateParameters());
1032   for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1033     Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record);
1034   Record.push_back(D->getFriendDecl() != 0);
1035   if (D->getFriendDecl())
1036     Writer.AddDeclRef(D->getFriendDecl(), Record);
1037   else
1038     Writer.AddTypeSourceInfo(D->getFriendType(), Record);
1039   Writer.AddSourceLocation(D->getFriendLoc(), Record);
1040   Code = serialization::DECL_FRIEND_TEMPLATE;
1041 }
1042
1043 void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
1044   VisitNamedDecl(D);
1045
1046   Writer.AddDeclRef(D->getTemplatedDecl(), Record);
1047   Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1048 }
1049
1050 void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1051   VisitRedeclarable(D);
1052
1053   // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1054   // getCommonPtr() can be used while this is still initializing.
1055   if (D->isFirstDeclaration()) {
1056     // This declaration owns the 'common' pointer, so serialize that data now.
1057     Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record);
1058     if (D->getInstantiatedFromMemberTemplate())
1059       Record.push_back(D->isMemberSpecialization());
1060   }
1061
1062   VisitTemplateDecl(D);
1063   Record.push_back(D->getIdentifierNamespace());
1064 }
1065
1066 void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1067   VisitRedeclarableTemplateDecl(D);
1068
1069   if (D->isFirstDeclaration()) {
1070     typedef llvm::FoldingSetVector<ClassTemplateSpecializationDecl> CTSDSetTy;
1071     CTSDSetTy &CTSDSet = D->getSpecializations();
1072     Record.push_back(CTSDSet.size());
1073     for (CTSDSetTy::iterator I=CTSDSet.begin(), E = CTSDSet.end(); I!=E; ++I) {
1074       assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1075       Writer.AddDeclRef(&*I, Record);
1076     }
1077
1078     typedef llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
1079       CTPSDSetTy;
1080     CTPSDSetTy &CTPSDSet = D->getPartialSpecializations();
1081     Record.push_back(CTPSDSet.size());
1082     for (CTPSDSetTy::iterator I=CTPSDSet.begin(), E=CTPSDSet.end(); I!=E; ++I) {
1083       assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1084       Writer.AddDeclRef(&*I, Record);
1085     }
1086
1087     Writer.AddTypeRef(D->getCommonPtr()->InjectedClassNameType, Record);
1088   }
1089   Code = serialization::DECL_CLASS_TEMPLATE;
1090 }
1091
1092 void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
1093                                            ClassTemplateSpecializationDecl *D) {
1094   VisitCXXRecordDecl(D);
1095
1096   llvm::PointerUnion<ClassTemplateDecl *,
1097                      ClassTemplatePartialSpecializationDecl *> InstFrom
1098     = D->getSpecializedTemplateOrPartial();
1099   if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
1100     Writer.AddDeclRef(InstFromD, Record);
1101   } else {
1102     Writer.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>(),
1103                       Record);
1104     Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record);
1105   }
1106
1107   // Explicit info.
1108   Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record);
1109   if (D->getTypeAsWritten()) {
1110     Writer.AddSourceLocation(D->getExternLoc(), Record);
1111     Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record);
1112   }
1113
1114   Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record);
1115   Writer.AddSourceLocation(D->getPointOfInstantiation(), Record);
1116   Record.push_back(D->getSpecializationKind());
1117   Record.push_back(D->isCanonicalDecl());
1118
1119   if (D->isCanonicalDecl()) {
1120     // When reading, we'll add it to the folding set of the following template.
1121     Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record);
1122   }
1123
1124   Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
1125 }
1126
1127 void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
1128                                     ClassTemplatePartialSpecializationDecl *D) {
1129   VisitClassTemplateSpecializationDecl(D);
1130
1131   Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1132
1133   Record.push_back(D->getNumTemplateArgsAsWritten());
1134   for (int i = 0, e = D->getNumTemplateArgsAsWritten(); i != e; ++i)
1135     Writer.AddTemplateArgumentLoc(D->getTemplateArgsAsWritten()[i], Record);
1136
1137   Record.push_back(D->getSequenceNumber());
1138
1139   // These are read/set from/to the first declaration.
1140   if (D->getPreviousDecl() == 0) {
1141     Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);
1142     Record.push_back(D->isMemberSpecialization());
1143   }
1144
1145   Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
1146 }
1147
1148 void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
1149                                     ClassScopeFunctionSpecializationDecl *D) {
1150   VisitDecl(D);
1151   Writer.AddDeclRef(D->getSpecialization(), Record);
1152   Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
1153 }
1154
1155
1156 void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1157   VisitRedeclarableTemplateDecl(D);
1158
1159   if (D->isFirstDeclaration()) {
1160     // This FunctionTemplateDecl owns the CommonPtr; write it.
1161
1162     // Write the function specialization declarations.
1163     Record.push_back(D->getSpecializations().size());
1164     for (llvm::FoldingSetVector<FunctionTemplateSpecializationInfo>::iterator
1165            I = D->getSpecializations().begin(),
1166            E = D->getSpecializations().end()   ; I != E; ++I) {
1167       assert(I->Function->isCanonicalDecl() &&
1168              "Expected only canonical decls in set");
1169       Writer.AddDeclRef(I->Function, Record);
1170     }
1171   }
1172   Code = serialization::DECL_FUNCTION_TEMPLATE;
1173 }
1174
1175 void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1176   VisitTypeDecl(D);
1177
1178   Record.push_back(D->wasDeclaredWithTypename());
1179   Record.push_back(D->defaultArgumentWasInherited());
1180   Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record);
1181
1182   Code = serialization::DECL_TEMPLATE_TYPE_PARM;
1183 }
1184
1185 void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1186   // For an expanded parameter pack, record the number of expansion types here
1187   // so that it's easier for deserialization to allocate the right amount of
1188   // memory.
1189   if (D->isExpandedParameterPack())
1190     Record.push_back(D->getNumExpansionTypes());
1191
1192   VisitDeclaratorDecl(D);
1193   // TemplateParmPosition.
1194   Record.push_back(D->getDepth());
1195   Record.push_back(D->getPosition());
1196
1197   if (D->isExpandedParameterPack()) {
1198     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1199       Writer.AddTypeRef(D->getExpansionType(I), Record);
1200       Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record);
1201     }
1202
1203     Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
1204   } else {
1205     // Rest of NonTypeTemplateParmDecl.
1206     Record.push_back(D->isParameterPack());
1207     Record.push_back(D->getDefaultArgument() != 0);
1208     if (D->getDefaultArgument()) {
1209       Writer.AddStmt(D->getDefaultArgument());
1210       Record.push_back(D->defaultArgumentWasInherited());
1211     }
1212     Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
1213   }
1214 }
1215
1216 void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1217   // For an expanded parameter pack, record the number of expansion types here
1218   // so that it's easier for deserialization to allocate the right amount of
1219   // memory.
1220   if (D->isExpandedParameterPack())
1221     Record.push_back(D->getNumExpansionTemplateParameters());
1222
1223   VisitTemplateDecl(D);
1224   // TemplateParmPosition.
1225   Record.push_back(D->getDepth());
1226   Record.push_back(D->getPosition());
1227
1228   if (D->isExpandedParameterPack()) {
1229     for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1230          I != N; ++I)
1231       Writer.AddTemplateParameterList(D->getExpansionTemplateParameters(I),
1232                                       Record);
1233     Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
1234   } else {
1235     // Rest of TemplateTemplateParmDecl.
1236     Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record);
1237     Record.push_back(D->defaultArgumentWasInherited());
1238     Record.push_back(D->isParameterPack());
1239     Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
1240   }
1241 }
1242
1243 void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1244   VisitRedeclarableTemplateDecl(D);
1245   Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
1246 }
1247
1248 void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1249   VisitDecl(D);
1250   Writer.AddStmt(D->getAssertExpr());
1251   Record.push_back(D->isFailed());
1252   Writer.AddStmt(D->getMessage());
1253   Writer.AddSourceLocation(D->getRParenLoc(), Record);
1254   Code = serialization::DECL_STATIC_ASSERT;
1255 }
1256
1257 /// \brief Emit the DeclContext part of a declaration context decl.
1258 ///
1259 /// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL
1260 /// block for this declaration context is stored. May be 0 to indicate
1261 /// that there are no declarations stored within this context.
1262 ///
1263 /// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE
1264 /// block for this declaration context is stored. May be 0 to indicate
1265 /// that there are no declarations visible from this context. Note
1266 /// that this value will not be emitted for non-primary declaration
1267 /// contexts.
1268 void ASTDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
1269                                      uint64_t VisibleOffset) {
1270   Record.push_back(LexicalOffset);
1271   Record.push_back(VisibleOffset);
1272 }
1273
1274 template <typename T>
1275 void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
1276   T *First = D->getFirstDeclaration();
1277   if (First->getMostRecentDecl() != First) {
1278     // There is more than one declaration of this entity, so we will need to
1279     // write a redeclaration chain.
1280     Writer.AddDeclRef(First, Record);
1281     Writer.Redeclarations.insert(First);
1282
1283     // Make sure that we serialize both the previous and the most-recent
1284     // declarations, which (transitively) ensures that all declarations in the
1285     // chain get serialized.
1286     (void)Writer.GetDeclRef(D->getPreviousDecl());
1287     (void)Writer.GetDeclRef(First->getMostRecentDecl());
1288   } else {
1289     // We use the sentinel value 0 to indicate an only declaration.
1290     Record.push_back(0);
1291   }
1292
1293 }
1294
1295 //===----------------------------------------------------------------------===//
1296 // ASTWriter Implementation
1297 //===----------------------------------------------------------------------===//
1298
1299 void ASTWriter::WriteDeclsBlockAbbrevs() {
1300   using namespace llvm;
1301
1302   BitCodeAbbrev *Abv;
1303
1304   // Abbreviation for DECL_FIELD
1305   Abv = new BitCodeAbbrev();
1306   Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
1307   // Decl
1308   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1309   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1310   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1311   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1312   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1313   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1314   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1315   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1316   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // AccessSpecifier
1317   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1318   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1319   // NamedDecl
1320   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1321   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1322   // ValueDecl
1323   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1324   // DeclaratorDecl
1325   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1326   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1327   // FieldDecl
1328   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1329   Abv->Add(BitCodeAbbrevOp(0));                       //getBitWidth
1330   // Type Source Info
1331   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1332   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1333   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1334   DeclFieldAbbrev = Stream.EmitAbbrev(Abv);
1335
1336   // Abbreviation for DECL_OBJC_IVAR
1337   Abv = new BitCodeAbbrev();
1338   Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
1339   // Decl
1340   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1341   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1342   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1343   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1344   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1345   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1346   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1347   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1348   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // AccessSpecifier
1349   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1350   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1351   // NamedDecl
1352   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1353   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1354   // ValueDecl
1355   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1356   // DeclaratorDecl
1357   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1358   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1359   // FieldDecl
1360   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1361   Abv->Add(BitCodeAbbrevOp(0));                       //getBitWidth
1362   // ObjC Ivar
1363   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
1364   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
1365   // Type Source Info
1366   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1367   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1368   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1369   DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abv);
1370
1371   // Abbreviation for DECL_ENUM
1372   Abv = new BitCodeAbbrev();
1373   Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
1374   // Redeclarable
1375   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1376   // Decl
1377   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1378   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1379   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1380   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1381   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1382   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1383   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1384   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1385   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1386   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1387   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1388   // NamedDecl
1389   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1390   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1391   // TypeDecl
1392   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1393   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1394   // TagDecl
1395   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IdentifierNamespace
1396   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getTagKind
1397   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1398   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1399   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1400   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
1401   Abv->Add(BitCodeAbbrevOp(0));                         // hasExtInfo
1402   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // TypedefNameAnonDecl
1403   // EnumDecl
1404   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // AddTypeRef
1405   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IntegerType
1406   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getPromotionType
1407   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getNumPositiveBits
1408   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getNumNegativeBits
1409   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
1410   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
1411   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
1412   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // InstantiatedMembEnum
1413   // DC
1414   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LexicalOffset
1415   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // VisibleOffset
1416   DeclEnumAbbrev = Stream.EmitAbbrev(Abv);
1417
1418   // Abbreviation for DECL_RECORD
1419   Abv = new BitCodeAbbrev();
1420   Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
1421   // Redeclarable
1422   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1423   // Decl
1424   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1425   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1426   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1427   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1428   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1429   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1430   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1431   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1432   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1433   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1434   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1435   // NamedDecl
1436   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1437   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1438   // TypeDecl
1439   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1440   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1441   // TagDecl
1442   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IdentifierNamespace
1443   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getTagKind
1444   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1445   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1446   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1447   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
1448   Abv->Add(BitCodeAbbrevOp(0));                         // hasExtInfo
1449   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // TypedefNameAnonDecl
1450   // RecordDecl
1451   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
1452   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
1453   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
1454   // DC
1455   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LexicalOffset
1456   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // VisibleOffset
1457   DeclRecordAbbrev = Stream.EmitAbbrev(Abv);
1458
1459   // Abbreviation for DECL_PARM_VAR
1460   Abv = new BitCodeAbbrev();
1461   Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
1462   // Redeclarable
1463   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1464   // Decl
1465   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1466   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1467   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1468   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1469   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1470   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1471   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1472   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1473   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1474   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1475   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1476   // NamedDecl
1477   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1478   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1479   // ValueDecl
1480   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1481   // DeclaratorDecl
1482   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1483   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1484   // VarDecl
1485   Abv->Add(BitCodeAbbrevOp(0));                       // StorageClass
1486   Abv->Add(BitCodeAbbrevOp(0));                       // StorageClassAsWritten
1487   Abv->Add(BitCodeAbbrevOp(0));                       // isThreadSpecified
1488   Abv->Add(BitCodeAbbrevOp(0));                       // hasCXXDirectInitializer
1489   Abv->Add(BitCodeAbbrevOp(0));                       // isExceptionVariable
1490   Abv->Add(BitCodeAbbrevOp(0));                       // isNRVOVariable
1491   Abv->Add(BitCodeAbbrevOp(0));                       // isCXXForRangeDecl
1492   Abv->Add(BitCodeAbbrevOp(0));                       // isARCPseudoStrong
1493   Abv->Add(BitCodeAbbrevOp(0));                       // isConstexpr
1494   Abv->Add(BitCodeAbbrevOp(0));                       // HasInit
1495   Abv->Add(BitCodeAbbrevOp(0));                   // HasMemberSpecializationInfo
1496   // ParmVarDecl
1497   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
1498   Abv->Add(BitCodeAbbrevOp(0));                       // ScopeDepth
1499   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
1500   Abv->Add(BitCodeAbbrevOp(0));                       // ObjCDeclQualifier
1501   Abv->Add(BitCodeAbbrevOp(0));                       // KNRPromoted
1502   Abv->Add(BitCodeAbbrevOp(0));                       // HasInheritedDefaultArg
1503   Abv->Add(BitCodeAbbrevOp(0));                   // HasUninstantiatedDefaultArg
1504   // Type Source Info
1505   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1506   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1507   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1508   DeclParmVarAbbrev = Stream.EmitAbbrev(Abv);
1509
1510   // Abbreviation for DECL_TYPEDEF
1511   Abv = new BitCodeAbbrev();
1512   Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
1513   // Redeclarable
1514   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1515   // Decl
1516   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1517   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1518   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1519   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1520   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1521   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1522   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1523   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1524   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1525   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1526   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1527   // NamedDecl
1528   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1529   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1530   // TypeDecl
1531   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1532   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1533   // TypedefDecl
1534   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1535   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1536   DeclTypedefAbbrev = Stream.EmitAbbrev(Abv);
1537
1538   // Abbreviation for DECL_VAR
1539   Abv = new BitCodeAbbrev();
1540   Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
1541   // Redeclarable
1542   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1543   // Decl
1544   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1545   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1546   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1547   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1548   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1549   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1550   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1551   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1552   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1553   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1554   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1555   // NamedDecl
1556   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1557   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1558   // ValueDecl
1559   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1560   // DeclaratorDecl
1561   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1562   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1563   // VarDecl
1564   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass
1565   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClassAsWritten
1566   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isThreadSpecified
1567   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer
1568   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
1569   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
1570   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
1571   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
1572   Abv->Add(BitCodeAbbrevOp(0));                         // isConstexpr
1573   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasInit
1574   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasMemberSpecInfo
1575   // Type Source Info
1576   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1577   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1578   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1579   DeclVarAbbrev = Stream.EmitAbbrev(Abv);
1580
1581   // Abbreviation for EXPR_DECL_REF
1582   Abv = new BitCodeAbbrev();
1583   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
1584   //Stmt
1585   //Expr
1586   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1587   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1588   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1589   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1590   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1591   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1592   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1593   //DeclRefExpr
1594   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
1595   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
1596   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
1597   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
1598   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //RefersToEnclosingLocal
1599   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
1600   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1601   DeclRefExprAbbrev = Stream.EmitAbbrev(Abv);
1602
1603   // Abbreviation for EXPR_INTEGER_LITERAL
1604   Abv = new BitCodeAbbrev();
1605   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
1606   //Stmt
1607   //Expr
1608   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1609   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1610   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1611   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1612   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1613   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1614   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1615   //Integer Literal
1616   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1617   Abv->Add(BitCodeAbbrevOp(32));                      // Bit Width
1618   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
1619   IntegerLiteralAbbrev = Stream.EmitAbbrev(Abv);
1620
1621   // Abbreviation for EXPR_CHARACTER_LITERAL
1622   Abv = new BitCodeAbbrev();
1623   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
1624   //Stmt
1625   //Expr
1626   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1627   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1628   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1629   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1630   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1631   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1632   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1633   //Character Literal
1634   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
1635   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1636   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getKind
1637   CharacterLiteralAbbrev = Stream.EmitAbbrev(Abv);
1638
1639   Abv = new BitCodeAbbrev();
1640   Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
1641   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1642   DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abv);
1643
1644   Abv = new BitCodeAbbrev();
1645   Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
1646   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1647   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1648   DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abv);
1649 }
1650
1651 /// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
1652 /// consumers of the AST.
1653 ///
1654 /// Such decls will always be deserialized from the AST file, so we would like
1655 /// this to be as restrictive as possible. Currently the predicate is driven by
1656 /// code generation requirements, if other clients have a different notion of
1657 /// what is "required" then we may have to consider an alternate scheme where
1658 /// clients can iterate over the top-level decls and get information on them,
1659 /// without necessary deserializing them. We could explicitly require such
1660 /// clients to use a separate API call to "realize" the decl. This should be
1661 /// relatively painless since they would presumably only do it for top-level
1662 /// decls.
1663 static bool isRequiredDecl(const Decl *D, ASTContext &Context) {
1664   // An ObjCMethodDecl is never considered as "required" because its
1665   // implementation container always is.
1666
1667   // File scoped assembly or obj-c implementation must be seen.
1668   if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D))
1669     return true;
1670
1671   return Context.DeclMustBeEmitted(D);
1672 }
1673
1674 void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
1675   // Switch case IDs are per Decl.
1676   ClearSwitchCaseIDs();
1677
1678   RecordData Record;
1679   ASTDeclWriter W(*this, Context, Record);
1680
1681   // Determine the ID for this declaration.
1682   serialization::DeclID ID;
1683   if (D->isFromASTFile())
1684     ID = getDeclID(D);
1685   else {
1686     serialization::DeclID &IDR = DeclIDs[D];
1687     if (IDR == 0)
1688       IDR = NextDeclID++;
1689
1690     ID= IDR;
1691   }
1692
1693   bool isReplacingADecl = ID < FirstDeclID;
1694
1695   // If this declaration is also a DeclContext, write blocks for the
1696   // declarations that lexically stored inside its context and those
1697   // declarations that are visible from its context. These blocks
1698   // are written before the declaration itself so that we can put
1699   // their offsets into the record for the declaration.
1700   uint64_t LexicalOffset = 0;
1701   uint64_t VisibleOffset = 0;
1702   DeclContext *DC = dyn_cast<DeclContext>(D);
1703   if (DC) {
1704     if (isReplacingADecl) {
1705       // It is replacing a decl from a chained PCH; make sure that the
1706       // DeclContext is fully loaded.
1707       if (DC->hasExternalLexicalStorage())
1708         DC->LoadLexicalDeclsFromExternalStorage();
1709       if (DC->hasExternalVisibleStorage())
1710         Chain->completeVisibleDeclsMap(DC);
1711     }
1712     LexicalOffset = WriteDeclContextLexicalBlock(Context, DC);
1713     VisibleOffset = WriteDeclContextVisibleBlock(Context, DC);
1714   }
1715
1716   if (isReplacingADecl) {
1717     // We're replacing a decl in a previous file.
1718     ReplacedDecls.push_back(ReplacedDeclInfo(ID, Stream.GetCurrentBitNo(),
1719                                              D->getLocation()));
1720   } else {
1721     unsigned Index = ID - FirstDeclID;
1722
1723     // Record the offset for this declaration
1724     SourceLocation Loc = D->getLocation();
1725     if (DeclOffsets.size() == Index)
1726       DeclOffsets.push_back(DeclOffset(Loc, Stream.GetCurrentBitNo()));
1727     else if (DeclOffsets.size() < Index) {
1728       DeclOffsets.resize(Index+1);
1729       DeclOffsets[Index].setLocation(Loc);
1730       DeclOffsets[Index].BitOffset = Stream.GetCurrentBitNo();
1731     }
1732
1733     SourceManager &SM = Context.getSourceManager();
1734     if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
1735       associateDeclWithFile(D, ID);
1736   }
1737
1738   // Build and emit a record for this declaration
1739   Record.clear();
1740   W.Code = (serialization::DeclCode)0;
1741   W.AbbrevToUse = 0;
1742   W.Visit(D);
1743   if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset);
1744
1745   if (!W.Code)
1746     llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
1747                             D->getDeclKindName() + "'");
1748   Stream.EmitRecord(W.Code, Record, W.AbbrevToUse);
1749
1750   // Flush any expressions that were written as part of this declaration.
1751   FlushStmts();
1752
1753   // Flush C++ base specifiers, if there are any.
1754   FlushCXXBaseSpecifiers();
1755
1756   // Note "external" declarations so that we can add them to a record in the
1757   // AST file later.
1758   //
1759   // FIXME: This should be renamed, the predicate is much more complicated.
1760   if (isRequiredDecl(D, Context))
1761     ExternalDefinitions.push_back(ID);
1762 }