Lines Matching refs:Const
152 const CXXMethodDecl *Method) {
157 const FunctionProtoType *Proto
213 for (const auto &E : Proto->exceptions())
420 static bool functionDeclHasDefaultArgument(const FunctionDecl *FD) {
422 const ParmVarDecl *PVD = FD->getParamDecl(NumParams-1);
631 const FunctionDecl *Def;
685 if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
688 } else if (const PointerType *P = NewType->getAs<PointerType>()) {
691 } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
765 const FunctionDecl *FD) {
767 const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>();
771 const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
803 bool Sema::CheckConstexprFunctionDecl(const FunctionDecl *NewFD) {
804 const
810 const CXXRecordDecl *RD = MD->getParent();
815 for (const auto &I : RD->vbases())
827 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
834 const CXXMethodDecl *WrittenVirtual = Method;
863 static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
868 for (const auto *DclIt : DS->decls()) {
885 const auto *TN = cast<TypedefNameDecl>(DclIt);
919 const auto *VD = cast<VarDecl>(DclIt);
977 const FunctionDecl *Dcl,
1003 const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
1015 CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S,
1133 bool Sema::CheckConstexprFunctionBody(const FunctionDecl *Dcl, Stmt *Body) {
1167 if (const CXXConstructorDecl *Constructor
1169 const CXXRecordDecl *RD = Constructor->getParent();
1207 for (const auto *I: Constructor->inits()) {
1272 bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
1273 const CXXScopeSpec *SS) {
1291 bool Sema::isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS) {
1316 static bool findCircularInheritance(const CXXRecordDecl *Class,
1317 const CXXRecordDecl *Current) {
1318 SmallVector<const CXXRecordDecl*, 8> Queue;
1322 for (const auto &I : Current->bases()) {
1536 const QualType &Type)
1544 for (const auto &BaseSpec : Decl->bases()) {
1603 if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
1604 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
1714 void Sema::BuildBasePathArray(const CXXBasePaths &Paths,
1719 const CXXBasePath &Path = Paths.front();
1958 const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
1966 bool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
1967 const CXXMethodDecl *Old) {
1979 static bool InitializationHasSideEffects(const FieldDecl &FD) {
1980 const Type *T = FD.getType()->getBaseElementTypeUnsafe();
1982 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
2004 Expr *BW, const VirtSpecifiers &VS,
2006 const DeclSpec &DS = D.getDeclSpec();
2069 // data members and cannot be applied to names declared const or static,
2105 const");
2107 const char *PrevSpec;
2112 assert(!Failed && "Making a constexpr member const shouldn't fail");
2116 const char *PrevSpec;
2283 const CXXConstructorDecl *Constructor;
2394 const bool IsReference = FoundVD->getType()->isReferenceType();
2478 void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
2479 FieldDecl *Field, const Type *BaseClass) {
2613 Sema &SemaRef, const CXXConstructorDecl *Constructor) {
2623 const CXXRecordDecl *RD = Constructor->getParent();
2651 for (const auto *FieldInit : Constructor->inits()) {
2746 const CXXBaseSpecifier *&DirectBaseSpec,
2747 const CXXBaseSpecifier *&VirtualBaseSpec) {
2750 for (const auto &Base : ClassDecl->bases()) {
2791 const DeclSpec &DS,
2807 const DeclSpec &DS,
2828 bool ValidateCandidate(const TypoCorrection &candidate) override {
2850 const DeclSpec &DS,
2957 const CXXBaseSpecifier *DirectBaseSpec;
2958 const CXXBaseSpecifier *VirtualBaseSpec;
2970 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
3022 const bool IsPointer = MemberTy->isPointerType();
3024 if (const UnaryOperator *Op
3038 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) {
3040 const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl());
3227 const CXXBaseSpecifier *DirectBaseSpec = nullptr;
3228 const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
3273 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
3357 const CXXRecordDecl *Inherited =
3359 const CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
3518 while (const ConstantArrayType *Array
3687 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
3704 bool isImplicitCopyOrMove() const {
3777 while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
4049 static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl<const void*> &IdealInits) {
4050 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
4051 const RecordDecl *RD = RT->getDecl();
4061 static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
4065 static const void *GetKeyForMember(ASTContext &Context,
4074 Sema &SemaRef, const CXXConstructorDecl *Constructor,
4096 SmallVector<const void*, 32> IdealInitKeys;
4098 const CXXRecordDecl *ClassDecl = Constructor->getParent();
4101 for (const auto &VBase : ClassDecl->vbases())
4105 for (const auto &Base : ClassDecl->bases()) {
4125 const void *InitKey = GetKeyForMember(SemaRef.Context, Init);
4179 const Type *BaseClass = Init->getBaseClass();
4251 llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
4264 const void *Key = GetKeyForMember(Context, Init);
4269 const void *Key = GetKeyForMember(Context, Init);
4321 const RecordType* RT = FieldType->getAs<RecordType>();
4345 llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
4348 for (const auto &Base : ClassDecl->bases()) {
4350 const RecordType *RT = Base.getType()->getAs<RecordType>();
4378 for (const auto &VBase : ClassDecl->vbases()) {
4380 const RecordType *RT = VBase.getType()->castAs<RecordType>();
4427 const auto *RD = Context.getBaseElementType(T)->getAsCXXRecordDecl();
4437 const CXXRecordDecl *Def = RD->getDefinition();
4455 void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) {
4472 llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
4526 void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
4531 const NamedDecl *Ctx;
4533 CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
4616 void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
4773 const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;
4774 const bool ClassImported = !ClassExported;
4900 // complain about any non-static data members of reference or const scalar
4906 for (const auto *F : Record->fields()) {
5034 /// \param ConstRHS True if this is a copy operation with a const object
5036 /// function is 'const' and this is not a field marked 'mutable'.
5048 RHSQuals |= Qualifiers::Const;
5051 RHSQuals & Qualifiers::Const,
5054 LHSQuals & Qualifiers::Const,
5134 for (const auto &B : ClassDecl->bases()) {
5135 const RecordType *BaseType = B.getType()->getAs<RecordType>();
5150 for (const auto *F : ClassDecl->fields()) {
5154 if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
5206 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
5219 const FunctionProtoType *CanonicalFPT =
5242 // copy operation can take a non-const reference) as an implicit
5261 const FunctionProtoType *Type = MD->getType()->getAs<FunctionProtoType>();
5293 // Argument must be reference to possibly-const T.
5308 // FIXME: Explain why this special member can't be const.
5398 CXXMethodDecl *MD, const FunctionProtoType *SpecifiedType) {
5411 const FunctionProtoType *ImplicitType = cast<FunctionProtoType>(
5482 if (const ReferenceType *RT =
5488 bool inUnion() const { return MD->getParent()->isUnion(); }
5640 // and, if a union, it must have a non-const member.
5648 // const-qualified type (or array thereof) with no
5656 << MD->getParent() << FD << FD->getType() << /*Const*/1;
5681 // -- a non-static data member of const non-class type (or array thereof)
5684 << IsMove << MD->getParent() << FD << FD->getType() << /*Const*/1;
5709 // At least one member in each anonymous union must be non-const
5734 /// X is a union and all of its variant members are of const-qualified type.
5942 if (Quals == Qualifiers::Const)
5962 if (Quals == Qualifiers::Const)
6081 for (const auto *FI : RD->fields()) {
6128 void Sema::DiagnoseNontrivial(const CXXRecordDecl *RD, CXXSpecialMember CSM) {
6158 // Trivial copy operations always have const, non-volatile parameter types.
6160 const ParmVarDecl *Param0 = MD->getParamDecl(0);
6161 const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
6162 if (!RT || RT->getPointeeType().getCVRQualifiers() != Qualifiers::Const) {
6176 const ParmVarDecl *Param0 = MD->getParamDecl(0);
6177 const RValueReferenceType *RT =
6215 for (const auto &BI : RD->bases())
6261 for (const auto *MI : RD->methods()) {
6280 llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
6286 const CXXMethodDecl *MD,
6287 const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
6302 bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
6347 static void AddMostOverridenMethods(const CXXMethodDecl *MD,
6348 llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
6427 for (const AttributeList* l = AttrList; l; l = l->getNext()) {
6649 // constructor can be invoked for a const, volatile or const
6650 // volatile object. A constructor shall not be declared const,
6651 // volatile, or const volatile (9.3.2).
6679 if (FTI.TypeQuals & Qualifiers::Const)
6681 << "const" << SourceRange(D.getIdentifierLoc());
6703 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
6738 const char *ConstRef
6739 = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
6740 : " const &";
6798 if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
6801 else if (const TemplateSpecializationType *TST =
6812 // destructor can be invoked for a const, volatile or const
6813 // volatile object. A destructor shall not be declared const,
6814 // volatile or const volatile (9.3.2).
6850 if (FTI.TypeQuals & Qualifiers::Const)
6852 << "const" << SourceRange(D.getIdentifierLoc());
6893 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
6957 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
7096 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
7250 if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
7330 CXXRecordDecl *Sema::getStdBadAlloc() const {
7335 NamespaceDecl *Sema::getStdNamespace() const {
7368 const TemplateArgument *Arguments = nullptr;
7370 if (const RecordType *RT = Ty->getAs<RecordType>()) {
7379 } else if (const TemplateSpecializationType *TST =
7466 bool Sema::isInitListConstructor(const CXXConstructorDecl* Ctor) {
7477 if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
7501 bool ValidateCandidate(const TypoCorrection &candidate) override {
7728 const LookupResult &Previous,
7962 bool ValidateCandidate(const TypoCorrection &Candidate) override {
8248 const Type *SourceType = UD->getQualifier()->getAsType();
8277 const CXXScopeSpec &SS,
8279 const LookupResult &Prev) {
8334 const CXXScopeSpec &SS,
8335 const DeclarationNameInfo &NameInfo,
8469 llvm::SmallPtrSet<const CXXRecordDecl *, 4> Bases;
8470 auto Collect = [&Bases](const CXXRecordDecl *Base) {
8481 auto IsNotBase = [&Bases](const CXXRecordDecl *Base) {
8739 for (const auto &B : ClassDecl->bases()) {
8743 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8754 for (const auto &B : ClassDecl->vbases()) {
8755 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8766 for (const auto *F : ClassDecl->fields()) {
8770 } else if (const RecordType *RecordTy
8798 const CXXConstructorDecl *InheritedCD = CD->getInheritedConstructor();
8799 const CXXRecordDecl *InheritedDecl = InheritedCD->getParent();
8806 for (const auto &B : ClassDecl->bases()) {
8810 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8821 for (const auto &B : ClassDecl->vbases()) {
8822 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8833 for (const auto *F : ClassDecl->fields()) {
8837 } else if (const RecordType *RecordTy
8873 bool isAlreadyBeingDeclared() const {
9014 const CXXConstructorDecl *BaseCtor;
9028 InheritingConstructor &getEntry(Sema &S, const CXXConstructorDecl *Ctor) {
9044 InheritingConstructor &getEntry(const CXXConstructorDecl *Ctor,
9050 typedef void (InheritingConstructorInfo::*VisitFn)(const CXXConstructorDecl*);
9053 void visitAll(const CXXRecordDecl *RD, VisitFn Callback) {
9054 for (const auto *Ctor : RD->ctors())
9059 const FunctionDecl *FD = (*I)->getTemplatedDecl();
9060 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
9066 void noteDeclaredInDerived(const CXXConstructorDecl *Ctor) {
9071 void inherit(const CXXConstructorDecl *Ctor) {
9072 const FunctionProtoType *CtorType =
9110 SourceLocation getUsingLoc(const CXXRecordDecl *Base) {
9120 unsigned minParamsToInherit(const CXXConstructorDecl *Ctor) {
9138 const ParmVarDecl *PD = Ctor->getParamDecl(0);
9139 const ReferenceType *RT = PD->getType()->getAs<ReferenceType>();
9145 void declareCtor(SourceLocation UsingLoc, const CXXConstructorDecl *BaseCtor,
9189 if (const FunctionTemplateDecl *FTD =
9212 const FunctionProtoType *FPT = DerivedType->castAs<FunctionProtoType>();
9258 typedef llvm::DenseMap<const Type *, InheritingConstructorsForType> MapType;
9271 for (const auto &BaseIt : ClassDecl->bases())
9326 for (const auto &B : ClassDecl->bases()) {
9330 if (const RecordType *BaseType = B.getType()->getAs<RecordType>())
9336 for (const auto &B : ClassDecl->vbases()) {
9337 if (const RecordType *BaseType = B.getType()->getAs<RecordType>())
9343 for (const auto *F : ClassDecl->fields()) {
9344 if (const RecordType *RecordTy
9522 const FunctionProtoType *DtorType = Destructor->getType()->
9547 ExprBuilder(const ExprBuilder&) = delete;
9548 ExprBuilder &operator=(const ExprBuilder&) = delete;
9560 virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
9568 Expr *build(Sema &S, SourceLocation Loc) const override {
9578 Expr *build(Sema &S, SourceLocation Loc) const override {
9584 const ExprBuilder &Builder;
9587 const CXXCastPath &Path;
9590 Expr *build(Sema &S, SourceLocation Loc) const override {
9596 CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
9597 const CXXCastPath &Path)
9602 const ExprBuilder &Builder;
9605 Expr *build(Sema &S, SourceLocation Loc) const override {
9610 DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9614 const ExprBuilder &Builder;
9621 Expr *build(Sema &S, SourceLocation Loc) const override {
9627 MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
9634 const ExprBuilder &Builder;
9637 Expr *build(Sema &S, SourceLocation Loc) const override {
9641 MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9645 const ExprBuilder &Builder;
9648 Expr *build(Sema &S, SourceLocation Loc) const override {
9653 LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9657 const ExprBuilder &Base;
9658 const ExprBuilder &Index;
9661 Expr *build(Sema &S, SourceLocation Loc) const override {
9666 SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
9678 const ExprBuilder &ToB, const ExprBuilder &FromB) {
9696 const Type *E = T->getBaseElementTypeUnsafe();
9757 const ExprBuilder &To, const ExprBuilder &From,
9774 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
9822 const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
9861 const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
9907 const ExprBuilder *FromIndex;
9947 const ExprBuilder &To, const ExprBuilder &From,
9974 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
9989 for (const auto &Base : ClassDecl->bases()) {
10000 for (const auto &Base : ClassDecl->vbases()) {
10008 for (const auto *Field : ClassDecl->fields()) {
10035 bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
10036 if (Const)
10042 Const);
10060 /* ConstRHS */ Const,
10190 if (const LValueReferenceType *OtherRef
10272 // Check for members of const-qualified, non-class type.
10384 for (const auto &Base : ClassDecl->bases()) {
10395 for (const auto &Base : ClassDecl->vbases()) {
10403 for (const auto *Field : ClassDecl->fields()) {
10704 // Check for members of const-qualified, non-class type.
10808 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
10815 for (const auto &Base : ClassDecl->bases()) {
10826 for (const auto &Base : ClassDecl->vbases()) {
10833 for (const auto *Field : ClassDecl->fields()) {
10859 bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
10860 if (Const)
10866 Const);
10886 /* ConstRHS */ Const,
10982 for (const auto &B : ClassDecl->bases()) {
10986 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
10998 for (const auto &B : ClassDecl->vbases()) {
10999 if (const
11011 for (const auto *F : ClassDecl->fields()) {
11155 const TemplateArgumentList *DeducedTemplateArgs = nullptr;
11403 void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
11447 const FunctionProtoType *Proto
11480 const FunctionDecl *FnDecl) {
11481 const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
11499 CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
11547 CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
11660 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
11784 const
11815 // Otherwise it must be a pointer to const; let's strip those qualifiers.
11816 const PointerType *PT = T->getAs<PointerType>();
11827 // If there is no second parameter, the first must be a const char *
11834 // const char *, const wchar_t*, const char16_t*, and const char32_t*
11976 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
11980 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
12000 if (const ReferenceType *RT = T->getAs<ReferenceType>())
12022 if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
12201 if (const
12387 Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
12458 const DeclSpec &DS = D.getDeclSpec();
12790 if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
12807 if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
12817 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn)) {
12862 const FunctionDecl *Primary = MD;
12863 if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern())
12926 bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
12927 const CXXMethodDecl *Old) {
12928 const FunctionType *NewFT = New->getType()->getAs<FunctionType>();
12929 const FunctionType *OldFT = Old->getType()->getAs<FunctionType>();
12951 bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
12952 const CXXMethodDecl *Old) {
12964 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
12965 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
12969 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
12970 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
12994 if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
13087 static bool isStaticDataMember(const Decl *D) {
13088 if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
13252 const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
13305 const FunctionDecl *KeyFunctionDef = nullptr;
13321 const CXXRecordDecl *RD) {
13322 for (const auto *I : RD->methods())
13328 const CXXRecordDecl *RD) {
13352 for (const auto &I : RD->bases()) {
13353 const CXXRecordDecl *Base =
13399 if (const RecordType *RecordTy =
13430 const FunctionDecl *FNTarget = nullptr;
13463 const FunctionDecl *FNTarget = nullptr;
13529 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
13554 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
13572 for (const auto &E : Proto->exceptions()) {
13586 for (const auto *A : Method->attrs()) {
13590 if (const auto *G = dyn_cast<GuardedByAttr>(A))
13592 else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
13594 else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
13596 else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
13598 else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
13601 } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
13604 } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
13606 else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
13608 else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
13610 else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
13612 else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
13614 else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
13791 const AttributeList::PropertyData &Data = MSPropertyAttr->getPropertyData();
