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