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