1 //===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements serialization for Declarations.
12 //===----------------------------------------------------------------------===//
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"
26 using namespace clang;
27 using namespace serialization;
29 //===----------------------------------------------------------------------===//
30 // Declaration serialization
31 //===----------------------------------------------------------------------===//
34 class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
38 typedef ASTWriter::RecordData RecordData;
42 serialization::DeclCode Code;
45 ASTDeclWriter(ASTWriter &Writer, ASTContext &Context, RecordData &Record)
46 : Writer(Writer), Context(Context), Record(Record) {
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 VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
72 void VisitVarTemplatePartialSpecializationDecl(
73 VarTemplatePartialSpecializationDecl *D);
74 void VisitClassScopeFunctionSpecializationDecl(
75 ClassScopeFunctionSpecializationDecl *D);
76 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
77 void VisitValueDecl(ValueDecl *D);
78 void VisitEnumConstantDecl(EnumConstantDecl *D);
79 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
80 void VisitDeclaratorDecl(DeclaratorDecl *D);
81 void VisitFunctionDecl(FunctionDecl *D);
82 void VisitCXXMethodDecl(CXXMethodDecl *D);
83 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
84 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
85 void VisitCXXConversionDecl(CXXConversionDecl *D);
86 void VisitFieldDecl(FieldDecl *D);
87 void VisitMSPropertyDecl(MSPropertyDecl *D);
88 void VisitIndirectFieldDecl(IndirectFieldDecl *D);
89 void VisitVarDecl(VarDecl *D);
90 void VisitImplicitParamDecl(ImplicitParamDecl *D);
91 void VisitParmVarDecl(ParmVarDecl *D);
92 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
93 void VisitTemplateDecl(TemplateDecl *D);
94 void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
95 void VisitClassTemplateDecl(ClassTemplateDecl *D);
96 void VisitVarTemplateDecl(VarTemplateDecl *D);
97 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
98 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
99 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
100 void VisitUsingDecl(UsingDecl *D);
101 void VisitUsingShadowDecl(UsingShadowDecl *D);
102 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
103 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
104 void VisitImportDecl(ImportDecl *D);
105 void VisitAccessSpecDecl(AccessSpecDecl *D);
106 void VisitFriendDecl(FriendDecl *D);
107 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
108 void VisitStaticAssertDecl(StaticAssertDecl *D);
109 void VisitBlockDecl(BlockDecl *D);
110 void VisitCapturedDecl(CapturedDecl *D);
111 void VisitEmptyDecl(EmptyDecl *D);
113 void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
114 uint64_t VisibleOffset);
115 template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
118 // FIXME: Put in the same order is DeclNodes.td?
119 void VisitObjCMethodDecl(ObjCMethodDecl *D);
120 void VisitObjCContainerDecl(ObjCContainerDecl *D);
121 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
122 void VisitObjCIvarDecl(ObjCIvarDecl *D);
123 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
124 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
125 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
126 void VisitObjCImplDecl(ObjCImplDecl *D);
127 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
128 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
129 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
130 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
131 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
132 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
136 void ASTDeclWriter::Visit(Decl *D) {
137 DeclVisitor<ASTDeclWriter>::Visit(D);
139 // Source locations require array (variable-length) abbreviations. The
140 // abbreviation infrastructure requires that arrays are encoded last, so
141 // we handle it here in the case of those classes derived from DeclaratorDecl
142 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)){
143 Writer.AddTypeSourceInfo(DD->getTypeSourceInfo(), Record);
146 // Handle FunctionDecl's body here and write it after all other Stmts/Exprs
147 // have been written. We want it last because we will not read it back when
148 // retrieving it from the AST, we'll just lazily set the offset.
149 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
150 Record.push_back(FD->doesThisDeclarationHaveABody());
151 if (FD->doesThisDeclarationHaveABody())
152 Writer.AddStmt(FD->getBody());
156 void ASTDeclWriter::VisitDecl(Decl *D) {
157 Writer.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()), Record);
158 Writer.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()), Record);
159 Record.push_back(D->isInvalidDecl());
160 Record.push_back(D->hasAttrs());
162 Writer.WriteAttributes(ArrayRef<const Attr*>(D->getAttrs().begin(),
163 D->getAttrs().size()), Record);
164 Record.push_back(D->isImplicit());
165 Record.push_back(D->isUsed(false));
166 Record.push_back(D->isReferenced());
167 Record.push_back(D->isTopLevelDeclInObjCContainer());
168 Record.push_back(D->getAccess());
169 Record.push_back(D->isModulePrivate());
170 Record.push_back(Writer.inferSubmoduleIDFromLocation(D->getLocation()));
173 void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
174 llvm_unreachable("Translation units aren't directly serialized");
177 void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
179 Writer.AddDeclarationName(D->getDeclName(), Record);
182 void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
184 Writer.AddSourceLocation(D->getLocStart(), Record);
185 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
188 void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
189 VisitRedeclarable(D);
191 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
192 Record.push_back(D->isModed());
194 Writer.AddTypeRef(D->getUnderlyingType(), Record);
197 void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
198 VisitTypedefNameDecl(D);
199 if (!D->hasAttrs() &&
202 D->getFirstDecl() == D->getMostRecentDecl() &&
203 !D->isInvalidDecl() &&
204 !D->isReferenced() &&
205 !D->isTopLevelDeclInObjCContainer() &&
206 D->getAccess() == AS_none &&
207 !D->isModulePrivate() &&
208 D->getDeclName().getNameKind() == DeclarationName::Identifier)
209 AbbrevToUse = Writer.getDeclTypedefAbbrev();
211 Code = serialization::DECL_TYPEDEF;
214 void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
215 VisitTypedefNameDecl(D);
216 Code = serialization::DECL_TYPEALIAS;
219 void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
220 VisitRedeclarable(D);
222 Record.push_back(D->getIdentifierNamespace());
223 Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
224 Record.push_back(D->isCompleteDefinition());
225 Record.push_back(D->isEmbeddedInDeclarator());
226 Record.push_back(D->isFreeStanding());
227 Record.push_back(D->isCompleteDefinitionRequired());
228 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
229 Record.push_back(D->hasExtInfo());
231 Writer.AddQualifierInfo(*D->getExtInfo(), Record);
232 else if (D->hasDeclaratorForAnonDecl())
233 Writer.AddDeclRef(D->getDeclaratorForAnonDecl(), Record);
235 Writer.AddDeclRef(D->getTypedefNameForAnonDecl(), Record);
238 void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
240 Writer.AddTypeSourceInfo(D->getIntegerTypeSourceInfo(), Record);
241 if (!D->getIntegerTypeSourceInfo())
242 Writer.AddTypeRef(D->getIntegerType(), Record);
243 Writer.AddTypeRef(D->getPromotionType(), Record);
244 Record.push_back(D->getNumPositiveBits());
245 Record.push_back(D->getNumNegativeBits());
246 Record.push_back(D->isScoped());
247 Record.push_back(D->isScopedUsingClassTag());
248 Record.push_back(D->isFixed());
249 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
250 Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
251 Record.push_back(MemberInfo->getTemplateSpecializationKind());
252 Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
254 Writer.AddDeclRef(0, Record);
257 if (!D->hasAttrs() &&
261 D->getFirstDecl() == D->getMostRecentDecl() &&
262 !D->isInvalidDecl() &&
263 !D->isReferenced() &&
264 !D->isTopLevelDeclInObjCContainer() &&
265 D->getAccess() == AS_none &&
266 !D->isModulePrivate() &&
267 !CXXRecordDecl::classofKind(D->getKind()) &&
268 !D->getIntegerTypeSourceInfo() &&
269 !D->getMemberSpecializationInfo() &&
270 D->getDeclName().getNameKind() == DeclarationName::Identifier)
271 AbbrevToUse = Writer.getDeclEnumAbbrev();
273 Code = serialization::DECL_ENUM;
276 void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
278 Record.push_back(D->hasFlexibleArrayMember());
279 Record.push_back(D->isAnonymousStructOrUnion());
280 Record.push_back(D->hasObjectMember());
281 Record.push_back(D->hasVolatileMember());
283 if (!D->hasAttrs() &&
287 D->getFirstDecl() == D->getMostRecentDecl() &&
288 !D->isInvalidDecl() &&
289 !D->isReferenced() &&
290 !D->isTopLevelDeclInObjCContainer() &&
291 D->getAccess() == AS_none &&
292 !D->isModulePrivate() &&
293 !CXXRecordDecl::classofKind(D->getKind()) &&
294 D->getDeclName().getNameKind() == DeclarationName::Identifier)
295 AbbrevToUse = Writer.getDeclRecordAbbrev();
297 Code = serialization::DECL_RECORD;
300 void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
302 Writer.AddTypeRef(D->getType(), Record);
305 void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
307 Record.push_back(D->getInitExpr()? 1 : 0);
308 if (D->getInitExpr())
309 Writer.AddStmt(D->getInitExpr());
310 Writer.AddAPSInt(D->getInitVal(), Record);
312 Code = serialization::DECL_ENUM_CONSTANT;
315 void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
317 Writer.AddSourceLocation(D->getInnerLocStart(), Record);
318 Record.push_back(D->hasExtInfo());
320 Writer.AddQualifierInfo(*D->getExtInfo(), Record);
323 void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
324 VisitRedeclarable(D);
325 VisitDeclaratorDecl(D);
327 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
328 Record.push_back(D->getIdentifierNamespace());
330 // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
331 // after everything else is written.
333 Record.push_back(D->getStorageClass()); // FIXME: stable encoding
334 Record.push_back(D->IsInline);
335 Record.push_back(D->isInlineSpecified());
336 Record.push_back(D->isVirtualAsWritten());
337 Record.push_back(D->isPure());
338 Record.push_back(D->hasInheritedPrototype());
339 Record.push_back(D->hasWrittenPrototype());
340 Record.push_back(D->isDeletedAsWritten());
341 Record.push_back(D->isTrivial());
342 Record.push_back(D->isDefaulted());
343 Record.push_back(D->isExplicitlyDefaulted());
344 Record.push_back(D->hasImplicitReturnZero());
345 Record.push_back(D->isConstexpr());
346 Record.push_back(D->HasSkippedBody);
347 Record.push_back(D->isLateTemplateParsed());
348 Record.push_back(D->getLinkageInternal());
349 Writer.AddSourceLocation(D->getLocEnd(), Record);
351 Record.push_back(D->getTemplatedKind());
352 switch (D->getTemplatedKind()) {
353 case FunctionDecl::TK_NonTemplate:
355 case FunctionDecl::TK_FunctionTemplate:
356 Writer.AddDeclRef(D->getDescribedFunctionTemplate(), Record);
358 case FunctionDecl::TK_MemberSpecialization: {
359 MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
360 Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
361 Record.push_back(MemberInfo->getTemplateSpecializationKind());
362 Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
365 case FunctionDecl::TK_FunctionTemplateSpecialization: {
366 FunctionTemplateSpecializationInfo *
367 FTSInfo = D->getTemplateSpecializationInfo();
368 Writer.AddDeclRef(FTSInfo->getTemplate(), Record);
369 Record.push_back(FTSInfo->getTemplateSpecializationKind());
371 // Template arguments.
372 Writer.AddTemplateArgumentList(FTSInfo->TemplateArguments, Record);
374 // Template args as written.
375 Record.push_back(FTSInfo->TemplateArgumentsAsWritten != 0);
376 if (FTSInfo->TemplateArgumentsAsWritten) {
377 Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
378 for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
380 Writer.AddTemplateArgumentLoc((*FTSInfo->TemplateArgumentsAsWritten)[i],
382 Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc,
384 Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc,
388 Writer.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Record);
390 if (D->isCanonicalDecl()) {
391 // Write the template that contains the specializations set. We will
392 // add a FunctionTemplateSpecializationInfo to it when reading.
393 Writer.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl(), Record);
397 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
398 DependentFunctionTemplateSpecializationInfo *
399 DFTSInfo = D->getDependentSpecializationInfo();
402 Record.push_back(DFTSInfo->getNumTemplates());
403 for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
404 Writer.AddDeclRef(DFTSInfo->getTemplate(i), Record);
407 Record.push_back(DFTSInfo->getNumTemplateArgs());
408 for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
409 Writer.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i), Record);
410 Writer.AddSourceLocation(DFTSInfo->getLAngleLoc(), Record);
411 Writer.AddSourceLocation(DFTSInfo->getRAngleLoc(), Record);
416 Record.push_back(D->param_size());
417 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
419 Writer.AddDeclRef(*P, Record);
420 Code = serialization::DECL_FUNCTION;
423 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
425 // FIXME: convert to LazyStmtPtr?
426 // Unlike C/C++, method bodies will never be in header files.
427 bool HasBodyStuff = D->getBody() != 0 ||
428 D->getSelfDecl() != 0 || D->getCmdDecl() != 0;
429 Record.push_back(HasBodyStuff);
431 Writer.AddStmt(D->getBody());
432 Writer.AddDeclRef(D->getSelfDecl(), Record);
433 Writer.AddDeclRef(D->getCmdDecl(), Record);
435 Record.push_back(D->isInstanceMethod());
436 Record.push_back(D->isVariadic());
437 Record.push_back(D->isPropertyAccessor());
438 Record.push_back(D->isDefined());
439 Record.push_back(D->IsOverriding);
440 Record.push_back(D->HasSkippedBody);
442 Record.push_back(D->IsRedeclaration);
443 Record.push_back(D->HasRedeclaration);
444 if (D->HasRedeclaration) {
445 assert(Context.getObjCMethodRedeclaration(D));
446 Writer.AddDeclRef(Context.getObjCMethodRedeclaration(D), Record);
449 // FIXME: stable encoding for @required/@optional
450 Record.push_back(D->getImplementationControl());
451 // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway
452 Record.push_back(D->getObjCDeclQualifier());
453 Record.push_back(D->hasRelatedResultType());
454 Writer.AddTypeRef(D->getResultType(), Record);
455 Writer.AddTypeSourceInfo(D->getResultTypeSourceInfo(), Record);
456 Writer.AddSourceLocation(D->getLocEnd(), Record);
457 Record.push_back(D->param_size());
458 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
459 PEnd = D->param_end(); P != PEnd; ++P)
460 Writer.AddDeclRef(*P, Record);
462 Record.push_back(D->SelLocsKind);
463 unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
464 SourceLocation *SelLocs = D->getStoredSelLocs();
465 Record.push_back(NumStoredSelLocs);
466 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
467 Writer.AddSourceLocation(SelLocs[i], Record);
469 Code = serialization::DECL_OBJC_METHOD;
472 void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
474 Writer.AddSourceLocation(D->getAtStartLoc(), Record);
475 Writer.AddSourceRange(D->getAtEndRange(), Record);
476 // Abstract class (no need to define a stable serialization::DECL code).
479 void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
480 VisitRedeclarable(D);
481 VisitObjCContainerDecl(D);
482 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
484 Record.push_back(D->isThisDeclarationADefinition());
485 if (D->isThisDeclarationADefinition()) {
486 // Write the DefinitionData
487 ObjCInterfaceDecl::DefinitionData &Data = D->data();
489 Writer.AddDeclRef(D->getSuperClass(), Record);
490 Writer.AddSourceLocation(D->getSuperClassLoc(), Record);
491 Writer.AddSourceLocation(D->getEndOfDefinitionLoc(), Record);
493 // Write out the protocols that are directly referenced by the @interface.
494 Record.push_back(Data.ReferencedProtocols.size());
495 for (ObjCInterfaceDecl::protocol_iterator P = D->protocol_begin(),
496 PEnd = D->protocol_end();
498 Writer.AddDeclRef(*P, Record);
499 for (ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
500 PLEnd = D->protocol_loc_end();
502 Writer.AddSourceLocation(*PL, Record);
504 // Write out the protocols that are transitively referenced.
505 Record.push_back(Data.AllReferencedProtocols.size());
506 for (ObjCList<ObjCProtocolDecl>::iterator
507 P = Data.AllReferencedProtocols.begin(),
508 PEnd = Data.AllReferencedProtocols.end();
510 Writer.AddDeclRef(*P, Record);
513 if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
514 // Ensure that we write out the set of categories for this class.
515 Writer.ObjCClassesWithCategories.insert(D);
517 // Make sure that the categories get serialized.
518 for (; Cat; Cat = Cat->getNextClassCategoryRaw())
519 (void)Writer.GetDeclRef(Cat);
523 Code = serialization::DECL_OBJC_INTERFACE;
526 void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
528 // FIXME: stable encoding for @public/@private/@protected/@package
529 Record.push_back(D->getAccessControl());
530 Record.push_back(D->getSynthesize());
531 Record.push_back(D->getBackingIvarReferencedInAccessor());
533 if (!D->hasAttrs() &&
536 !D->isInvalidDecl() &&
537 !D->isReferenced() &&
538 !D->isModulePrivate() &&
542 AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
544 Code = serialization::DECL_OBJC_IVAR;
547 void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
548 VisitRedeclarable(D);
549 VisitObjCContainerDecl(D);
551 Record.push_back(D->isThisDeclarationADefinition());
552 if (D->isThisDeclarationADefinition()) {
553 Record.push_back(D->protocol_size());
554 for (ObjCProtocolDecl::protocol_iterator
555 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
556 Writer.AddDeclRef(*I, Record);
557 for (ObjCProtocolDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
558 PLEnd = D->protocol_loc_end();
560 Writer.AddSourceLocation(*PL, Record);
563 Code = serialization::DECL_OBJC_PROTOCOL;
566 void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
568 Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
571 void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
572 VisitObjCContainerDecl(D);
573 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
574 Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
575 Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
576 Writer.AddDeclRef(D->getClassInterface(), Record);
577 Record.push_back(D->protocol_size());
578 for (ObjCCategoryDecl::protocol_iterator
579 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
580 Writer.AddDeclRef(*I, Record);
581 for (ObjCCategoryDecl::protocol_loc_iterator
582 PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end();
584 Writer.AddSourceLocation(*PL, Record);
585 Code = serialization::DECL_OBJC_CATEGORY;
588 void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
590 Writer.AddDeclRef(D->getClassInterface(), Record);
591 Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
594 void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
596 Writer.AddSourceLocation(D->getAtLoc(), Record);
597 Writer.AddSourceLocation(D->getLParenLoc(), Record);
598 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
599 // FIXME: stable encoding
600 Record.push_back((unsigned)D->getPropertyAttributes());
601 Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
602 // FIXME: stable encoding
603 Record.push_back((unsigned)D->getPropertyImplementation());
604 Writer.AddDeclarationName(D->getGetterName(), Record);
605 Writer.AddDeclarationName(D->getSetterName(), Record);
606 Writer.AddDeclRef(D->getGetterMethodDecl(), Record);
607 Writer.AddDeclRef(D->getSetterMethodDecl(), Record);
608 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
609 Code = serialization::DECL_OBJC_PROPERTY;
612 void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
613 VisitObjCContainerDecl(D);
614 Writer.AddDeclRef(D->getClassInterface(), Record);
615 // Abstract class (no need to define a stable serialization::DECL code).
618 void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
619 VisitObjCImplDecl(D);
620 Writer.AddIdentifierRef(D->getIdentifier(), Record);
621 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
622 Code = serialization::DECL_OBJC_CATEGORY_IMPL;
625 void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
626 VisitObjCImplDecl(D);
627 Writer.AddDeclRef(D->getSuperClass(), Record);
628 Writer.AddSourceLocation(D->getSuperClassLoc(), Record);
629 Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
630 Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
631 Record.push_back(D->hasNonZeroConstructors());
632 Record.push_back(D->hasDestructors());
633 Writer.AddCXXCtorInitializers(D->IvarInitializers, D->NumIvarInitializers,
635 Code = serialization::DECL_OBJC_IMPLEMENTATION;
638 void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
640 Writer.AddSourceLocation(D->getLocStart(), Record);
641 Writer.AddDeclRef(D->getPropertyDecl(), Record);
642 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
643 Writer.AddSourceLocation(D->getPropertyIvarDeclLoc(), Record);
644 Writer.AddStmt(D->getGetterCXXConstructor());
645 Writer.AddStmt(D->getSetterCXXAssignment());
646 Code = serialization::DECL_OBJC_PROPERTY_IMPL;
649 void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
650 VisitDeclaratorDecl(D);
651 Record.push_back(D->isMutable());
652 if (D->InitializerOrBitWidth.getInt() != ICIS_NoInit ||
653 D->InitializerOrBitWidth.getPointer()) {
654 Record.push_back(D->InitializerOrBitWidth.getInt() + 1);
655 Writer.AddStmt(D->InitializerOrBitWidth.getPointer());
659 if (!D->getDeclName())
660 Writer.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D), Record);
662 if (!D->hasAttrs() &&
665 !D->isInvalidDecl() &&
666 !D->isReferenced() &&
667 !D->isTopLevelDeclInObjCContainer() &&
668 !D->isModulePrivate() &&
670 !D->hasInClassInitializer() &&
672 !ObjCIvarDecl::classofKind(D->getKind()) &&
673 !ObjCAtDefsFieldDecl::classofKind(D->getKind()) &&
675 AbbrevToUse = Writer.getDeclFieldAbbrev();
677 Code = serialization::DECL_FIELD;
680 void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
681 VisitDeclaratorDecl(D);
682 Writer.AddIdentifierRef(D->getGetterId(), Record);
683 Writer.AddIdentifierRef(D->getSetterId(), Record);
684 Code = serialization::DECL_MS_PROPERTY;
687 void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
689 Record.push_back(D->getChainingSize());
691 for (IndirectFieldDecl::chain_iterator
692 P = D->chain_begin(),
693 PEnd = D->chain_end(); P != PEnd; ++P)
694 Writer.AddDeclRef(*P, Record);
695 Code = serialization::DECL_INDIRECTFIELD;
698 void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
699 VisitRedeclarable(D);
700 VisitDeclaratorDecl(D);
701 Record.push_back(D->getStorageClass());
702 Record.push_back(D->getTSCSpec());
703 Record.push_back(D->getInitStyle());
704 Record.push_back(D->isExceptionVariable());
705 Record.push_back(D->isNRVOVariable());
706 Record.push_back(D->isCXXForRangeDecl());
707 Record.push_back(D->isARCPseudoStrong());
708 Record.push_back(D->isConstexpr());
709 Record.push_back(D->isInitCapture());
710 Record.push_back(D->isPreviousDeclInSameBlockScope());
711 Record.push_back(D->getLinkageInternal());
714 Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2));
715 Writer.AddStmt(D->getInit());
721 VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
723 if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) {
724 Record.push_back(VarTemplate);
725 Writer.AddDeclRef(TemplD, Record);
726 } else if (MemberSpecializationInfo *SpecInfo
727 = D->getMemberSpecializationInfo()) {
728 Record.push_back(StaticDataMemberSpecialization);
729 Writer.AddDeclRef(SpecInfo->getInstantiatedFrom(), Record);
730 Record.push_back(SpecInfo->getTemplateSpecializationKind());
731 Writer.AddSourceLocation(SpecInfo->getPointOfInstantiation(), Record);
733 Record.push_back(VarNotTemplate);
736 if (!D->hasAttrs() &&
739 !D->isInvalidDecl() &&
740 !D->isReferenced() &&
741 !D->isTopLevelDeclInObjCContainer() &&
742 D->getAccess() == AS_none &&
743 !D->isModulePrivate() &&
744 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
746 D->getFirstDecl() == D->getMostRecentDecl() &&
747 D->getInitStyle() == VarDecl::CInit &&
749 !isa<ParmVarDecl>(D) &&
750 !isa<VarTemplateSpecializationDecl>(D) &&
752 !D->isInitCapture() &&
753 !D->isPreviousDeclInSameBlockScope() &&
754 !D->getMemberSpecializationInfo())
755 AbbrevToUse = Writer.getDeclVarAbbrev();
757 Code = serialization::DECL_VAR;
760 void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
762 Code = serialization::DECL_IMPLICIT_PARAM;
765 void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
767 Record.push_back(D->isObjCMethodParameter());
768 Record.push_back(D->getFunctionScopeDepth());
769 Record.push_back(D->getFunctionScopeIndex());
770 Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
771 Record.push_back(D->isKNRPromoted());
772 Record.push_back(D->hasInheritedDefaultArg());
773 Record.push_back(D->hasUninstantiatedDefaultArg());
774 if (D->hasUninstantiatedDefaultArg())
775 Writer.AddStmt(D->getUninstantiatedDefaultArg());
776 Code = serialization::DECL_PARM_VAR;
778 assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl
780 // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here
781 // we dynamically check for the properties that we optimize for, but don't
782 // know are true of all PARM_VAR_DECLs.
783 if (!D->hasAttrs() &&
787 !D->isInvalidDecl() &&
788 !D->isReferenced() &&
789 D->getAccess() == AS_none &&
790 !D->isModulePrivate() &&
791 D->getStorageClass() == 0 &&
792 D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
793 D->getFunctionScopeDepth() == 0 &&
794 D->getObjCDeclQualifier() == 0 &&
795 !D->isKNRPromoted() &&
796 !D->hasInheritedDefaultArg() &&
798 !D->hasUninstantiatedDefaultArg()) // No default expr.
799 AbbrevToUse = Writer.getDeclParmVarAbbrev();
801 // Check things we know are true of *every* PARM_VAR_DECL, which is more than
802 // just us assuming it.
803 assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS");
804 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
805 assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
806 assert(D->getPreviousDecl() == 0 && "PARM_VAR_DECL can't be redecl");
807 assert(!D->isStaticDataMember() &&
808 "PARM_VAR_DECL can't be static data member");
811 void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
813 Writer.AddStmt(D->getAsmString());
814 Writer.AddSourceLocation(D->getRParenLoc(), Record);
815 Code = serialization::DECL_FILE_SCOPE_ASM;
818 void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
820 Code = serialization::DECL_EMPTY;
823 void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
825 Writer.AddStmt(D->getBody());
826 Writer.AddTypeSourceInfo(D->getSignatureAsWritten(), Record);
827 Record.push_back(D->param_size());
828 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
830 Writer.AddDeclRef(*P, Record);
831 Record.push_back(D->isVariadic());
832 Record.push_back(D->blockMissingReturnType());
833 Record.push_back(D->isConversionFromLambda());
834 Record.push_back(D->capturesCXXThis());
835 Record.push_back(D->getNumCaptures());
836 for (BlockDecl::capture_iterator
837 i = D->capture_begin(), e = D->capture_end(); i != e; ++i) {
838 const BlockDecl::Capture &capture = *i;
839 Writer.AddDeclRef(capture.getVariable(), Record);
842 if (capture.isByRef()) flags |= 1;
843 if (capture.isNested()) flags |= 2;
844 if (capture.hasCopyExpr()) flags |= 4;
845 Record.push_back(flags);
847 if (capture.hasCopyExpr()) Writer.AddStmt(capture.getCopyExpr());
850 Code = serialization::DECL_BLOCK;
853 void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) {
854 Record.push_back(CD->getNumParams());
856 // Body is stored by VisitCapturedStmt.
857 for (unsigned i = 0; i < CD->getNumParams(); ++i)
858 Writer.AddDeclRef(CD->getParam(i), Record);
859 Code = serialization::DECL_CAPTURED;
862 void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
864 Record.push_back(D->getLanguage());
865 Writer.AddSourceLocation(D->getExternLoc(), Record);
866 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
867 Code = serialization::DECL_LINKAGE_SPEC;
870 void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
872 Writer.AddSourceLocation(D->getLocStart(), Record);
873 Code = serialization::DECL_LABEL;
877 void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
878 VisitRedeclarable(D);
880 Record.push_back(D->isInline());
881 Writer.AddSourceLocation(D->getLocStart(), Record);
882 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
884 if (D->isOriginalNamespace())
885 Writer.AddDeclRef(D->getAnonymousNamespace(), Record);
886 Code = serialization::DECL_NAMESPACE;
888 if (Writer.hasChain() && !D->isOriginalNamespace() &&
889 D->getOriginalNamespace()->isFromASTFile()) {
890 NamespaceDecl *NS = D->getOriginalNamespace();
891 Writer.AddUpdatedDeclContext(NS);
893 // Make sure all visible decls are written. They will be recorded later.
894 if (StoredDeclsMap *Map = NS->buildLookup()) {
895 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
897 DeclContext::lookup_result R = D->second.getLookupResult();
898 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
900 Writer.GetDeclRef(*I);
905 if (Writer.hasChain() && D->isAnonymousNamespace() &&
906 D == D->getMostRecentDecl()) {
907 // This is a most recent reopening of the anonymous namespace. If its parent
908 // is in a previous PCH (or is the TU), mark that parent for update, because
909 // the original namespace always points to the latest re-opening of its
910 // anonymous namespace.
911 Decl *Parent = cast<Decl>(
912 D->getParent()->getRedeclContext()->getPrimaryContext());
913 if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
914 ASTWriter::UpdateRecord &Record = Writer.DeclUpdates[Parent];
915 Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE);
916 Writer.AddDeclRef(D, Record);
921 void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
923 Writer.AddSourceLocation(D->getNamespaceLoc(), Record);
924 Writer.AddSourceLocation(D->getTargetNameLoc(), Record);
925 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
926 Writer.AddDeclRef(D->getNamespace(), Record);
927 Code = serialization::DECL_NAMESPACE_ALIAS;
930 void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
932 Writer.AddSourceLocation(D->getUsingLoc(), Record);
933 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
934 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
935 Writer.AddDeclRef(D->FirstUsingShadow.getPointer(), Record);
936 Record.push_back(D->hasTypename());
937 Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record);
938 Code = serialization::DECL_USING;
941 void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
942 VisitRedeclarable(D);
944 Writer.AddDeclRef(D->getTargetDecl(), Record);
945 Writer.AddDeclRef(D->UsingOrNextShadow, Record);
946 Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record);
947 Code = serialization::DECL_USING_SHADOW;
950 void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
952 Writer.AddSourceLocation(D->getUsingLoc(), Record);
953 Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record);
954 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
955 Writer.AddDeclRef(D->getNominatedNamespace(), Record);
956 Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record);
957 Code = serialization::DECL_USING_DIRECTIVE;
960 void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
962 Writer.AddSourceLocation(D->getUsingLoc(), Record);
963 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
964 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
965 Code = serialization::DECL_UNRESOLVED_USING_VALUE;
968 void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
969 UnresolvedUsingTypenameDecl *D) {
971 Writer.AddSourceLocation(D->getTypenameLoc(), Record);
972 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
973 Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
976 void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
978 Record.push_back(D->isThisDeclarationADefinition());
979 if (D->isThisDeclarationADefinition())
980 Writer.AddCXXDefinitionData(D, Record);
983 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
985 if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
986 Record.push_back(CXXRecTemplate);
987 Writer.AddDeclRef(TemplD, Record);
988 } else if (MemberSpecializationInfo *MSInfo
989 = D->getMemberSpecializationInfo()) {
990 Record.push_back(CXXRecMemberSpecialization);
991 Writer.AddDeclRef(MSInfo->getInstantiatedFrom(), Record);
992 Record.push_back(MSInfo->getTemplateSpecializationKind());
993 Writer.AddSourceLocation(MSInfo->getPointOfInstantiation(), Record);
995 Record.push_back(CXXRecNotTemplate);
998 // Store (what we currently believe to be) the key function to avoid
999 // deserializing every method so we can compute it.
1000 if (D->IsCompleteDefinition)
1001 Writer.AddDeclRef(Context.getCurrentKeyFunction(D), Record);
1003 Code = serialization::DECL_CXX_RECORD;
1006 void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
1007 VisitFunctionDecl(D);
1008 if (D->isCanonicalDecl()) {
1009 Record.push_back(D->size_overridden_methods());
1010 for (CXXMethodDecl::method_iterator
1011 I = D->begin_overridden_methods(), E = D->end_overridden_methods();
1013 Writer.AddDeclRef(*I, Record);
1015 // We only need to record overridden methods once for the canonical decl.
1016 Record.push_back(0);
1018 Code = serialization::DECL_CXX_METHOD;
1021 void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1022 VisitCXXMethodDecl(D);
1024 Record.push_back(D->IsExplicitSpecified);
1025 Writer.AddCXXCtorInitializers(D->CtorInitializers, D->NumCtorInitializers,
1028 Code = serialization::DECL_CXX_CONSTRUCTOR;
1031 void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1032 VisitCXXMethodDecl(D);
1034 Writer.AddDeclRef(D->OperatorDelete, Record);
1036 Code = serialization::DECL_CXX_DESTRUCTOR;
1039 void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
1040 VisitCXXMethodDecl(D);
1041 Record.push_back(D->IsExplicitSpecified);
1042 Code = serialization::DECL_CXX_CONVERSION;
1045 void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
1047 Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
1048 ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1049 Record.push_back(!IdentifierLocs.empty());
1050 if (IdentifierLocs.empty()) {
1051 Writer.AddSourceLocation(D->getLocEnd(), Record);
1052 Record.push_back(1);
1054 for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1055 Writer.AddSourceLocation(IdentifierLocs[I], Record);
1056 Record.push_back(IdentifierLocs.size());
1058 // Note: the number of source locations must always be the last element in
1060 Code = serialization::DECL_IMPORT;
1063 void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1065 Writer.AddSourceLocation(D->getColonLoc(), Record);
1066 Code = serialization::DECL_ACCESS_SPEC;
1069 void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
1070 // Record the number of friend type template parameter lists here
1071 // so as to simplify memory allocation during deserialization.
1072 Record.push_back(D->NumTPLists);
1074 bool hasFriendDecl = D->Friend.is<NamedDecl*>();
1075 Record.push_back(hasFriendDecl);
1077 Writer.AddDeclRef(D->getFriendDecl(), Record);
1079 Writer.AddTypeSourceInfo(D->getFriendType(), Record);
1080 for (unsigned i = 0; i < D->NumTPLists; ++i)
1081 Writer.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i),
1083 Writer.AddDeclRef(D->getNextFriend(), Record);
1084 Record.push_back(D->UnsupportedFriend);
1085 Writer.AddSourceLocation(D->FriendLoc, Record);
1086 Code = serialization::DECL_FRIEND;
1089 void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1091 Record.push_back(D->getNumTemplateParameters());
1092 for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1093 Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record);
1094 Record.push_back(D->getFriendDecl() != 0);
1095 if (D->getFriendDecl())
1096 Writer.AddDeclRef(D->getFriendDecl(), Record);
1098 Writer.AddTypeSourceInfo(D->getFriendType(), Record);
1099 Writer.AddSourceLocation(D->getFriendLoc(), Record);
1100 Code = serialization::DECL_FRIEND_TEMPLATE;
1103 void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
1106 Writer.AddDeclRef(D->getTemplatedDecl(), Record);
1107 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1110 void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1111 VisitRedeclarable(D);
1113 // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1114 // getCommonPtr() can be used while this is still initializing.
1115 if (D->isFirstDecl()) {
1116 // This declaration owns the 'common' pointer, so serialize that data now.
1117 Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record);
1118 if (D->getInstantiatedFromMemberTemplate())
1119 Record.push_back(D->isMemberSpecialization());
1122 VisitTemplateDecl(D);
1123 Record.push_back(D->getIdentifierNamespace());
1126 void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1127 VisitRedeclarableTemplateDecl(D);
1129 if (D->isFirstDecl()) {
1130 typedef llvm::FoldingSetVector<ClassTemplateSpecializationDecl> CTSDSetTy;
1131 CTSDSetTy &CTSDSet = D->getSpecializations();
1132 Record.push_back(CTSDSet.size());
1133 for (CTSDSetTy::iterator I=CTSDSet.begin(), E = CTSDSet.end(); I!=E; ++I) {
1134 assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1135 Writer.AddDeclRef(&*I, Record);
1138 typedef llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
1140 CTPSDSetTy &CTPSDSet = D->getPartialSpecializations();
1141 Record.push_back(CTPSDSet.size());
1142 for (CTPSDSetTy::iterator I=CTPSDSet.begin(), E=CTPSDSet.end(); I!=E; ++I) {
1143 assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1144 Writer.AddDeclRef(&*I, Record);
1147 Writer.AddTypeRef(D->getCommonPtr()->InjectedClassNameType, Record);
1149 Code = serialization::DECL_CLASS_TEMPLATE;
1152 void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
1153 ClassTemplateSpecializationDecl *D) {
1154 VisitCXXRecordDecl(D);
1156 llvm::PointerUnion<ClassTemplateDecl *,
1157 ClassTemplatePartialSpecializationDecl *> InstFrom
1158 = D->getSpecializedTemplateOrPartial();
1159 if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
1160 Writer.AddDeclRef(InstFromD, Record);
1162 Writer.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>(),
1164 Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record);
1167 Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record);
1168 Writer.AddSourceLocation(D->getPointOfInstantiation(), Record);
1169 Record.push_back(D->getSpecializationKind());
1170 Record.push_back(D->isCanonicalDecl());
1172 if (D->isCanonicalDecl()) {
1173 // When reading, we'll add it to the folding set of the following template.
1174 Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record);
1178 Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record);
1179 if (D->getTypeAsWritten()) {
1180 Writer.AddSourceLocation(D->getExternLoc(), Record);
1181 Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record);
1184 Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
1187 void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
1188 ClassTemplatePartialSpecializationDecl *D) {
1189 VisitClassTemplateSpecializationDecl(D);
1191 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1192 Writer.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten(), Record);
1194 // These are read/set from/to the first declaration.
1195 if (D->getPreviousDecl() == 0) {
1196 Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);
1197 Record.push_back(D->isMemberSpecialization());
1200 Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
1203 void ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) {
1204 VisitRedeclarableTemplateDecl(D);
1206 if (D->isFirstDecl()) {
1207 typedef llvm::FoldingSetVector<VarTemplateSpecializationDecl> VTSDSetTy;
1208 VTSDSetTy &VTSDSet = D->getSpecializations();
1209 Record.push_back(VTSDSet.size());
1210 for (VTSDSetTy::iterator I = VTSDSet.begin(), E = VTSDSet.end(); I != E;
1212 assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1213 Writer.AddDeclRef(&*I, Record);
1216 typedef llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>
1218 VTPSDSetTy &VTPSDSet = D->getPartialSpecializations();
1219 Record.push_back(VTPSDSet.size());
1220 for (VTPSDSetTy::iterator I = VTPSDSet.begin(), E = VTPSDSet.end(); I != E;
1222 assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1223 Writer.AddDeclRef(&*I, Record);
1226 Code = serialization::DECL_VAR_TEMPLATE;
1229 void ASTDeclWriter::VisitVarTemplateSpecializationDecl(
1230 VarTemplateSpecializationDecl *D) {
1233 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
1234 InstFrom = D->getSpecializedTemplateOrPartial();
1235 if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) {
1236 Writer.AddDeclRef(InstFromD, Record);
1238 Writer.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl *>(),
1240 Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record);
1244 Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record);
1245 if (D->getTypeAsWritten()) {
1246 Writer.AddSourceLocation(D->getExternLoc(), Record);
1247 Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record);
1250 Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record);
1251 Writer.AddSourceLocation(D->getPointOfInstantiation(), Record);
1252 Record.push_back(D->getSpecializationKind());
1253 Record.push_back(D->isCanonicalDecl());
1255 if (D->isCanonicalDecl()) {
1256 // When reading, we'll add it to the folding set of the following template.
1257 Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record);
1260 Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION;
1263 void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl(
1264 VarTemplatePartialSpecializationDecl *D) {
1265 VisitVarTemplateSpecializationDecl(D);
1267 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1268 Writer.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten(), Record);
1270 // These are read/set from/to the first declaration.
1271 if (D->getPreviousDecl() == 0) {
1272 Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);
1273 Record.push_back(D->isMemberSpecialization());
1276 Code = serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION;
1279 void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
1280 ClassScopeFunctionSpecializationDecl *D) {
1282 Writer.AddDeclRef(D->getSpecialization(), Record);
1283 Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
1287 void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1288 VisitRedeclarableTemplateDecl(D);
1290 if (D->isFirstDecl()) {
1291 // This FunctionTemplateDecl owns the CommonPtr; write it.
1293 // Write the function specialization declarations.
1294 Record.push_back(D->getSpecializations().size());
1295 for (llvm::FoldingSetVector<FunctionTemplateSpecializationInfo>::iterator
1296 I = D->getSpecializations().begin(),
1297 E = D->getSpecializations().end() ; I != E; ++I) {
1298 assert(I->Function->isCanonicalDecl() &&
1299 "Expected only canonical decls in set");
1300 Writer.AddDeclRef(I->Function, Record);
1303 Code = serialization::DECL_FUNCTION_TEMPLATE;
1306 void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1309 Record.push_back(D->wasDeclaredWithTypename());
1310 Record.push_back(D->defaultArgumentWasInherited());
1311 Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record);
1313 Code = serialization::DECL_TEMPLATE_TYPE_PARM;
1316 void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1317 // For an expanded parameter pack, record the number of expansion types here
1318 // so that it's easier for deserialization to allocate the right amount of
1320 if (D->isExpandedParameterPack())
1321 Record.push_back(D->getNumExpansionTypes());
1323 VisitDeclaratorDecl(D);
1324 // TemplateParmPosition.
1325 Record.push_back(D->getDepth());
1326 Record.push_back(D->getPosition());
1328 if (D->isExpandedParameterPack()) {
1329 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1330 Writer.AddTypeRef(D->getExpansionType(I), Record);
1331 Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record);
1334 Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
1336 // Rest of NonTypeTemplateParmDecl.
1337 Record.push_back(D->isParameterPack());
1338 Record.push_back(D->getDefaultArgument() != 0);
1339 if (D->getDefaultArgument()) {
1340 Writer.AddStmt(D->getDefaultArgument());
1341 Record.push_back(D->defaultArgumentWasInherited());
1343 Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
1347 void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1348 // For an expanded parameter pack, record the number of expansion types here
1349 // so that it's easier for deserialization to allocate the right amount of
1351 if (D->isExpandedParameterPack())
1352 Record.push_back(D->getNumExpansionTemplateParameters());
1354 VisitTemplateDecl(D);
1355 // TemplateParmPosition.
1356 Record.push_back(D->getDepth());
1357 Record.push_back(D->getPosition());
1359 if (D->isExpandedParameterPack()) {
1360 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1362 Writer.AddTemplateParameterList(D->getExpansionTemplateParameters(I),
1364 Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
1366 // Rest of TemplateTemplateParmDecl.
1367 Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record);
1368 Record.push_back(D->defaultArgumentWasInherited());
1369 Record.push_back(D->isParameterPack());
1370 Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
1374 void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1375 VisitRedeclarableTemplateDecl(D);
1376 Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
1379 void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1381 Writer.AddStmt(D->getAssertExpr());
1382 Record.push_back(D->isFailed());
1383 Writer.AddStmt(D->getMessage());
1384 Writer.AddSourceLocation(D->getRParenLoc(), Record);
1385 Code = serialization::DECL_STATIC_ASSERT;
1388 /// \brief Emit the DeclContext part of a declaration context decl.
1390 /// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL
1391 /// block for this declaration context is stored. May be 0 to indicate
1392 /// that there are no declarations stored within this context.
1394 /// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE
1395 /// block for this declaration context is stored. May be 0 to indicate
1396 /// that there are no declarations visible from this context. Note
1397 /// that this value will not be emitted for non-primary declaration
1399 void ASTDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
1400 uint64_t VisibleOffset) {
1401 Record.push_back(LexicalOffset);
1402 Record.push_back(VisibleOffset);
1405 template <typename T>
1406 void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
1407 T *First = D->getFirstDecl();
1408 if (First->getMostRecentDecl() != First) {
1409 assert(isRedeclarableDeclKind(static_cast<T *>(D)->getKind()) &&
1410 "Not considered redeclarable?");
1412 // There is more than one declaration of this entity, so we will need to
1413 // write a redeclaration chain.
1414 Writer.AddDeclRef(First, Record);
1415 Writer.Redeclarations.insert(First);
1417 // Make sure that we serialize both the previous and the most-recent
1418 // declarations, which (transitively) ensures that all declarations in the
1419 // chain get serialized.
1420 (void)Writer.GetDeclRef(D->getPreviousDecl());
1421 (void)Writer.GetDeclRef(First->getMostRecentDecl());
1423 // We use the sentinel value 0 to indicate an only declaration.
1424 Record.push_back(0);
1429 void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
1430 Record.push_back(D->varlist_size());
1432 for (OMPThreadPrivateDecl::varlist_iterator I = D->varlist_begin(),
1433 E = D->varlist_end();
1436 Code = serialization::DECL_OMP_THREADPRIVATE;
1439 //===----------------------------------------------------------------------===//
1440 // ASTWriter Implementation
1441 //===----------------------------------------------------------------------===//
1443 void ASTWriter::WriteDeclsBlockAbbrevs() {
1444 using namespace llvm;
1448 // Abbreviation for DECL_FIELD
1449 Abv = new BitCodeAbbrev();
1450 Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
1452 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1453 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1454 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1455 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1456 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1457 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1458 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1459 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1460 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
1461 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1462 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1464 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1465 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1467 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1469 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1470 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1472 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1473 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth
1475 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1476 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1477 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1478 DeclFieldAbbrev = Stream.EmitAbbrev(Abv);
1480 // Abbreviation for DECL_OBJC_IVAR
1481 Abv = new BitCodeAbbrev();
1482 Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
1484 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1485 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1486 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1487 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1488 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1489 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1490 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1491 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1492 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
1493 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1494 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1496 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1497 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1499 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1501 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1502 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1504 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1505 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth
1507 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
1508 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
1509 // getBackingIvarReferencedInAccessor
1510 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1512 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1513 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1514 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1515 DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abv);
1517 // Abbreviation for DECL_ENUM
1518 Abv = new BitCodeAbbrev();
1519 Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
1521 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1523 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1524 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1525 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1526 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1527 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1528 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1529 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1530 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1531 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1532 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1533 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1535 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1536 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1538 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1539 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1541 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1542 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
1543 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1544 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1545 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1546 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
1547 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1548 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1549 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl
1551 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef
1552 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType
1553 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType
1554 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits
1555 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits
1556 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
1557 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
1558 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
1559 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum
1561 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
1562 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
1563 DeclEnumAbbrev = Stream.EmitAbbrev(Abv);
1565 // Abbreviation for DECL_RECORD
1566 Abv = new BitCodeAbbrev();
1567 Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
1569 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1571 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1572 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1573 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1574 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1575 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1576 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1577 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1578 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1579 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1580 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1581 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1583 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1584 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1586 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1587 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1589 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1590 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
1591 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1592 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1593 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1594 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
1595 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1596 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1597 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl
1599 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
1600 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
1601 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
1602 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember
1604 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
1605 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
1606 DeclRecordAbbrev = Stream.EmitAbbrev(Abv);
1608 // Abbreviation for DECL_PARM_VAR
1609 Abv = new BitCodeAbbrev();
1610 Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
1612 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1614 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1615 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1616 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1617 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1618 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1619 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1620 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1621 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1622 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1623 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1624 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1626 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1627 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1629 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1631 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1632 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1634 Abv->Add(BitCodeAbbrevOp(0)); // StorageClass
1635 Abv->Add(BitCodeAbbrevOp(0)); // getTSCSpec
1636 Abv->Add(BitCodeAbbrevOp(0)); // hasCXXDirectInitializer
1637 Abv->Add(BitCodeAbbrevOp(0)); // isExceptionVariable
1638 Abv->Add(BitCodeAbbrevOp(0)); // isNRVOVariable
1639 Abv->Add(BitCodeAbbrevOp(0)); // isCXXForRangeDecl
1640 Abv->Add(BitCodeAbbrevOp(0)); // isARCPseudoStrong
1641 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
1642 Abv->Add(BitCodeAbbrevOp(0)); // isInitCapture
1643 Abv->Add(BitCodeAbbrevOp(0)); // isPrevDeclInSameScope
1644 Abv->Add(BitCodeAbbrevOp(0)); // Linkage
1645 Abv->Add(BitCodeAbbrevOp(0)); // HasInit
1646 Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo
1648 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
1649 Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth
1650 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
1651 Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier
1652 Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted
1653 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg
1654 Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg
1656 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1657 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1658 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1659 DeclParmVarAbbrev = Stream.EmitAbbrev(Abv);
1661 // Abbreviation for DECL_TYPEDEF
1662 Abv = new BitCodeAbbrev();
1663 Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
1665 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1667 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1668 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1669 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1670 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1671 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1672 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1673 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1674 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1675 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1676 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1677 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1679 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1680 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1682 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1683 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1685 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1686 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1687 DeclTypedefAbbrev = Stream.EmitAbbrev(Abv);
1689 // Abbreviation for DECL_VAR
1690 Abv = new BitCodeAbbrev();
1691 Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
1693 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1695 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1696 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1697 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1698 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1699 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1700 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1701 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1702 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1703 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1704 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1705 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1707 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1708 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1710 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1712 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1713 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1715 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass
1716 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getTSCSpec
1717 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer
1718 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
1719 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
1720 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
1721 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
1722 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
1723 Abv->Add(BitCodeAbbrevOp(0)); // isInitCapture
1724 Abv->Add(BitCodeAbbrevOp(0)); // isPrevDeclInSameScope
1725 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
1726 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasInit
1727 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasMemberSpecInfo
1729 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1730 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1731 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1732 DeclVarAbbrev = Stream.EmitAbbrev(Abv);
1734 // Abbreviation for EXPR_DECL_REF
1735 Abv = new BitCodeAbbrev();
1736 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
1739 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1740 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1741 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1742 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1743 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1744 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1745 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1747 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
1748 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
1749 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
1750 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
1751 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //RefersToEnclosingLocal
1752 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
1753 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1754 DeclRefExprAbbrev = Stream.EmitAbbrev(Abv);
1756 // Abbreviation for EXPR_INTEGER_LITERAL
1757 Abv = new BitCodeAbbrev();
1758 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
1761 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1762 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1763 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1764 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1765 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1766 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1767 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1769 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1770 Abv->Add(BitCodeAbbrevOp(32)); // Bit Width
1771 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
1772 IntegerLiteralAbbrev = Stream.EmitAbbrev(Abv);
1774 // Abbreviation for EXPR_CHARACTER_LITERAL
1775 Abv = new BitCodeAbbrev();
1776 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
1779 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1780 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1781 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1782 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1783 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1784 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1785 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1787 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
1788 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1789 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getKind
1790 CharacterLiteralAbbrev = Stream.EmitAbbrev(Abv);
1792 Abv = new BitCodeAbbrev();
1793 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
1794 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1795 DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abv);
1797 Abv = new BitCodeAbbrev();
1798 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
1799 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1800 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1801 DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abv);
1804 /// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
1805 /// consumers of the AST.
1807 /// Such decls will always be deserialized from the AST file, so we would like
1808 /// this to be as restrictive as possible. Currently the predicate is driven by
1809 /// code generation requirements, if other clients have a different notion of
1810 /// what is "required" then we may have to consider an alternate scheme where
1811 /// clients can iterate over the top-level decls and get information on them,
1812 /// without necessary deserializing them. We could explicitly require such
1813 /// clients to use a separate API call to "realize" the decl. This should be
1814 /// relatively painless since they would presumably only do it for top-level
1816 static bool isRequiredDecl(const Decl *D, ASTContext &Context) {
1817 // An ObjCMethodDecl is never considered as "required" because its
1818 // implementation container always is.
1820 // File scoped assembly or obj-c implementation must be seen.
1821 if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D))
1824 return Context.DeclMustBeEmitted(D);
1827 void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
1828 // Switch case IDs are per Decl.
1829 ClearSwitchCaseIDs();
1832 ASTDeclWriter W(*this, Context, Record);
1834 // Determine the ID for this declaration.
1835 serialization::DeclID ID;
1836 if (D->isFromASTFile())
1839 serialization::DeclID &IDR = DeclIDs[D];
1846 bool isReplacingADecl = ID < FirstDeclID;
1848 // If this declaration is also a DeclContext, write blocks for the
1849 // declarations that lexically stored inside its context and those
1850 // declarations that are visible from its context. These blocks
1851 // are written before the declaration itself so that we can put
1852 // their offsets into the record for the declaration.
1853 uint64_t LexicalOffset = 0;
1854 uint64_t VisibleOffset = 0;
1855 DeclContext *DC = dyn_cast<DeclContext>(D);
1857 if (isReplacingADecl) {
1858 // It is replacing a decl from a chained PCH; make sure that the
1859 // DeclContext is fully loaded.
1860 if (DC->hasExternalLexicalStorage())
1861 DC->LoadLexicalDeclsFromExternalStorage();
1862 if (DC->hasExternalVisibleStorage())
1863 Chain->completeVisibleDeclsMap(DC);
1865 LexicalOffset = WriteDeclContextLexicalBlock(Context, DC);
1866 VisibleOffset = WriteDeclContextVisibleBlock(Context, DC);
1869 if (isReplacingADecl) {
1870 // We're replacing a decl in a previous file.
1871 ReplacedDecls.push_back(ReplacedDeclInfo(ID, Stream.GetCurrentBitNo(),
1874 unsigned Index = ID - FirstDeclID;
1876 // Record the offset for this declaration
1877 SourceLocation Loc = D->getLocation();
1878 if (DeclOffsets.size() == Index)
1879 DeclOffsets.push_back(DeclOffset(Loc, Stream.GetCurrentBitNo()));
1880 else if (DeclOffsets.size() < Index) {
1881 DeclOffsets.resize(Index+1);
1882 DeclOffsets[Index].setLocation(Loc);
1883 DeclOffsets[Index].BitOffset = Stream.GetCurrentBitNo();
1886 SourceManager &SM = Context.getSourceManager();
1887 if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
1888 associateDeclWithFile(D, ID);
1891 // Build and emit a record for this declaration
1893 W.Code = (serialization::DeclCode)0;
1896 if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset);
1899 llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
1900 D->getDeclKindName() + "'");
1901 Stream.EmitRecord(W.Code, Record, W.AbbrevToUse);
1903 // Flush any expressions that were written as part of this declaration.
1906 // Flush C++ base specifiers, if there are any.
1907 FlushCXXBaseSpecifiers();
1909 // Note "external" declarations so that we can add them to a record in the
1912 // FIXME: This should be renamed, the predicate is much more complicated.
1913 if (isRequiredDecl(D, Context))
1914 ExternalDefinitions.push_back(ID);