Lines Matching defs:D
159 void ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update,
163 const CXXRecordDecl *D, Decl *LambdaContext,
165 void MergeDefinitionData(CXXRecordDecl *D,
168 void MergeDefinitionData(ObjCInterfaceDecl *D,
171 void MergeDefinitionData(ObjCProtocolDecl *D,
180 unsigned Index, NamedDecl *D);
256 FindExistingResult findExisting(NamedDecl *D);
266 static void AddLazySpecializations(T *D,
272 ASTContext &C = D->getASTContext();
274 auto *&LazySpecializations = D->getCommonPtr()->LazySpecializations;
291 static Decl *getMostRecentDeclImpl(Redeclarable<DeclT> *D);
293 static Decl *getMostRecentDecl(Decl *D);
295 static void mergeInheritableAttributes(ASTReader &Reader, Decl *D,
300 Redeclarable<DeclT> *D, Decl *Previous,
303 static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous,
307 static void attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest);
309 static void attachLatestDecl(Decl *D, Decl *latest);
312 static void markIncompleteDeclChainImpl(Redeclarable<DeclT> *D);
316 void Visit(Decl *D);
318 void UpdateDecl(Decl *D, SmallVectorImpl<GlobalDeclID> &);
325 void VisitDecl(Decl *D);
326 void VisitPragmaCommentDecl(PragmaCommentDecl *D);
327 void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
331 void VisitNamespaceDecl(NamespaceDecl *D);
332 void VisitHLSLBufferDecl(HLSLBufferDecl *D);
333 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
334 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
339 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
340 void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);
345 RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
346 void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
348 ClassTemplateSpecializationDecl *D);
351 ClassTemplateSpecializationDecl *D) {
352 VisitClassTemplateSpecializationDeclImpl(D);
356 ClassTemplatePartialSpecializationDecl *D);
358 VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);
360 void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {
361 VisitVarTemplateSpecializationDeclImpl(D);
365 VarTemplatePartialSpecializationDecl *D);
366 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
369 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
373 void VisitCXXMethodDecl(CXXMethodDecl *D);
374 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
375 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
376 void VisitCXXConversionDecl(CXXConversionDecl *D);
379 void VisitMSGuidDecl(MSGuidDecl *D);
380 void VisitUnnamedGlobalConstantDecl(UnnamedGlobalConstantDecl *D);
381 void VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D);
383 RedeclarableResult VisitVarDeclImpl(VarDecl *D);
390 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
391 void VisitTemplateDecl(TemplateDecl *D);
392 void VisitConceptDecl(ConceptDecl *D);
394 ImplicitConceptSpecializationDecl *D);
395 void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D);
396 RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
397 void VisitClassTemplateDecl(ClassTemplateDecl *D);
398 void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
399 void VisitVarTemplateDecl(VarTemplateDecl *D);
400 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
401 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
402 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
403 void VisitUsingDecl(UsingDecl *D);
404 void VisitUsingEnumDecl(UsingEnumDecl *D);
405 void VisitUsingPackDecl(UsingPackDecl *D);
406 void VisitUsingShadowDecl(UsingShadowDecl *D);
407 void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
408 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
409 void VisitExportDecl(ExportDecl *D);
411 void VisitTopLevelStmtDecl(TopLevelStmtDecl *D);
412 void VisitImportDecl(ImportDecl *D);
413 void VisitAccessSpecDecl(AccessSpecDecl *D);
414 void VisitFriendDecl(FriendDecl *D);
415 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
416 void VisitStaticAssertDecl(StaticAssertDecl *D);
419 void VisitEmptyDecl(EmptyDecl *D);
420 void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
425 RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
428 void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl);
430 void mergeLambda(CXXRecordDecl *D, RedeclarableResult &Redecl,
433 void mergeRedeclarableTemplate(RedeclarableTemplateDecl *D,
437 void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
441 void mergeMergeable(Mergeable<T> *D);
443 void mergeMergeable(LifetimeExtendedTemporaryDecl *D);
445 void mergeTemplatePattern(RedeclarableTemplateDecl *D,
452 void VisitObjCMethodDecl(ObjCMethodDecl *D);
453 void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
454 void VisitObjCContainerDecl(ObjCContainerDecl *D);
455 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
456 void VisitObjCIvarDecl(ObjCIvarDecl *D);
457 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
458 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
459 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
460 void VisitObjCImplDecl(ObjCImplDecl *D);
461 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
462 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
463 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
464 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
465 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
466 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
467 void VisitOMPAllocateDecl(OMPAllocateDecl *D);
468 void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
469 void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
470 void VisitOMPRequiresDecl(OMPRequiresDecl *D);
471 void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
517 merged_redecls(DeclT *D) {
518 return llvm::make_range(MergedRedeclIterator<DeclT>(D),
541 void ASTDeclReader::Visit(Decl *D) {
542 DeclVisitor<ASTDeclReader, void>::Visit(D);
546 D->getCanonicalDecl()->Used |= IsDeclMarkedUsed;
549 if (auto *DD = dyn_cast<DeclaratorDecl>(D)) {
554 if (auto *TD = dyn_cast<TypeDecl>(D)) {
561 cast<TagDecl>(D)->TypedefNameDeclOrQualifier =
563 } else if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
566 } else if (auto *FD = dyn_cast<FunctionDecl>(D)) {
570 } else if (auto *VD = dyn_cast<VarDecl>(D)) {
572 } else if (auto *FD = dyn_cast<FieldDecl>(D)) {
579 void ASTDeclReader::VisitDecl(Decl *D) {
583 D->setReferenced(DeclBits.getNextBit());
584 D->Used = DeclBits.getNextBit();
585 IsDeclMarkedUsed |= D->Used;
586 D->setAccess((AccessSpecifier)DeclBits.getNextBits(/*Width=*/2));
587 D->setImplicit(DeclBits.getNextBit());
590 D->setTopLevelDeclInObjCContainer(DeclBits.getNextBit());
591 D->InvalidDecl = DeclBits.getNextBit();
592 D->FromASTFile = true;
594 if (D->isTemplateParameter() || D->isTemplateParameterPack() ||
595 isa<ParmVarDecl, ObjCTypeParamDecl>(D)) {
607 Reader.addPendingDeclContextInfo(D,
610 D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
626 D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
629 D->setLocation(ThisDeclLoc);
636 D->setAttrsImpl(Attrs, Reader.getContext());
655 D->setModuleOwnershipKind(ModuleOwnership);
657 D->setOwningModuleID(SubmoduleID);
668 D->setVisibleDespiteOwningModule();
670 Reader.HiddenNamesMap[Owner].push_back(D);
673 D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
677 void ASTDeclReader::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
678 VisitDecl(D);
679 D->setLocation(readSourceLocation());
680 D->CommentKind = (PragmaMSCommentKind)Record.readInt();
682 memcpy(D->getTrailingObjects<char>(), Arg.data(), Arg.size());
683 D->getTrailingObjects<char>()[Arg.size()] = '\0';
686 void ASTDeclReader::VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) {
687 VisitDecl(D);
688 D->setLocation(readSourceLocation());
690 memcpy(D->getTrailingObjects<char>(), Name.data(), Name.size());
691 D->getTrailingObjects<char>()[Name.size()] = '\0';
693 D->ValueStart = Name.size() + 1;
695 memcpy(D->getTrailingObjects<char>() + D->ValueStart, Value.data(),
697 D->getTrailingObjects<char>()[D->ValueStart + Value.size()] = '\0';
811 for (auto *D : merged_redecls(ED->getCanonicalDecl())) {
812 if (!D->isFromASTFile() && D->isCompleteDefinition()) {
813 OldDef = D;
874 for (auto *D : merged_redecls(Canon)) {
875 if (!D->isFromASTFile() && D->isCompleteDefinition()) {
876 OldDef = D;
1200 void ASTDeclReader::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
1201 VisitTypedefNameDecl(D);
1203 D->Variance = Record.readInt();
1204 D->Index = Record.readInt();
1205 D->VarianceLoc = readSourceLocation();
1206 D->ColonLoc = readSourceLocation();
1270 void ASTDeclReader::MergeDefinitionData(ObjCInterfaceDecl *D,
1272 struct ObjCInterfaceDecl::DefinitionData &DD = D->data();
1280 if (D->getODRHash() != NewDD.ODRHash)
1382 ObjCProtocolDecl *D, struct ObjCProtocolDecl::DefinitionData &&NewDD) {
1383 struct ObjCProtocolDecl::DefinitionData &DD = D->data();
1391 if (D->getODRHash() != NewDD.ODRHash)
1466 void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
1467 VisitNamedDecl(D);
1468 D->setAtLoc(readSourceLocation());
1469 D->setLParenLoc(readSourceLocation());
1472 D->setType(T, TSI);
1473 D->setPropertyAttributes((ObjCPropertyAttribute::Kind)Record.readInt());
1474 D->setPropertyAttributesAsWritten(
1476 D->setPropertyImplementation(
1480 D->setGetterName(GetterName.getObjCSelector(), GetterLoc);
1483 D->setSetterName(SetterName.getObjCSelector(), SetterLoc);
1484 D->setGetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1485 D->setSetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1486 D->setPropertyIvarDecl(readDeclAs<ObjCIvarDecl>());
1489 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
1490 VisitObjCContainerDecl(D);
1491 D->setClassInterface(readDeclAs<ObjCInterfaceDecl>());
1494 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
1495 VisitObjCImplDecl(D);
1496 D->CategoryNameLoc = readSourceLocation();
1499 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1500 VisitObjCImplDecl(D);
1501 D->setSuperClass(readDeclAs<ObjCInterfaceDecl>());
1502 D->SuperLoc = readSourceLocation();
1503 D->setIvarLBraceLoc(readSourceLocation());
1504 D->setIvarRBraceLoc(readSourceLocation());
1505 D->setHasNonZeroConstructors(Record.readInt());
1506 D->setHasDestructors(Record.readInt());
1507 D->NumIvarInitializers = Record.readInt();
1508 if (D->NumIvarInitializers)
1509 D->IvarInitializers = ReadGlobalOffset();
1512 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
1513 VisitDecl(D);
1514 D->setAtLoc(readSourceLocation());
1515 D->setPropertyDecl(readDeclAs<ObjCPropertyDecl>());
1516 D->PropertyIvarDecl = readDeclAs<ObjCIvarDecl>();
1517 D->IvarLoc = readSourceLocation();
1518 D->setGetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1519 D->setSetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1520 D->setGetterCXXConstructor(Record.readExpr());
1521 D->setSetterCXXAssignment(Record.readExpr());
1549 void ASTDeclReader::VisitMSGuidDecl(MSGuidDecl *D) {
1550 VisitValueDecl(D);
1551 D->PartVal.Part1 = Record.readInt();
1552 D->PartVal.Part2 = Record.readInt();
1553 D->PartVal.Part3 = Record.readInt();
1554 for (auto &C : D->PartVal.Part4And5)
1558 if (MSGuidDecl *Existing = Reader.getContext().MSGuidDecls.GetOrInsertNode(D))
1559 Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl());
1563 UnnamedGlobalConstantDecl *D) {
1564 VisitValueDecl(D);
1565 D->Value = Record.readAPValue();
1569 Reader.getContext().UnnamedGlobalConstantDecls.GetOrInsertNode(D))
1570 Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl());
1573 void ASTDeclReader::VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) {
1574 VisitValueDecl(D);
1575 D->Value = Record.readAPValue();
1580 Reader.getContext().TemplateParamObjectDecls.GetOrInsertNode(D))
1581 Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl());
1758 void ASTDeclReader::VisitTopLevelStmtDecl(TopLevelStmtDecl *D) {
1759 VisitDecl(D);
1760 D->Statement = Record.readStmt();
1809 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1810 VisitDecl(D);
1811 D->setLanguage(static_cast<LinkageSpecLanguageIDs>(Record.readInt()));
1812 D->setExternLoc(readSourceLocation());
1813 D->setRBraceLoc(readSourceLocation());
1816 void ASTDeclReader::VisitExportDecl(ExportDecl *D) {
1817 VisitDecl(D);
1818 D->RBraceLoc = readSourceLocation();
1821 void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
1822 VisitNamedDecl(D);
1823 D->setLocStart(readSourceLocation());
1826 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
1827 RedeclarableResult Redecl = VisitRedeclarable(D);
1828 VisitNamedDecl(D);
1831 D->setInline(NamespaceDeclBits.getNextBit());
1832 D->setNested(NamespaceDeclBits.getNextBit());
1833 D->LocStart = readSourceLocation();
1834 D->RBraceLoc = readSourceLocation();
1844 mergeRedeclarable(D, Redecl);
1852 D->setAnonymousNamespace(Anon);
1856 void ASTDeclReader::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
1857 VisitNamedDecl(D);
1858 VisitDeclContext(D);
1859 D->IsCBuffer = Record.readBool();
1860 D->KwLoc = readSourceLocation();
1861 D->LBraceLoc = readSourceLocation();
1862 D->RBraceLoc = readSourceLocation();
1865 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1866 RedeclarableResult Redecl = VisitRedeclarable(D);
1867 VisitNamedDecl(D);
1868 D->NamespaceLoc = readSourceLocation();
1869 D->IdentLoc = readSourceLocation();
1870 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1871 D->Namespace = readDeclAs<NamedDecl>();
1872 mergeRedeclarable(D, Redecl);
1875 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1876 VisitNamedDecl(D);
1877 D->setUsingLoc(readSourceLocation());
1878 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1879 D->DNLoc = Record.readDeclarationNameLoc(D->getDeclName());
1880 D->FirstUsingShadow.setPointer(readDeclAs<UsingShadowDecl>());
1881 D->setTypename(Record.readInt());
1883 Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1884 mergeMergeable(D);
1887 void ASTDeclReader::VisitUsingEnumDecl(UsingEnumDecl *D) {
1888 VisitNamedDecl(D);
1889 D->setUsingLoc(readSourceLocation());
1890 D->setEnumLoc(readSourceLocation());
1891 D->setEnumType(Record.readTypeSourceInfo());
1892 D->FirstUsingShadow.setPointer(readDeclAs<UsingShadowDecl>());
1894 Reader.getContext().setInstantiatedFromUsingEnumDecl(D, Pattern);
1895 mergeMergeable(D);
1898 void ASTDeclReader::VisitUsingPackDecl(UsingPackDecl *D) {
1899 VisitNamedDecl(D);
1900 D->InstantiatedFrom = readDeclAs<NamedDecl>();
1901 auto **Expansions = D->getTrailingObjects<NamedDecl *>();
1902 for (unsigned I = 0; I != D->NumExpansions; ++I)
1904 mergeMergeable(D);
1907 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1908 RedeclarableResult Redecl = VisitRedeclarable(D);
1909 VisitNamedDecl(D);
1910 D->Underlying = readDeclAs<NamedDecl>();
1911 D->IdentifierNamespace = Record.readInt();
1912 D->UsingOrNextShadow = readDeclAs<NamedDecl>();
1915 Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1916 mergeRedeclarable(D, Redecl);
1920 ConstructorUsingShadowDecl *D) {
1921 VisitUsingShadowDecl(D);
1922 D->NominatedBaseClassShadowDecl = readDeclAs<ConstructorUsingShadowDecl>();
1923 D->ConstructedBaseClassShadowDecl = readDeclAs<ConstructorUsingShadowDecl>();
1924 D->IsVirtual = Record.readInt();
1927 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1928 VisitNamedDecl(D);
1929 D->UsingLoc = readSourceLocation();
1930 D->NamespaceLoc = readSourceLocation();
1931 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1932 D->NominatedNamespace = readDeclAs<NamedDecl>();
1933 D->CommonAncestor = readDeclAs<DeclContext>();
1936 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1937 VisitValueDecl(D);
1938 D->setUsingLoc(readSourceLocation());
1939 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1940 D->DNLoc = Record.readDeclarationNameLoc(D->getDeclName());
1941 D->EllipsisLoc = readSourceLocation();
1942 mergeMergeable(D);
1946 UnresolvedUsingTypenameDecl *D) {
1947 VisitTypeDecl(D);
1948 D->TypenameLocation = readSourceLocation();
1949 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1950 D->EllipsisLoc = readSourceLocation();
1951 mergeMergeable(D);
1955 UnresolvedUsingIfExistsDecl *D) {
1956 VisitNamedDecl(D);
1960 struct CXXRecordDecl::DefinitionData &Data, const CXXRecordDecl *D,
1978 Reader.DefinitionSource[D] =
2017 Reader.getContext().DeviceLambdaManglingNumbers[D] = DeviceManglingNumber;
2054 CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &&MergeDD) {
2055 assert(D->DefinitionData &&
2057 auto &DD = *D->DefinitionData;
2137 if (shouldSkipCheckingODR(MergeDD.Definition) || shouldSkipCheckingODR(D))
2140 if (D->getODRHash() != MergeDD.ODRHash) {
2149 void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update,
2162 D, nullptr, CXXRecordDecl::LDK_Unknown, false, LCD_None);
2164 DD = new (C) struct CXXRecordDecl::DefinitionData(D);
2166 CXXRecordDecl *Canon = D->getCanonicalDecl();
2172 D->DefinitionData = Canon->DefinitionData;
2173 ReadCXXDefinitionData(*DD, D, LambdaContext, IndexInLambdaContext);
2184 D->setCompleteDefinition(true);
2189 if (Update || Canon != D)
2190 Reader.PendingDefinitions.insert(D);
2194 ASTDeclReader::VisitCXXRecordDeclImpl(CXXRecordDecl *D) {
2195 RedeclarableResult Redecl = VisitRecordDeclImpl(D);
2212 if (!isa<ClassTemplateSpecializationDecl>(D))
2213 mergeRedeclarable(D, Redecl);
2218 D->TemplateOrInstantiation = Template;
2236 D->TemplateOrInstantiation = MSI;
2237 mergeRedeclarable(D, Redecl);
2244 mergeLambda(D, Redecl, LambdaContext, IndexInLambdaContext);
2251 ReadCXXRecordDefinition(D, /*Update=*/false, LambdaContext,
2255 D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
2261 if (KeyFn.isValid() && D->isCompleteDefinition())
2265 C.KeyFunctions[D] = KeyFn.getRawValue();
2271 void ASTDeclReader::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
2272 D->setExplicitSpecifier(Record.readExplicitSpec());
2273 D->Ctor = readDeclAs<CXXConstructorDecl>();
2274 VisitFunctionDecl(D);
2275 D->setDeductionCandidateKind(
2279 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
2280 VisitFunctionDecl(D);
2283 if (D->isCanonicalDecl()) {
2288 Reader.getContext().addOverriddenMethod(D, MD->getCanonicalDecl());
2297 void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2300 D->setExplicitSpecifier(Record.readExplicitSpec());
2301 if (D->isInheritingConstructor()) {
2304 *D->getTrailingObjects<InheritedConstructor>() =
2308 VisitCXXMethodDecl(D);
2311 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2312 VisitCXXMethodDecl(D);
2315 CXXDestructorDecl *Canon = D->getCanonicalDecl();
2325 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
2326 D->setExplicitSpecifier(Record.readExplicitSpec());
2327 VisitCXXMethodDecl(D);
2330 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
2331 VisitDecl(D);
2332 D->ImportedModule = readModule();
2333 D->setImportComplete(Record.readInt());
2334 auto *StoredLocs = D->getTrailingObjects<SourceLocation>();
2340 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
2341 VisitDecl(D);
2342 D->setColonLoc(readSourceLocation());
2345 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
2346 VisitDecl(D);
2348 D->Friend = readDeclAs<NamedDecl>();
2350 D->Friend = readTypeSourceInfo();
2351 for (unsigned i = 0; i != D->NumTPLists; ++i)
2352 D->getTrailingObjects<TemplateParameterList *>()[i] =
2354 D->NextFriend = readDeclID().getRawValue();
2355 D->UnsupportedFriend = (Record.readInt() != 0);
2356 D->FriendLoc = readSourceLocation();
2359 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
2360 VisitDecl(D);
2362 D->NumParams = NumParams;
2363 D->Params = new (Reader.getContext()) TemplateParameterList *[NumParams];
2365 D->Params[i] = Record.readTemplateParameterList();
2367 D->Friend = readDeclAs<NamedDecl>();
2369 D->Friend = readTypeSourceInfo();
2370 D->FriendLoc = readSourceLocation();
2373 void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
2374 VisitNamedDecl(D);
2376 assert(!D->TemplateParams && "TemplateParams already set!");
2377 D->TemplateParams = Record.readTemplateParameterList();
2378 D->init(readDeclAs<NamedDecl>());
2381 void ASTDeclReader::VisitConceptDecl(ConceptDecl *D) {
2382 VisitTemplateDecl(D);
2383 D->ConstraintExpr = Record.readExpr();
2384 mergeMergeable(D);
2388 ImplicitConceptSpecializationDecl *D) {
2391 VisitDecl(D);
2393 for (unsigned I = 0; I < D->NumTemplateArgs; ++I)
2395 D->setTemplateArguments(Args);
2398 void ASTDeclReader::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
2402 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
2403 RedeclarableResult Redecl = VisitRedeclarable(D);
2407 RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
2412 D->Common = CanonD->Common;
2418 assert(RTD->getKind() == D->getKind() &&
2420 D->setInstantiatedFromMemberTemplate(RTD);
2422 D->setMemberSpecialization();
2426 VisitTemplateDecl(D);
2427 D->IdentifierNamespace = Record.readInt();
2432 void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
2433 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2434 mergeRedeclarableTemplate(D, Redecl);
2441 ASTDeclReader::AddLazySpecializations(D, SpecIDs);
2444 if (D->getTemplatedDecl()->TemplateOrInstantiation) {
2449 D->getTemplatedDecl(), D->getInjectedClassNameSpecialization());
2453 void ASTDeclReader::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
2460 void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {
2461 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2462 mergeRedeclarableTemplate(D, Redecl);
2469 ASTDeclReader::AddLazySpecializations(D, SpecIDs);
2475 ClassTemplateSpecializationDecl *D) {
2476 RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
2481 D->SpecializedTemplate = CTD;
2493 D->SpecializedTemplate = PS;
2499 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
2500 D->PointOfInstantiation = readSourceLocation();
2501 D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();
2506 if (D->isCanonicalDecl()) { // It's kept in the folding set.
2509 if (auto *Partial = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
2514 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2517 if (CanonSpec != D) {
2518 mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);
2522 if (auto *DDD = D->DefinitionData) {
2526 CanonSpec->DefinitionData = D->DefinitionData;
2528 D->DefinitionData = CanonSpec->DefinitionData;
2538 D->ExplicitInfo = ExplicitInfo;
2542 D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());
2548 ClassTemplatePartialSpecializationDecl *D) {
2552 D->TemplateParams = Params;
2554 RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
2558 D->InstantiatedFromMember.setPointer(
2560 D->InstantiatedFromMember.setInt(Record.readInt());
2564 void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
2565 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2571 ASTDeclReader::AddLazySpecializations(D, SpecIDs);
2582 VarTemplateSpecializationDecl *D) {
2586 D->SpecializedTemplate = VTD;
2598 D->SpecializedTemplate = PS;
2607 D->ExplicitInfo = ExplicitInfo;
2611 D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());
2615 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
2616 D->PointOfInstantiation = readSourceLocation();
2617 D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();
2618 D->IsCompleteDefinition = Record.readInt();
2620 RedeclarableResult Redecl = VisitVarDeclImpl(D);
2625 if (D->isCanonicalDecl()) { // It's kept in the folding set.
2627 if (auto *Partial = dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
2632 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2635 if (CanonSpec != D)
2636 mergeRedeclarable<VarDecl>(D, CanonSpec, Redecl);
2649 VarTemplatePartialSpecializationDecl *D) {
2651 D->TemplateParams = Params;
2653 RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
2657 D->InstantiatedFromMember.setPointer(
2659 D->InstantiatedFromMember.setInt(Record.readInt());
2663 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
2664 VisitTypeDecl(D);
2666 D->setDeclaredWithTypename(Record.readInt());
2669 if (TypeConstraintInitialized && D->hasTypeConstraint()) {
2675 D->setTypeConstraint(CR, ImmediatelyDeclaredConstraint);
2676 if ((D->ExpandedParameterPack = Record.readInt()))
2677 D->NumExpanded = Record.readInt();
2681 D->setDefaultArgument(Reader.getContext(),
2685 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
2686 VisitDeclaratorDecl(D);
2688 D->setDepth(Record.readInt());
2689 D->setPosition(Record.readInt());
2690 if (D->hasPlaceholderTypeConstraint())
2691 D->setPlaceholderTypeConstraint(Record.readExpr());
2692 if (D->isExpandedParameterPack()) {
2694 D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
2695 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2701 D->ParameterPack = Record.readInt();
2703 D->setDefaultArgument(Reader.getContext(),
2708 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
2709 VisitTemplateDecl(D);
2710 D->setDeclaredWithTypename(Record.readBool());
2712 D->setDepth(Record.readInt());
2713 D->setPosition(Record.readInt());
2714 if (D->isExpandedParameterPack()) {
2715 auto **Data = D->getTrailingObjects<TemplateParameterList *>();
2716 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2721 D->ParameterPack = Record.readInt();
2723 D->setDefaultArgument(Reader.getContext(),
2728 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2729 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2730 mergeRedeclarableTemplate(D, Redecl);
2733 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
2734 VisitDecl(D);
2735 D->AssertExprAndFailed.setPointer(Record.readExpr());
2736 D->AssertExprAndFailed.setInt(Record.readInt());
2737 D->Message = cast_or_null<StringLiteral>(Record.readExpr());
2738 D->RParenLoc = readSourceLocation();
2741 void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {
2742 VisitDecl(D);
2746 LifetimeExtendedTemporaryDecl *D) {
2747 VisitDecl(D);
2748 D->ExtendingDecl = readDeclAs<ValueDecl>();
2749 D->ExprWithTemporary = Record.readStmt();
2751 D->Value = new (D->getASTContext()) APValue(Record.readAPValue());
2752 D->getASTContext().addDestruction(D->Value);
2754 D->ManglingNumber = Record.readInt();
2755 mergeMergeable(D);
2767 ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
2804 if (FirstDecl != D) {
2809 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
2810 D->First = FirstDecl->getCanonicalDecl();
2813 auto *DAsT = static_cast<T *>(D);
2825 /// Attempts to merge the given declaration (D) with another declaration
2838 auto *D = static_cast<T *>(DBase);
2842 mergeRedeclarable(D, cast<T>(Existing), Redecl);
2843 else if (FindExistingResult ExistingRes = findExisting(D))
2845 mergeRedeclarable(D, Existing, Redecl);
2848 /// Attempt to merge D with a previous declaration of the same lambda, which is
2854 void ASTDeclReader::mergeLambda(CXXRecordDecl *D, RedeclarableResult &Redecl,
2859 return mergeRedeclarable(D, Redecl);
2866 if (!D->isFirstDecl())
2871 mergeRedeclarable(D, cast<TagDecl>(Existing), Redecl);
2878 mergeRedeclarable(D, cast<TagDecl>(Slot), Redecl);
2880 Slot = D;
2883 void ASTDeclReader::mergeRedeclarableTemplate(RedeclarableTemplateDecl *D,
2885 mergeRedeclarable(D, Redecl);
2889 D->Common = D->getCanonicalDecl()->Common;
2902 void ASTDeclReader::mergeTemplatePattern(RedeclarableTemplateDecl *D,
2905 auto *DPattern = D->getTemplatedDecl();
2942 /// Attempts to merge the given declaration (D) with another declaration
2947 auto *D = static_cast<T *>(DBase);
2949 T *DCanon = D->getCanonicalDecl();
2954 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
2955 D->First = ExistingCanon;
2956 ExistingCanon->Used |= D->Used;
2957 D->Used = false;
2960 if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
2987 void ASTDeclReader::mergeMergeable(LifetimeExtendedTemporaryDecl *D) {
2992 LifetimeExtendedTemporaryDecl *LETDecl = D;
3004 /// Attempts to merge the given declaration (D) with another declaration
3009 void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
3019 !allowODRLikeMergeInC(dyn_cast<NamedDecl>(static_cast<T*>(D))))
3022 if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
3024 Reader.getContext().setPrimaryMergedDecl(static_cast<T *>(D),
3028 void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
3029 Record.readOMPChildren(D->Data);
3030 VisitDecl(D);
3033 void ASTDeclReader::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
3034 Record.readOMPChildren(D->Data);
3035 VisitDecl(D);
3038 void ASTDeclReader::VisitOMPRequiresDecl(OMPRequiresDecl * D) {
3039 Record.readOMPChildren(D->Data);
3040 VisitDecl(D);
3043 void ASTDeclReader::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
3044 VisitValueDecl(D);
3045 D->setLocation(readSourceLocation());
3048 D->setCombinerData(In, Out);
3050 D->setCombiner(Combiner);
3053 D->setInitializerData(Orig, Priv);
3056 D->setInitializer(Init, IK);
3057 D->PrevDeclInScope = readDeclID().getRawValue();
3060 void ASTDeclReader::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
3061 Record.readOMPChildren(D->Data);
3062 VisitValueDecl(D);
3063 D->VarName = Record.readDeclarationName();
3064 D->PrevDeclInScope = readDeclID().getRawValue();
3067 void ASTDeclReader::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
3068 VisitVarDecl(D);
3174 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
3176 DeclsLoaded[Index] = D;
3185 bool ASTReader::isConsumerInterestedIn(Decl *D) {
3191 if (isPartOfPerModuleInitializer(D)) {
3192 auto *M = D->getImportedOwningModule();
3194 getContext().DeclMustBeEmitted(D))
3199 ImportDecl, PragmaCommentDecl, PragmaDetectMismatchDecl>(D))
3202 OMPAllocateDecl, OMPRequiresDecl>(D))
3203 return !D->getDeclContext()->isFunctionOrMethod();
3204 if (const auto *Var = dyn_cast<VarDecl>(D))
3208 if (const auto *Func = dyn_cast<FunctionDecl>(D))
3209 return Func->doesThisDeclarationHaveABody() || PendingBodies.count(D);
3211 if (auto *ES = D->getASTContext().getExternalSource())
3212 if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
3359 for (auto *D : merged_redecls(cast<Decl>(LexicalDC))) {
3360 if (auto *FD = dyn_cast<FunctionDecl>(D))
3363 if (auto *MD = dyn_cast<ObjCMethodDecl>(D))
3366 if (auto *RD = dyn_cast<RecordDecl>(D))
3404 NamedDecl *D) {
3411 Previous[Index] = D;
3414 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
3416 : D->getDeclName();
3418 if (!Name && !needsAnonymousDeclarationNumber(D)) {
3421 FindExistingResult Result(Reader, D, /*Existing=*/nullptr,
3428 DeclContext *DC = D->getDeclContext()->getRedeclContext();
3433 if (C.isSameEntity(It->second, D))
3434 return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,
3440 if (needsAnonymousDeclarationNumber(D)) {
3444 Reader, D->getLexicalDeclContext(), AnonymousDeclNumber))
3445 if (C.isSameEntity(Existing, D))
3446 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3477 if (C.isSameEntity(Existing, D))
3478 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3485 if (C.isSameEntity(Existing, D))
3486 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3502 auto MergedDCIt = Reader.MergedDeclContexts.find(D->getLexicalDeclContext());
3504 !shouldSkipCheckingODR(D) && MergedDCIt->second == D->getDeclContext())
3505 Reader.PendingOdrMergeChecks.push_back(D);
3507 return FindExistingResult(Reader, D, /*Existing=*/nullptr,
3512 Decl *ASTDeclReader::getMostRecentDeclImpl(Redeclarable<DeclT> *D) {
3513 return D->RedeclLink.getLatestNotUpdated();
3520 Decl *ASTDeclReader::getMostRecentDecl(Decl *D) {
3521 assert(D);
3523 switch (D->getKind()) {
3527 return getMostRecentDeclImpl(cast<TYPE##Decl>(D));
3533 Decl *ASTReader::getMostRecentExistingDecl(Decl *D) {
3534 return ASTDeclReader::getMostRecentDecl(D->getCanonicalDecl());
3537 void ASTDeclReader::mergeInheritableAttributes(ASTReader &Reader, Decl *D,
3543 if (IA && !D->hasAttr<MSInheritanceAttr>()) {
3546 D->addAttr(NewAttr);
3550 if (AA && !D->hasAttr<AvailabilityAttr>()) {
3553 D->addAttr(NewAttr);
3559 Redeclarable<DeclT> *D,
3561 D->RedeclLink.setPrevious(cast<DeclT>(Previous));
3562 D->First = cast<DeclT>(Previous)->First;
3569 Redeclarable<VarDecl> *D,
3571 auto *VD = static_cast<VarDecl *>(D);
3573 D->RedeclLink.setPrevious(PrevVD);
3574 D->First = PrevVD->First;
3597 Redeclarable<FunctionDecl> *D,
3599 auto *FD = static_cast<FunctionDecl *>(D);
3691 static void checkMultipleDefinitionInNamedModules(ASTReader &Reader, Decl *D,
3727 if (Reader.getContext().isInSameModule(M, D->getOwningModule()))
3733 Reader.Diag(D->getLocation(), diag::note_also_found);
3736 void ASTDeclReader::attachPreviousDecl(ASTReader &Reader, Decl *D,
3738 assert(D && Previous);
3740 switch (D->getKind()) {
3744 attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous, Canon); \
3749 checkMultipleDefinitionInNamedModules(Reader, D, Previous);
3756 D->IdentifierNamespace |=
3762 if (auto *TD = dyn_cast<TemplateDecl>(D))
3770 mergeInheritableAttributes(Reader, D, Previous);
3774 void ASTDeclReader::attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest) {
3775 D->RedeclLink.setLatest(cast<DeclT>(Latest));
3782 void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
3783 assert(D && Latest);
3785 switch (D->getKind()) {
3789 attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
3796 void ASTDeclReader::markIncompleteDeclChainImpl(Redeclarable<DeclT> *D) {
3797 D->RedeclLink.markIncomplete();
3804 void ASTReader::markIncompleteDeclChain(Decl *D) {
3805 switch (D->getKind()) {
3809 ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
3844 Decl *D = nullptr;
3856 D = TypedefDecl::CreateDeserialized(Context, ID);
3859 D = TypeAliasDecl::CreateDeserialized(Context, ID);
3862 D = EnumDecl::CreateDeserialized(Context, ID);
3865 D = RecordDecl::CreateDeserialized(Context, ID);
3868 D = EnumConstantDecl::CreateDeserialized(Context, ID);
3871 D = FunctionDecl::CreateDeserialized(Context, ID);
3874 D = LinkageSpecDecl::CreateDeserialized(Context, ID);
3877 D = ExportDecl::CreateDeserialized(Context, ID);
3880 D = LabelDecl::CreateDeserialized(Context, ID);
3883 D = NamespaceDecl::CreateDeserialized(Context, ID);
3886 D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
3889 D = UsingDecl::CreateDeserialized(Context, ID);
3892 D = UsingPackDecl::CreateDeserialized(Context, ID, Record.readInt());
3895 D = UsingShadowDecl::CreateDeserialized(Context, ID);
3898 D = UsingEnumDecl::CreateDeserialized(Context, ID);
3901 D = ConstructorUsingShadowDecl::CreateDeserialized(Context, ID);
3904 D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
3907 D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
3910 D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
3913 D = UnresolvedUsingIfExistsDecl::CreateDeserialized(Context, ID);
3916 D = CXXRecordDecl::CreateDeserialized(Context, ID);
3919 D = CXXDeductionGuideDecl::CreateDeserialized(Context, ID);
3922 D = CXXMethodDecl::CreateDeserialized(Context, ID);
3925 D = CXXConstructorDecl::CreateDeserialized(Context, ID, Record.readInt());
3928 D = CXXDestructorDecl::CreateDeserialized(Context, ID);
3931 D = CXXConversionDecl::CreateDeserialized(Context, ID);
3934 D = AccessSpecDecl::CreateDeserialized(Context, ID);
3937 D = FriendDecl::CreateDeserialized(Context, ID, Record.readInt());
3940 D = FriendTemplateDecl::CreateDeserialized(Context, ID);
3943 D = ClassTemplateDecl::CreateDeserialized(Context, ID);
3946 D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
3949 D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
3952 D = VarTemplateDecl::CreateDeserialized(Context, ID);
3955 D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);
3958 D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
3961 D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
3965 D = TemplateTypeParmDecl::CreateDeserialized(Context, ID,
3971 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID,
3977 D = NonTypeTemplateParmDecl::CreateDeserialized(
3982 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
3985 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
3989 D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
3992 D = ConceptDecl::CreateDeserialized(Context, ID);
3995 D = RequiresExprBodyDecl::CreateDeserialized(Context, ID);
3998 D = StaticAssertDecl::CreateDeserialized(Context, ID);
4001 D = ObjCMethodDecl::CreateDeserialized(Context, ID);
4004 D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
4007 D = ObjCIvarDecl::CreateDeserialized(Context, ID);
4010 D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
4013 D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
4016 D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
4019 D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
4022 D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
4025 D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
4028 D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
4031 D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
4034 D = FieldDecl::CreateDeserialized(Context, ID);
4037 D = IndirectFieldDecl::CreateDeserialized(Context, ID);
4040 D = VarDecl::CreateDeserialized(Context, ID);
4043 D = ImplicitParamDecl::CreateDeserialized(Context, ID);
4046 D = ParmVarDecl::CreateDeserialized(Context, ID);
4049 D = DecompositionDecl::CreateDeserialized(Context, ID, Record.readInt());
4052 D = BindingDecl::CreateDeserialized(Context, ID);
4055 D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
4058 D = TopLevelStmtDecl::CreateDeserialized(Context, ID);
4061 D = BlockDecl::CreateDeserialized(Context, ID);
4064 D = MSPropertyDecl::CreateDeserialized(Context, ID);
4067 D = MSGuidDecl::CreateDeserialized(Context, ID);
4070 D = UnnamedGlobalConstantDecl::CreateDeserialized(Context, ID);
4073 D = TemplateParamObjectDecl::CreateDeserialized(Context, ID);
4076 D = CapturedDecl::CreateDeserialized(Context, ID, Record.readInt());
4087 D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
4093 D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, NumChildren);
4100 D = OMPAllocateDecl::CreateDeserialized(Context, ID, NumVars, NumClauses);
4106 D = OMPRequiresDecl::CreateDeserialized(Context, ID, NumClauses);
4110 D = OMPDeclareReductionDecl::CreateDeserialized(Context, ID);
4115 D = OMPDeclareMapperDecl::CreateDeserialized(Context, ID, NumClauses);
4119 D = OMPCapturedExprDecl::CreateDeserialized(Context, ID);
4122 D = PragmaCommentDecl::CreateDeserialized(Context, ID, Record.readInt());
4125 D = PragmaDetectMismatchDecl::CreateDeserialized(Context, ID,
4129 D = EmptyDecl::CreateDeserialized(Context, ID);
4132 D = LifetimeExtendedTemporaryDecl::CreateDeserialized(Context, ID);
4135 D = ObjCTypeParamDecl::CreateDeserialized(Context, ID);
4138 D = HLSLBufferDecl::CreateDeserialized(Context, ID);
4141 D = ImplicitConceptSpecializationDecl::CreateDeserialized(Context, ID,
4146 assert(D && "Unknown declaration reading AST file");
4147 LoadedDecl(translateGlobalDeclIDToIndex(ID), D);
4151 D->setDeclContext(Context.getTranslationUnitDecl());
4155 [&] { Reader.Visit(D); });
4159 if (auto *DC = dyn_cast<DeclContext>(D)) {
4165 if (!Offsets.first && !Offsets.second && isa<NamespaceDecl>(D))
4181 PendingUpdateRecord(ID, D, /*JustLoaded=*/true));
4184 if (auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
4195 PotentiallyInterestingDecls.push_back(D);
4197 return D;
4218 Decl *D = PotentiallyInterestingDecls.front();
4220 if (isConsumerInterestedIn(D))
4221 PassInterestingDeclToConsumer(D);
4229 Decl *D = MaybeInterestingDecls.front();
4236 if (auto *VD = dyn_cast<VarDecl>(D);
4240 if (isConsumerInterestedIn(D))
4241 PassInterestingDeclToConsumer(D);
4260 Decl *D = Record.D;
4274 bool WasInteresting = Record.JustLoaded || isConsumerInterestedIn(D);
4302 Reader.UpdateDecl(D, PendingLazySpecializationIDs);
4306 if (!WasInteresting && isConsumerInterestedIn(D)) {
4307 PotentiallyInterestingDecls.push_back(D);
4313 assert((PendingLazySpecializationIDs.empty() || isa<ClassTemplateDecl>(D) ||
4314 isa<FunctionTemplateDecl, VarTemplateDecl>(D)) &&
4316 if (auto *CTD = dyn_cast<ClassTemplateDecl>(D))
4318 else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(D))
4320 else if (auto *VTD = dyn_cast<VarTemplateDecl>(D))
4330 auto *DC = cast<DeclContext>(D)->getPrimaryContext();
4385 auto *D = ReadDecl(*M, Record, Idx);
4386 ASTDeclReader::attachPreviousDecl(*this, D, MostRecent, CanonDecl);
4387 MostRecent = D;
4501 void ASTReader::loadObjCCategories(GlobalDeclID ID, ObjCInterfaceDecl *D,
4503 ObjCCategoriesVisitor Visitor(*this, D, CategoriesDeserialized, ID,
4509 static void forAllLaterRedecls(DeclT *D, Fn F) {
4510 F(D);
4512 // Check whether we've already merged D into its redeclaration chain.
4513 // MostRecent may or may not be nullptr if D has not been merged. If
4515 auto *MostRecent = D->getMostRecentDecl();
4519 Found = (Redecl == D);
4523 for (auto *Redecl = MostRecent; Redecl != D;
4530 Decl *D,
4535 auto *RD = cast<CXXRecordDecl>(D);
4554 if (auto *TU = dyn_cast<TranslationUnitDecl>(D))
4557 cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
4563 auto *VD = cast<VarDecl>(D);
4572 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D)) {
4574 } else if (auto *VD = dyn_cast<VarDecl>(D)) {
4579 auto *FD = cast<FunctionDecl>(D);
4591 auto *Param = cast<ParmVarDecl>(D);
4606 auto *FD = cast<FieldDecl>(D);
4623 auto *FD = cast<FunctionDecl>(D);
4645 auto *RD = cast<CXXRecordDecl>(D);
4699 if (!D->hasAttrs())
4700 D->setAttrsImpl(Attrs, Reader.getContext());
4709 auto *First = cast<CXXDestructorDecl>(D->getCanonicalDecl());
4724 auto *FD = cast<FunctionDecl>(D);
4742 auto *FD = cast<FunctionDecl>(D);
4751 D->markUsed(Reader.getContext());
4755 Reader.getContext().setManglingNumber(cast<NamedDecl>(D),
4760 Reader.getContext().setStaticLocalNumber(cast<VarDecl>(D),
4765 D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(Reader.getContext(),
4775 D->addAttr(OMPAllocateDeclAttr::CreateImplicit(
4782 auto *Exported = cast<NamedDecl>(D);
4795 D->addAttr(OMPDeclareTargetDeclAttr::CreateImplicit(
4805 D->addAttr(Attrs[0]);