Lines Matching full:d
52 uint64_t Emit(Decl *D) {
55 D->getDeclKindName() + "'");
59 void Visit(Decl *D);
61 void VisitDecl(Decl *D);
62 void VisitPragmaCommentDecl(PragmaCommentDecl *D);
63 void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
64 void VisitTranslationUnitDecl(TranslationUnitDecl *D);
65 void VisitNamedDecl(NamedDecl *D);
67 void VisitNamespaceDecl(NamespaceDecl *D);
68 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
69 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
70 void VisitTypeDecl(TypeDecl *D);
71 void VisitTypedefNameDecl(TypedefNameDecl *D);
72 void VisitTypedefDecl(TypedefDecl *D);
73 void VisitTypeAliasDecl(TypeAliasDecl *D);
74 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
75 void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);
76 void VisitTagDecl(TagDecl *D);
77 void VisitEnumDecl(EnumDecl *D);
78 void VisitRecordDecl(RecordDecl *D);
79 void VisitCXXRecordDecl(CXXRecordDecl *D);
81 ClassTemplateSpecializationDecl *D);
83 ClassTemplatePartialSpecializationDecl *D);
84 void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
86 VarTemplatePartialSpecializationDecl *D);
87 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
88 void VisitValueDecl(ValueDecl *D);
89 void VisitEnumConstantDecl(EnumConstantDecl *D);
90 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
91 void VisitDeclaratorDecl(DeclaratorDecl *D);
92 void VisitFunctionDecl(FunctionDecl *D);
93 void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
94 void VisitCXXMethodDecl(CXXMethodDecl *D);
95 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
96 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
97 void VisitCXXConversionDecl(CXXConversionDecl *D);
98 void VisitFieldDecl(FieldDecl *D);
99 void VisitMSPropertyDecl(MSPropertyDecl *D);
100 void VisitMSGuidDecl(MSGuidDecl *D);
101 void VisitUnnamedGlobalConstantDecl(UnnamedGlobalConstantDecl *D);
102 void VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D);
103 void VisitIndirectFieldDecl(IndirectFieldDecl *D);
104 void VisitVarDecl(VarDecl *D);
105 void VisitImplicitParamDecl(ImplicitParamDecl *D);
106 void VisitParmVarDecl(ParmVarDecl *D);
107 void VisitDecompositionDecl(DecompositionDecl *D);
108 void VisitBindingDecl(BindingDecl *D);
109 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
110 void VisitTemplateDecl(TemplateDecl *D);
111 void VisitConceptDecl(ConceptDecl *D);
113 ImplicitConceptSpecializationDecl *D);
114 void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D);
115 void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
116 void VisitClassTemplateDecl(ClassTemplateDecl *D);
117 void VisitVarTemplateDecl(VarTemplateDecl *D);
118 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
119 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
120 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
121 void VisitUsingDecl(UsingDecl *D);
122 void VisitUsingEnumDecl(UsingEnumDecl *D);
123 void VisitUsingPackDecl(UsingPackDecl *D);
124 void VisitUsingShadowDecl(UsingShadowDecl *D);
125 void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
126 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
127 void VisitExportDecl(ExportDecl *D);
128 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
129 void VisitTopLevelStmtDecl(TopLevelStmtDecl *D);
130 void VisitImportDecl(ImportDecl *D);
131 void VisitAccessSpecDecl(AccessSpecDecl *D);
132 void VisitFriendDecl(FriendDecl *D);
133 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
134 void VisitStaticAssertDecl(StaticAssertDecl *D);
135 void VisitBlockDecl(BlockDecl *D);
136 void VisitCapturedDecl(CapturedDecl *D);
137 void VisitEmptyDecl(EmptyDecl *D);
138 void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
140 template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
141 void VisitHLSLBufferDecl(HLSLBufferDecl *D);
144 void VisitObjCMethodDecl(ObjCMethodDecl *D);
145 void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
146 void VisitObjCContainerDecl(ObjCContainerDecl *D);
147 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
148 void VisitObjCIvarDecl(ObjCIvarDecl *D);
149 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
150 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
151 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
152 void VisitObjCImplDecl(ObjCImplDecl *D);
153 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
154 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
155 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
156 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
157 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
158 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
159 void VisitOMPAllocateDecl(OMPAllocateDecl *D);
160 void VisitOMPRequiresDecl(OMPRequiresDecl *D);
161 void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
162 void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
163 void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
182 /// provides a declaration of D. The intent is to provide a sufficient
184 void AddFirstDeclFromEachModule(const Decl *D, bool IncludeLocal) {
187 for (const Decl *R = D->getMostRecentDecl(); R; R = R->getPreviousDecl()) {
214 void AddTemplateSpecializations(DeclTy *D) {
215 auto *Common = D->getCommonPtr();
222 D->LoadLazySpecializations();
242 for (auto *D : Specs) {
243 assert(D->isCanonicalDecl() && "non-canonical decl in set");
244 AddFirstDeclFromEachModule(D, /*IncludeLocal*/true);
278 bool clang::CanElideDeclDef(const Decl *D) {
279 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
290 if (auto *VD = dyn_cast<VarDecl>(D)) {
306 void ASTDeclWriter::Visit(Decl *D) {
307 DeclVisitor<ASTDeclWriter>::Visit(D);
312 if (auto *DD = dyn_cast<DeclaratorDecl>(D)) {
320 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
333 if (auto *VD = dyn_cast<VarDecl>(D)) {
342 if (auto *FD = dyn_cast<FieldDecl>(D)) {
357 if (auto *DC = dyn_cast<DeclContext>(D))
361 void ASTDeclWriter::VisitDecl(Decl *D) {
373 DeclBits.addBits((uint64_t)D->getModuleOwnershipKind(), /*BitWidth=*/3);
374 DeclBits.addBit(D->isReferenced());
375 DeclBits.addBit(D->isUsed(false));
376 DeclBits.addBits(D->getAccess(), /*BitWidth=*/2);
377 DeclBits.addBit(D->isImplicit());
378 DeclBits.addBit(D->getDeclContext() != D->getLexicalDeclContext());
379 DeclBits.addBit(D->hasAttrs());
380 DeclBits.addBit(D->isTopLevelDeclInObjCContainer());
381 DeclBits.addBit(D->isInvalidDecl());
384 Record.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()));
385 if (D->getDeclContext() != D->getLexicalDeclContext())
386 Record.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()));
388 if (D->hasAttrs())
389 Record.AddAttributes(D->getAttrs());
391 Record.push_back(Writer.getSubmoduleID(D->getOwningModule()));
401 if (D->isOutOfLine()) {
402 auto *DC = D->getDeclContext();
414 void ASTDeclWriter::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
415 StringRef Arg = D->getArg();
417 VisitDecl(D);
418 Record.AddSourceLocation(D->getBeginLoc());
419 Record.push_back(D->getCommentKind());
425 PragmaDetectMismatchDecl *D) {
426 StringRef Name = D->getName();
427 StringRef Value = D->getValue();
429 VisitDecl(D);
430 Record.AddSourceLocation(D->getBeginLoc());
436 void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
440 void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
441 VisitDecl(D);
442 Record.AddDeclarationName(D->getDeclName());
443 Record.push_back(needsAnonymousDeclarationNumber(D)
444 ? Writer.getAnonymousDeclarationNumber(D)
448 void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
449 VisitNamedDecl(D);
450 Record.AddSourceLocation(D->getBeginLoc());
451 Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
454 void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
455 VisitRedeclarable(D);
456 VisitTypeDecl(D);
457 Record.AddTypeSourceInfo(D->getTypeSourceInfo());
458 Record.push_back(D->isModed());
459 if (D->isModed())
460 Record.AddTypeRef(D->getUnderlyingType());
461 Record.AddDeclRef(D->getAnonDeclWithTypedefName(false));
464 void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
465 VisitTypedefNameDecl(D);
466 if (D->getDeclContext() == D->getLexicalDeclContext() &&
467 !D->hasAttrs() &&
468 !D->isImplicit() &&
469 D->getFirstDecl() == D->getMostRecentDecl() &&
470 !D->isInvalidDecl() &&
471 !D->isTopLevelDeclInObjCContainer() &&
472 !D->isModulePrivate() &&
473 !needsAnonymousDeclarationNumber(D) &&
474 D->getDeclName().getNameKind() == DeclarationName::Identifier)
480 void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
481 VisitTypedefNameDecl(D);
482 Record.AddDeclRef(D->getDescribedAliasTemplate());
486 void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
491 VisitRedeclarable(D);
492 VisitTypeDecl(D);
493 Record.push_back(D->getIdentifierNamespace());
496 TagDeclBits.addBits(llvm::to_underlying(D->getTagKind()), /*BitWidth=*/3);
497 TagDeclBits.addBit(!isa<CXXRecordDecl>(D) ? D->isCompleteDefinition() : 0);
498 TagDeclBits.addBit(D->isEmbeddedInDeclarator());
499 TagDeclBits.addBit(D->isFreeStanding());
500 TagDeclBits.addBit(D->isCompleteDefinitionRequired());
502 D->hasExtInfo() ? 1 : (D->getTypedefNameForAnonDecl() ? 2 : 0),
506 Record.AddSourceRange(D->getBraceRange());
508 if (D->hasExtInfo()) {
509 Record.AddQualifierInfo(*D->getExtInfo());
510 } else if (auto *TD = D->getTypedefNameForAnonDecl()) {
516 void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
521 VisitTagDecl(D);
522 Record.AddTypeSourceInfo(D->getIntegerTypeSourceInfo());
523 if (!D->getIntegerTypeSourceInfo())
524 Record.AddTypeRef(D->getIntegerType());
525 Record.AddTypeRef(D->getPromotionType());
528 EnumDeclBits.addBits(D->getNumPositiveBits(), /*BitWidth=*/8);
529 EnumDeclBits.addBits(D->getNumNegativeBits(), /*BitWidth=*/8);
530 EnumDeclBits.addBit(D->isScoped());
531 EnumDeclBits.addBit(D->isScopedUsingClassTag());
532 EnumDeclBits.addBit(D->isFixed());
535 Record.push_back(D->getODRHash());
537 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
545 if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
546 !D->isInvalidDecl() && !D->isImplicit() && !D->hasExtInfo() &&
547 !D->getTypedefNameForAnonDecl() &&
548 D->getFirstDecl() == D->getMostRecentDecl() &&
549 !D->isTopLevelDeclInObjCContainer() &&
550 !CXXRecordDecl::classofKind(D->getKind()) &&
551 !D->getIntegerTypeSourceInfo() && !D->getMemberSpecializationInfo() &&
552 !needsAnonymousDeclarationNumber(D) &&
553 D->getDeclName().getNameKind() == DeclarationName::Identifier)
559 void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
564 VisitTagDecl(D);
567 RecordDeclBits.addBit(D->hasFlexibleArrayMember());
568 RecordDeclBits.addBit(D->isAnonymousStructOrUnion());
569 RecordDeclBits.addBit(D->hasObjectMember());
570 RecordDeclBits.addBit(D->hasVolatileMember());
571 RecordDeclBits.addBit(D->isNonTrivialToPrimitiveDefaultInitialize());
572 RecordDeclBits.addBit(D->isNonTrivialToPrimitiveCopy());
573 RecordDeclBits.addBit(D->isNonTrivialToPrimitiveDestroy());
574 RecordDeclBits.addBit(D->hasNonTrivialToPrimitiveDefaultInitializeCUnion());
575 RecordDeclBits.addBit(D->hasNonTrivialToPrimitiveDestructCUnion());
576 RecordDeclBits.addBit(D->hasNonTrivialToPrimitiveCopyCUnion());
577 RecordDeclBits.addBit(D->isParamDestroyedInCallee());
578 RecordDeclBits.addBits(llvm::to_underlying(D->getArgPassingRestrictions()), 2);
583 if (!isa<CXXRecordDecl>(D))
584 Record.push_back(D->getODRHash());
586 if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
587 !D->isImplicit() && !D->isInvalidDecl() && !D->hasExtInfo() &&
588 !D->getTypedefNameForAnonDecl() &&
589 D->getFirstDecl() == D->getMostRecentDecl() &&
590 !D->isTopLevelDeclInObjCContainer() &&
591 !CXXRecordDecl::classofKind(D->getKind()) &&
592 !needsAnonymousDeclarationNumber(D) &&
593 D->getDeclName().getNameKind() == DeclarationName::Identifier)
599 void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
600 VisitNamedDecl(D);
601 Record.AddTypeRef(D->getType());
604 void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
605 VisitValueDecl(D);
606 Record.push_back(D->getInitExpr()? 1 : 0);
607 if (D->getInitExpr())
608 Record.AddStmt(D->getInitExpr());
609 Record.AddAPSInt(D->getInitVal());
614 void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
615 VisitValueDecl(D);
616 Record.AddSourceLocation(D->getInnerLocStart());
617 Record.push_back(D->hasExtInfo());
618 if (D->hasExtInfo()) {
619 DeclaratorDecl::ExtInfo *Info = D->getExtInfo();
624 Record.AddTypeRef(D->getTypeSourceInfo() ? D->getTypeSourceInfo()->getType()
628 void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
633 VisitRedeclarable(D);
635 Record.push_back(D->getTemplatedKind());
636 switch (D->getTemplatedKind()) {
640 Record.AddDeclRef(D->getInstantiatedFromDecl());
643 Record.AddDeclRef(D->getDescribedFunctionTemplate());
646 MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
654 FTSInfo = D->getTemplateSpecializationInfo();
656 RegisterTemplateSpecialization(FTSInfo->getTemplate(), D);
682 if (D->isCanonicalDecl()) {
691 DFTSInfo = D->getDependentSpecializationInfo();
707 VisitDeclaratorDecl(D);
708 Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
709 Record.push_back(D->getIdentifierNamespace());
716 FunctionDeclBits.addBits(llvm::to_underlying(D->getLinkageInternal()), 3);
717 FunctionDeclBits.addBits((uint32_t)D->getStorageClass(), /*BitWidth=*/3);
718 FunctionDeclBits.addBit(D->isInlineSpecified());
719 FunctionDeclBits.addBit(D->isInlined());
720 FunctionDeclBits.addBit(D->hasSkippedBody());
721 FunctionDeclBits.addBit(D->isVirtualAsWritten());
722 FunctionDeclBits.addBit(D->isPureVirtual());
723 FunctionDeclBits.addBit(D->hasInheritedPrototype());
724 FunctionDeclBits.addBit(D->hasWrittenPrototype());
725 FunctionDeclBits.addBit(D->isDeletedBit());
726 FunctionDeclBits.addBit(D->isTrivial());
727 FunctionDeclBits.addBit(D->isTrivialForCall());
728 FunctionDeclBits.addBit(D->isDefaulted());
729 FunctionDeclBits.addBit(D->isExplicitlyDefaulted());
730 FunctionDeclBits.addBit(D->isIneligibleOrNotSelected());
731 FunctionDeclBits.addBits((uint64_t)(D->getConstexprKind()), /*BitWidth=*/2);
732 FunctionDeclBits.addBit(D->hasImplicitReturnZero());
733 FunctionDeclBits.addBit(D->isMultiVersion());
734 FunctionDeclBits.addBit(D->isLateTemplateParsed());
735 FunctionDeclBits.addBit(D->FriendConstraintRefersToEnclosingTemplate());
736 FunctionDeclBits.addBit(D->usesSEHTry());
739 Record.AddSourceLocation(D->getEndLoc());
740 if (D->isExplicitlyDefaulted())
741 Record.AddSourceLocation(D->getDefaultLoc());
743 Record.push_back(D->getODRHash());
745 if (D->isDefaulted() || D->isDeletedAsWritten()) {
746 if (auto *FDI = D->getDefalutedOrDeletedInfo()) {
764 Record.push_back(D->param_size());
765 for (auto *P : D->parameters())
780 void ASTDeclWriter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
781 addExplicitSpecifier(D->getExplicitSpecifier(), Record);
782 Record.AddDeclRef(D->Ctor);
783 VisitFunctionDecl(D);
784 Record.push_back(static_cast<unsigned char>(D->getDeductionCandidateKind()));
788 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
793 VisitNamedDecl(D);
796 bool HasBodyStuff = D->getBody() != nullptr;
799 Record.AddStmt(D->getBody());
801 Record.AddDeclRef(D->getSelfDecl());
802 Record.AddDeclRef(D->getCmdDecl());
803 Record.push_back(D->isInstanceMethod());
804 Record.push_back(D->isVariadic());
805 Record.push_back(D->isPropertyAccessor());
806 Record.push_back(D->isSynthesizedAccessorStub());
807 Record.push_back(D->isDefined());
808 Record.push_back(D->isOverriding());
809 Record.push_back(D->hasSkippedBody());
811 Record.push_back(D->isRedeclaration());
812 Record.push_back(D->hasRedeclaration());
813 if (D->hasRedeclaration()) {
814 assert(Context.getObjCMethodRedeclaration(D));
815 Record.AddDeclRef(Context.getObjCMethodRedeclaration(D));
819 Record.push_back(llvm::to_underlying(D->getImplementationControl()));
821 Record.push_back(D->getObjCDeclQualifier());
822 Record.push_back(D->hasRelatedResultType());
823 Record.AddTypeRef(D->getReturnType());
824 Record.AddTypeSourceInfo(D->getReturnTypeSourceInfo());
825 Record.AddSourceLocation(D->getEndLoc());
826 Record.push_back(D->param_size());
827 for (const auto *P : D->parameters())
830 Record.push_back(D->getSelLocsKind());
831 unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
832 SourceLocation *SelLocs = D->getStoredSelLocs();
840 void ASTDeclWriter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
841 VisitTypedefNameDecl(D);
842 Record.push_back(D->Variance);
843 Record.push_back(D->Index);
844 Record.AddSourceLocation(D->VarianceLoc);
845 Record.AddSourceLocation(D->ColonLoc);
850 void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
855 VisitNamedDecl(D);
856 Record.AddSourceLocation(D->getAtStartLoc());
857 Record.AddSourceRange(D->getAtEndRange());
861 void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
862 VisitRedeclarable(D);
863 VisitObjCContainerDecl(D);
864 Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
865 AddObjCTypeParamList(D->TypeParamList);
867 Record.push_back(D->isThisDeclarationADefinition());
868 if (D->isThisDeclarationADefinition()) {
870 ObjCInterfaceDecl::DefinitionData &Data = D->data();
872 Record.AddTypeSourceInfo(D->getSuperClassTInfo());
873 Record.AddSourceLocation(D->getEndOfDefinitionLoc());
875 Record.push_back(D->getODRHash());
879 for (const auto *P : D->protocols())
881 for (const auto &PL : D->protocol_locs())
893 if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
895 Writer.ObjCClassesWithCategories.insert(D);
906 void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
907 VisitFieldDecl(D);
909 Record.push_back(D->getAccessControl());
910 Record.push_back(D->getSynthesize());
912 if (D->getDeclContext() == D->getLexicalDeclContext() &&
913 !D->hasAttrs() &&
914 !D->isImplicit() &&
915 !D->isUsed(false) &&
916 !D->isInvalidDecl() &&
917 !D->isReferenced() &&
918 !D->isModulePrivate() &&
919 !D->getBitWidth() &&
920 !D->hasExtInfo() &&
921 D->getDeclName())
927 void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
928 VisitRedeclarable(D);
929 VisitObjCContainerDecl(D);
931 Record.push_back(D->isThisDeclarationADefinition());
932 if (D->isThisDeclarationADefinition()) {
933 Record.push_back(D->protocol_size());
934 for (const auto *I : D->protocols())
936 for (const auto &PL : D->protocol_locs())
938 Record.push_back(D->getODRHash());
944 void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
945 VisitFieldDecl(D);
949 void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
950 VisitObjCContainerDecl(D);
951 Record.AddSourceLocation(D->getCategoryNameLoc());
952 Record.AddSourceLocation(D->getIvarLBraceLoc());
953 Record.AddSourceLocation(D->getIvarRBraceLoc());
954 Record.AddDeclRef(D->getClassInterface());
955 AddObjCTypeParamList(D->TypeParamList);
956 Record.push_back(D->protocol_size());
957 for (const auto *I : D->protocols())
959 for (const auto &PL : D->protocol_locs())
964 void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
965 VisitNamedDecl(D);
966 Record.AddDeclRef(D->getClassInterface());
970 void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
971 VisitNamedDecl(D);
972 Record.AddSourceLocation(D->getAtLoc());
973 Record.AddSourceLocation(D->getLParenLoc());
974 Record.AddTypeRef(D->getType());
975 Record.AddTypeSourceInfo(D->getTypeSourceInfo());
977 Record.push_back((unsigned)D->getPropertyAttributes());
978 Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
980 Record.push_back((unsigned)D->getPropertyImplementation());
981 Record.AddDeclarationName(D->getGetterName());
982 Record.AddSourceLocation(D->getGetterNameLoc());
983 Record.AddDeclarationName(D->getSetterName());
984 Record.AddSourceLocation(D->getSetterNameLoc());
985 Record.AddDeclRef(D->getGetterMethodDecl());
986 Record.AddDeclRef(D->getSetterMethodDecl());
987 Record.AddDeclRef(D->getPropertyIvarDecl());
991 void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
992 VisitObjCContainerDecl(D);
993 Record.AddDeclRef(D->getClassInterface());
997 void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
998 VisitObjCImplDecl(D);
999 Record.AddSourceLocation(D->getCategoryNameLoc());
1003 void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1004 VisitObjCImplDecl(D);
1005 Record.AddDeclRef(D->getSuperClass());
1006 Record.AddSourceLocation(D->getSuperClassLoc());
1007 Record.AddSourceLocation(D->getIvarLBraceLoc());
1008 Record.AddSourceLocation(D->getIvarRBraceLoc());
1009 Record.push_back(D->hasNonZeroConstructors());
1010 Record.push_back(D->hasDestructors());
1011 Record.push_back(D->NumIvarInitializers);
1012 if (D->NumIvarInitializers)
1014 llvm::ArrayRef(D->init_begin(), D->init_end()));
1018 void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
1019 VisitDecl(D);
1020 Record.AddSourceLocation(D->getBeginLoc());
1021 Record.AddDeclRef(D->getPropertyDecl());
1022 Record.AddDeclRef(D->getPropertyIvarDecl());
1023 Record.AddSourceLocation(D->getPropertyIvarDeclLoc());
1024 Record.AddDeclRef(D->getGetterMethodDecl());
1025 Record.AddDeclRef(D->getSetterMethodDecl());
1026 Record.AddStmt(D->getGetterCXXConstructor());
1027 Record.AddStmt(D->getSetterCXXAssignment());
1031 void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
1032 VisitDeclaratorDecl(D);
1033 Record.push_back(D->isMutable());
1035 Record.push_back((D->StorageKind << 1) | D->BitField);
1036 if (D->StorageKind == FieldDecl::ISK_CapturedVLAType)
1037 Record.AddTypeRef(QualType(D->getCapturedVLAType(), 0));
1038 else if (D->BitField)
1039 Record.AddStmt(D->getBitWidth());
1041 if (!D->getDeclName())
1042 Record.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D));
1044 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1045 !D->hasAttrs() &&
1046 !D->isImplicit() &&
1047 !D->isUsed(false) &&
1048 !D->isInvalidDecl() &&
1049 !D->isReferenced() &&
1050 !D->isTopLevelDeclInObjCContainer() &&
1051 !D->isModulePrivate() &&
1052 !D->getBitWidth() &&
1053 !D->hasInClassInitializer() &&
1054 !D->hasCapturedVLAType() &&
1055 !D->hasExtInfo() &&
1056 !ObjCIvarDecl::classofKind(D->getKind()) &&
1057 !ObjCAtDefsFieldDecl::classofKind(D->getKind()) &&
1058 D->getDeclName())
1064 void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
1065 VisitDeclaratorDecl(D);
1066 Record.AddIdentifierRef(D->getGetterId());
1067 Record.AddIdentifierRef(D->getSetterId());
1071 void ASTDeclWriter::VisitMSGuidDecl(MSGuidDecl *D) {
1072 VisitValueDecl(D);
1073 MSGuidDecl::Parts Parts = D->getParts();
1082 UnnamedGlobalConstantDecl *D) {
1083 VisitValueDecl(D);
1084 Record.AddAPValue(D->getValue());
1088 void ASTDeclWriter::VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) {
1089 VisitValueDecl(D);
1090 Record.AddAPValue(D->getValue());
1094 void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
1095 VisitValueDecl(D);
1096 Record.push_back(D->getChainingSize());
1098 for (const auto *P : D->chain())
1103 void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
1104 VisitRedeclarable(D);
1105 VisitDeclaratorDecl(D);
1111 VarDeclBits.addBits(llvm::to_underlying(D->getLinkageInternal()),
1115 if (Writer.WritingModule && D->getStorageDuration() == SD_Static &&
1116 !D->getDescribedVarTemplate()) {
1123 (D->hasAttr<DLLExportAttr>() &&
1125 Writer.Context->GetGVALinkageForVariable(D) >= GVA_StrongExternal;
1129 VarDeclBits.addBits(D->getStorageClass(), /*BitWidth=*/3);
1130 VarDeclBits.addBits(D->getTSCSpec(), /*BitWidth=*/2);
1131 VarDeclBits.addBits(D->getInitStyle(), /*BitWidth=*/2);
1132 VarDeclBits.addBit(D->isARCPseudoStrong());
1135 if (!isa<ParmVarDecl>(D)) {
1136 VarDeclBits.addBit(D->isThisDeclarationADemotedDefinition());
1137 VarDeclBits.addBit(D->isExceptionVariable());
1138 VarDeclBits.addBit(D->isNRVOVariable());
1139 VarDeclBits.addBit(D->isCXXForRangeDecl());
1141 VarDeclBits.addBit(D->isInline());
1142 VarDeclBits.addBit(D->isInlineSpecified());
1143 VarDeclBits.addBit(D->isConstexpr());
1144 VarDeclBits.addBit(D->isInitCapture());
1145 VarDeclBits.addBit(D->isPreviousDeclInSameBlockScope());
1147 VarDeclBits.addBit(D->isEscapingByref());
1148 HasDeducedType = D->getType()->getContainedDeducedType();
1151 if (const auto *IPD = dyn_cast<ImplicitParamDecl>(D))
1157 VarDeclBits.addBit(D->isObjCForDecl());
1163 Writer.AddDeclRef(D, Writer.ModularCodegenDecls);
1165 if (D->hasAttr<BlocksAttr>()) {
1166 BlockVarCopyInit Init = Writer.Context->getBlockVarCopyInit(D);
1175 if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) {
1179 = D->getMemberSpecializationInfo()) {
1188 if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
1189 !D->isTopLevelDeclInObjCContainer() &&
1190 !needsAnonymousDeclarationNumber(D) &&
1191 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1192 !D->hasExtInfo() && D->getFirstDecl() == D->getMostRecentDecl() &&
1193 D->getKind() == Decl::Var && !D->isInline() && !D->isConstexpr() &&
1194 !D->isInitCapture() && !D->isPreviousDeclInSameBlockScope() &&
1195 !D->isEscapingByref() && !HasDeducedType &&
1196 D->getStorageDuration() != SD_Static && !D->getDescribedVarTemplate() &&
1197 !D->getMemberSpecializationInfo() && !D->isObjCForDecl() &&
1198 !isa<ImplicitParamDecl>(D) && !D->isEscapingByref())
1204 void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
1205 VisitVarDecl(D);
1209 void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
1210 VisitVarDecl(D);
1215 Record.push_back(D->getFunctionScopeIndex());
1218 ParmVarDeclBits.addBit(D->isObjCMethodParameter());
1219 ParmVarDeclBits.addBits(D->getFunctionScopeDepth(), /*BitsWidth=*/7);
1221 ParmVarDeclBits.addBits(D->getObjCDeclQualifier(), /*BitsWidth=*/7);
1222 ParmVarDeclBits.addBit(D->isKNRPromoted());
1223 ParmVarDeclBits.addBit(D->hasInheritedDefaultArg());
1224 ParmVarDeclBits.addBit(D->hasUninstantiatedDefaultArg());
1225 ParmVarDeclBits.addBit(D->getExplicitObjectParamThisLoc().isValid());
1228 if (D->hasUninstantiatedDefaultArg())
1229 Record.AddStmt(D->getUninstantiatedDefaultArg());
1230 if (D->getExplicitObjectParamThisLoc().isValid())
1231 Record.AddSourceLocation(D->getExplicitObjectParamThisLoc());
1237 if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
1238 !D->hasExtInfo() && D->getStorageClass() == 0 && !D->isInvalidDecl() &&
1239 !D->isTopLevelDeclInObjCContainer() &&
1240 D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
1241 D->getInit() == nullptr) // No default expr.
1246 assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS");
1247 assert(!D->isThisDeclarationADemotedDefinition()
1249 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
1250 assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
1251 assert(D->getPreviousDecl() == nullptr && "PARM_VAR_DECL can't be redecl");
1252 assert(!D->isStaticDataMember() &&
1256 void ASTDeclWriter::VisitDecompositionDecl(DecompositionDecl *D) {
1258 Record.push_back(D->bindings().size());
1260 VisitVarDecl(D);
1261 for (auto *B : D->bindings())
1266 void ASTDeclWriter::VisitBindingDecl(BindingDecl *D) {
1267 VisitValueDecl(D);
1268 Record.AddStmt(D->getBinding());
1272 void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
1273 VisitDecl(D);
1274 Record.AddStmt(D->getAsmString());
1275 Record.AddSourceLocation(D->getRParenLoc());
1279 void ASTDeclWriter::VisitTopLevelStmtDecl(TopLevelStmtDecl *D) {
1280 VisitDecl(D);
1281 Record.AddStmt(D->getStmt());
1285 void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
1286 VisitDecl(D);
1291 LifetimeExtendedTemporaryDecl *D) {
1292 VisitDecl(D);
1293 Record.AddDeclRef(D->getExtendingDecl());
1294 Record.AddStmt(D->getTemporaryExpr());
1295 Record.push_back(static_cast<bool>(D->getValue()));
1296 if (D->getValue())
1297 Record.AddAPValue(*D->getValue());
1298 Record.push_back(D->getManglingNumber());
1301 void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
1302 VisitDecl(D);
1303 Record.AddStmt(D->getBody());
1304 Record.AddTypeSourceInfo(D->getSignatureAsWritten());
1305 Record.push_back(D->param_size());
1306 for (ParmVarDecl *P : D->parameters())
1308 Record.push_back(D->isVariadic());
1309 Record.push_back(D->blockMissingReturnType());
1310 Record.push_back(D->isConversionFromLambda());
1311 Record.push_back(D->doesNotEscape());
1312 Record.push_back(D->canAvoidCopyToHeap());
1313 Record.push_back(D->capturesCXXThis());
1314 Record.push_back(D->getNumCaptures());
1315 for (const auto &capture : D->captures()) {
1341 void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1346 VisitDecl(D);
1347 Record.push_back(llvm::to_underlying(D->getLanguage()));
1348 Record.AddSourceLocation(D->getExternLoc());
1349 Record.AddSourceLocation(D->getRBraceLoc());
1353 void ASTDeclWriter::VisitExportDecl(ExportDecl *D) {
1354 VisitDecl(D);
1355 Record.AddSourceLocation(D->getRBraceLoc());
1359 void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
1360 VisitNamedDecl(D);
1361 Record.AddSourceLocation(D->getBeginLoc());
1366 void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
1367 VisitRedeclarable(D);
1368 VisitNamedDecl(D);
1371 NamespaceDeclBits.addBit(D->isInline());
1372 NamespaceDeclBits.addBit(D->isNested());
1375 Record.AddSourceLocation(D->getBeginLoc());
1376 Record.AddSourceLocation(D->getRBraceLoc());
1378 if (D->isFirstDecl())
1379 Record.AddDeclRef(D->getAnonymousNamespace());
1382 if (Writer.hasChain() && D->isAnonymousNamespace() &&
1383 D == D->getMostRecentDecl()) {
1389 D->getParent()->getRedeclContext()->getPrimaryContext());
1392 ASTWriter::DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, D));
1397 void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1398 VisitRedeclarable(D);
1399 VisitNamedDecl(D);
1400 Record.AddSourceLocation(D->getNamespaceLoc());
1401 Record.AddSourceLocation(D->getTargetNameLoc());
1402 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1403 Record.AddDeclRef(D->getNamespace());
1407 void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
1408 VisitNamedDecl(D);
1409 Record.AddSourceLocation(D->getUsingLoc());
1410 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1411 Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
1412 Record.AddDeclRef(D->FirstUsingShadow.getPointer());
1413 Record.push_back(D->hasTypename());
1414 Record.AddDeclRef(Context.getInstantiatedFromUsingDecl(D));
1418 void ASTDeclWriter::VisitUsingEnumDecl(UsingEnumDecl *D) {
1419 VisitNamedDecl(D);
1420 Record.AddSourceLocation(D->getUsingLoc());
1421 Record.AddSourceLocation(D->getEnumLoc());
1422 Record.AddTypeSourceInfo(D->getEnumType());
1423 Record.AddDeclRef(D->FirstUsingShadow.getPointer());
1424 Record.AddDeclRef(Context.getInstantiatedFromUsingEnumDecl(D));
1428 void ASTDeclWriter::VisitUsingPackDecl(UsingPackDecl *D) {
1429 Record.push_back(D->NumExpansions);
1430 VisitNamedDecl(D);
1431 Record.AddDeclRef(D->getInstantiatedFromUsingDecl());
1432 for (auto *E : D->expansions())
1437 void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
1438 VisitRedeclarable(D);
1439 VisitNamedDecl(D);
1440 Record.AddDeclRef(D->getTargetDecl());
1441 Record.push_back(D->getIdentifierNamespace());
1442 Record.AddDeclRef(D->UsingOrNextShadow);
1443 Record.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D));
1445 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1446 D->getFirstDecl() == D->getMostRecentDecl() && !D->hasAttrs() &&
1447 !needsAnonymousDeclarationNumber(D) &&
1448 D->getDeclName().getNameKind() == DeclarationName::Identifier)
1455 ConstructorUsingShadowDecl *D) {
1456 VisitUsingShadowDecl(D);
1457 Record.AddDeclRef(D->NominatedBaseClassShadowDecl);
1458 Record.AddDeclRef(D->ConstructedBaseClassShadowDecl);
1459 Record.push_back(D->IsVirtual);
1463 void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1464 VisitNamedDecl(D);
1465 Record.AddSourceLocation(D->getUsingLoc());
1466 Record.AddSourceLocation(D->getNamespaceKeyLocation());
1467 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1468 Record.AddDeclRef(D->getNominatedNamespace());
1469 Record.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()));
1473 void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1474 VisitValueDecl(D);
1475 Record.AddSourceLocation(D->getUsingLoc());
1476 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1477 Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
1478 Record.AddSourceLocation(D->getEllipsisLoc());
1483 UnresolvedUsingTypenameDecl *D) {
1484 VisitTypeDecl(D);
1485 Record.AddSourceLocation(D->getTypenameLoc());
1486 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1487 Record.AddSourceLocation(D->getEllipsisLoc());
1492 UnresolvedUsingIfExistsDecl *D) {
1493 VisitNamedDecl(D);
1497 void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
1498 VisitRecordDecl(D);
1506 if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
1510 = D->getMemberSpecializationInfo()) {
1515 } else if (D->isLambda()) {
1518 if (auto *Context = D->getLambdaContextDecl()) {
1520 Record.push_back(D->getLambdaIndexInContext());
1528 Record.push_back(D->isThisDeclarationADefinition());
1529 if (D->isThisDeclarationADefinition())
1530 Record.AddCXXDefinitionData(D);
1532 if (D->isCompleteDefinition() && D->isInNamedModule())
1533 Writer.AddDeclRef(D, Writer.ModularCodegenDecls);
1540 if (D->isCompleteDefinition())
1541 Record.AddDeclRef(Context.getCurrentKeyFunction(D));
1546 void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
1547 VisitFunctionDecl(D);
1548 if (D->isCanonicalDecl()) {
1549 Record.push_back(D->size_overridden_methods());
1550 for (const CXXMethodDecl *MD : D->overridden_methods())
1557 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1558 D->getFirstDecl() == D->getMostRecentDecl() && !D->isInvalidDecl() &&
1559 !D->hasAttrs() && !D->isTopLevelDeclInObjCContainer() &&
1560 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1561 !D->hasExtInfo() && !D->isExplicitlyDefaulted()) {
1562 if (D->getTemplatedKind() == FunctionDecl::TK_NonTemplate ||
1563 D->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate ||
1564 D->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization ||
1565 D->getTemplatedKind() == FunctionDecl::TK_DependentNonTemplate)
1566 AbbrevToUse = Writer.getDeclCXXMethodAbbrev(D->getTemplatedKind());
1567 else if (D->getTemplatedKind() ==
1570 D->getTemplateSpecializationInfo();
1577 AbbrevToUse = Writer.getDeclCXXMethodAbbrev(D->getTemplatedKind());
1579 } else if (D->getTemplatedKind() ==
1582 D->getDependentSpecializationInfo();
1584 AbbrevToUse = Writer.getDeclCXXMethodAbbrev(D->getTemplatedKind());
1591 void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1596 Record.push_back(D->getTrailingAllocKind());
1597 addExplicitSpecifier(D->getExplicitSpecifier(), Record);
1598 if (auto Inherited = D->getInheritedConstructor()) {
1603 VisitCXXMethodDecl(D);
1607 void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1608 VisitCXXMethodDecl(D);
1610 Record.AddDeclRef(D->getOperatorDelete());
1611 if (D->getOperatorDelete())
1612 Record.AddStmt(D->getOperatorDeleteThisArg());
1617 void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
1618 addExplicitSpecifier(D->getExplicitSpecifier(), Record);
1619 VisitCXXMethodDecl(D);
1623 void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
1624 VisitDecl(D);
1625 Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
1626 ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1629 Record.AddSourceLocation(D->getEndLoc());
1641 void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1642 VisitDecl(D);
1643 Record.AddSourceLocation(D->getColonLoc());
1647 void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
1650 Record.push_back(D->NumTPLists);
1651 VisitDecl(D);
1652 bool hasFriendDecl = D->Friend.is<NamedDecl*>();
1655 Record.AddDeclRef(D->getFriendDecl());
1657 Record.AddTypeSourceInfo(D->getFriendType());
1658 for (unsigned i = 0; i < D->NumTPLists; ++i)
1659 Record.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i));
1660 Record.AddDeclRef(D->getNextFriend());
1661 Record.push_back(D->UnsupportedFriend);
1662 Record.AddSourceLocation(D->FriendLoc);
1666 void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1667 VisitDecl(D);
1668 Record.push_back(D->getNumTemplateParameters());
1669 for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1670 Record.AddTemplateParameterList(D->getTemplateParameterList(i));
1671 Record.push_back(D->getFriendDecl() != nullptr);
1672 if (D->getFriendDecl())
1673 Record.AddDeclRef(D->getFriendDecl());
1675 Record.AddTypeSourceInfo(D->getFriendType());
1676 Record.AddSourceLocation(D->getFriendLoc());
1680 void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
1681 VisitNamedDecl(D);
1683 Record.AddTemplateParameterList(D->getTemplateParameters());
1684 Record.AddDeclRef(D->getTemplatedDecl());
1687 void ASTDeclWriter::VisitConceptDecl(ConceptDecl *D) {
1688 VisitTemplateDecl(D);
1689 Record.AddStmt(D->getConstraintExpr());
1694 ImplicitConceptSpecializationDecl *D) {
1695 Record.push_back(D->getTemplateArguments().size());
1696 VisitDecl(D);
1697 for (const TemplateArgument &Arg : D->getTemplateArguments())
1702 void ASTDeclWriter::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
1706 void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1707 VisitRedeclarable(D);
1711 if (D->isFirstDecl()) {
1713 Record.AddDeclRef(D->getInstantiatedFromMemberTemplate());
1714 if (D->getInstantiatedFromMemberTemplate())
1715 Record.push_back(D->isMemberSpecialization());
1718 VisitTemplateDecl(D);
1719 Record.push_back(D->getIdentifierNamespace());
1722 void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1723 VisitRedeclarableTemplateDecl(D);
1725 if (D->isFirstDecl())
1726 AddTemplateSpecializations(D);
1731 auto Name = Context.DeclarationNames.getCXXDeductionGuideName(D);
1732 for (auto *DG : D->getDeclContext()->noload_lookup(Name))
1740 ClassTemplateSpecializationDecl *D) {
1741 RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
1743 VisitCXXRecordDecl(D);
1747 = D->getSpecializedTemplateOrPartial();
1752 Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
1755 Record.AddTemplateArgumentList(&D->getTemplateArgs());
1756 Record.AddSourceLocation(D->getPointOfInstantiation());
1757 Record.push_back(D->getSpecializationKind());
1758 Record.push_back(D->isCanonicalDecl());
1760 if (D->isCanonicalDecl()) {
1762 Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
1766 D->getTemplateSpecializationKind() ==
1768 D->getTemplateSpecializationKind() == TSK_ExplicitInstantiationDefinition;
1771 Record.AddSourceLocation(D->getExternKeywordLoc());
1772 Record.AddSourceLocation(D->getTemplateKeywordLoc());
1776 D->getTemplateArgsAsWritten();
1785 ClassTemplatePartialSpecializationDecl *D) {
1786 Record.AddTemplateParameterList(D->getTemplateParameters());
1788 VisitClassTemplateSpecializationDecl(D);
1791 if (D->getPreviousDecl() == nullptr) {
1792 Record.AddDeclRef(D->getInstantiatedFromMember());
1793 Record.push_back(D->isMemberSpecialization());
1799 void ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) {
1800 VisitRedeclarableTemplateDecl(D);
1802 if (D->isFirstDecl())
1803 AddTemplateSpecializations(D);
1808 VarTemplateSpecializationDecl *D) {
1809 RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
1812 InstFrom = D->getSpecializedTemplateOrPartial();
1817 Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
1821 D->getTemplateSpecializationKind() ==
1823 D->getTemplateSpecializationKind() == TSK_ExplicitInstantiationDefinition;
1826 Record.AddSourceLocation(D->getExternKeywordLoc());
1827 Record.AddSourceLocation(D->getTemplateKeywordLoc());
1831 D->getTemplateArgsAsWritten();
1836 Record.AddTemplateArgumentList(&D->getTemplateArgs());
1837 Record.AddSourceLocation(D->getPointOfInstantiation());
1838 Record.push_back(D->getSpecializationKind());
1839 Record.push_back(D->IsCompleteDefinition);
1841 VisitVarDecl(D);
1843 Record.push_back(D->isCanonicalDecl());
1845 if (D->isCanonicalDecl()) {
1847 Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
1854 VarTemplatePartialSpecializationDecl *D) {
1855 Record.AddTemplateParameterList(D->getTemplateParameters());
1857 VisitVarTemplateSpecializationDecl(D);
1860 if (D->getPreviousDecl() == nullptr) {
1861 Record.AddDeclRef(D->getInstantiatedFromMember());
1862 Record.push_back(D->isMemberSpecialization());
1868 void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1869 VisitRedeclarableTemplateDecl(D);
1871 if (D->isFirstDecl())
1872 AddTemplateSpecializations(D);
1876 void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1877 Record.push_back(D->hasTypeConstraint());
1878 VisitTypeDecl(D);
1880 Record.push_back(D->wasDeclaredWithTypename());
1882 const TypeConstraint *TC = D->getTypeConstraint();
1890 Record.push_back(D->isExpandedParameterPack());
1891 if (D->isExpandedParameterPack())
1892 Record.push_back(D->getNumExpansionParameters());
1895 bool OwnsDefaultArg = D->hasDefaultArgument() &&
1896 !D->defaultArgumentWasInherited();
1899 Record.AddTemplateArgumentLoc(D->getDefaultArgument());
1901 if (!D->hasTypeConstraint() && !OwnsDefaultArg &&
1902 D->getDeclContext() == D->getLexicalDeclContext() &&
1903 !D->isInvalidDecl() && !D->hasAttrs() &&
1904 !D->isTopLevelDeclInObjCContainer() && !D->isImplicit() &&
1905 D->getDeclName().getNameKind() == DeclarationName::Identifier)
1911 void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1915 Expr *TypeConstraint = D->getPlaceholderTypeConstraint();
1917 if (D->isExpandedParameterPack())
1918 Record.push_back(D->getNumExpansionTypes());
1920 VisitDeclaratorDecl(D);
1922 Record.push_back(D->getDepth());
1923 Record.push_back(D->getPosition());
1927 if (D->isExpandedParameterPack()) {
1928 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1929 Record.AddTypeRef(D->getExpansionType(I));
1930 Record.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I));
1936 Record.push_back(D->isParameterPack());
1937 bool OwnsDefaultArg = D->hasDefaultArgument() &&
1938 !D->defaultArgumentWasInherited();
1941 Record.AddTemplateArgumentLoc(D->getDefaultArgument());
1946 void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1950 if (D->isExpandedParameterPack())
1951 Record.push_back(D->getNumExpansionTemplateParameters());
1953 VisitTemplateDecl(D);
1954 Record.push_back(D->wasDeclaredWithTypename());
1956 Record.push_back(D->getDepth());
1957 Record.push_back(D->getPosition());
1959 if (D->isExpandedParameterPack()) {
1960 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1962 Record.AddTemplateParameterList(D->getExpansionTemplateParameters(I));
1966 Record.push_back(D->isParameterPack());
1967 bool OwnsDefaultArg = D->hasDefaultArgument() &&
1968 !D->defaultArgumentWasInherited();
1971 Record.AddTemplateArgumentLoc(D->getDefaultArgument());
1976 void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1977 VisitRedeclarableTemplateDecl(D);
1981 void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1982 VisitDecl(D);
1983 Record.AddStmt(D->getAssertExpr());
1984 Record.push_back(D->isFailed());
1985 Record.AddStmt(D->getMessage());
1986 Record.AddSourceLocation(D->getRParenLoc());
2014 const Decl *ASTWriter::getFirstLocalDecl(const Decl *D) {
2015 assert(IsLocalDecl(D) && "expected a local declaration");
2017 const Decl *Canon = D->getCanonicalDecl();
2025 for (const Decl *Redecl = D; Redecl; Redecl = Redecl->getPreviousDecl())
2027 D = Redecl;
2028 return CacheEntry = D;
2032 void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
2033 T *First = D->getFirstDecl();
2035 T *DAsT = static_cast<T *>(D);
2047 // that all redeclarations visible to this module are before D in the
2082 (void)Writer.GetDeclRef(D->getPreviousDecl());
2090 void ASTDeclWriter::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
2091 VisitNamedDecl(D);
2092 VisitDeclContext(D);
2093 Record.push_back(D->isCBuffer());
2094 Record.AddSourceLocation(D->getLocStart());
2095 Record.AddSourceLocation(D->getLBraceLoc());
2096 Record.AddSourceLocation(D->getRBraceLoc());
2101 void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
2102 Record.writeOMPChildren(D->Data);
2103 VisitDecl(D);
2107 void ASTDeclWriter::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
2108 Record.writeOMPChildren(D->Data);
2109 VisitDecl(D);
2113 void ASTDeclWriter::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
2114 Record.writeOMPChildren(D->Data);
2115 VisitDecl(D);
2119 void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
2124 VisitValueDecl(D);
2125 Record.AddSourceLocation(D->getBeginLoc());
2126 Record.AddStmt(D->getCombinerIn());
2127 Record.AddStmt(D->getCombinerOut());
2128 Record.AddStmt(D->getCombiner());
2129 Record.AddStmt(D->getInitOrig());
2130 Record.AddStmt(D->getInitPriv());
2131 Record.AddStmt(D->getInitializer());
2132 Record.push_back(llvm::to_underlying(D->getInitializerKind()));
2133 Record.AddDeclRef(D->getPrevDeclInScope());
2137 void ASTDeclWriter::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
2138 Record.writeOMPChildren(D->Data);
2139 VisitValueDecl(D);
2140 Record.AddDeclarationName(D->getVarName());
2141 Record.AddDeclRef(D->getPrevDeclInScope());
2145 void ASTDeclWriter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
2146 VisitVarDecl(D);
2768 static bool isRequiredDecl(const Decl *D, ASTContext &Context,
2778 if (isa<PragmaCommentDecl, PragmaDetectMismatchDecl>(D))
2788 if (isa<FileScopeAsmDecl, TopLevelStmtDecl, ObjCImplDecl>(D))
2791 if (WritingModule && isPartOfPerModuleInitializer(D)) {
2797 return Context.DeclMustBeEmitted(D);
2800 void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
2801 PrettyDeclStackTraceEntry CrashInfo(Context, D, SourceLocation(),
2806 assert(!D->isFromASTFile() && "should not be emitting imported decl");
2807 LocalDeclID &IDR = DeclIDs[D];
2819 W.Visit(D);
2822 uint64_t Offset = W.Emit(D);
2825 SourceLocation Loc = D->getLocation();
2843 associateDeclWithFile(D, ID);
2847 if (isRequiredDecl(D, Context, WritingModule))
2848 AddDeclRef(D, EagerlyDeserializedDecls);