Lines Matching defs:Const
151 const CXXMethodDecl *Method) {
156 const FunctionProtoType *Proto
214 for (const auto &E : Proto->exceptions())
402 static bool functionDeclHasDefaultArgument(const FunctionDecl *FD) {
404 const ParmVarDecl *PVD = FD->getParamDecl(NumParams-1);
586 const FunctionDecl *Def;
639 if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
642 } else if (const PointerType *P = NewType->getAs<PointerType>()) {
645 } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
719 const FunctionDecl *FD) {
721 const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>();
725 const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
757 bool Sema::CheckConstexprFunctionDecl(const FunctionDecl *NewFD) {
758 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
764 const CXXRecordDecl *RD = MD->getParent();
769 for (const auto &I : RD->vbases())
781 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
787 const CXXMethodDecl *WrittenVirtual = Method;
816 static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
821 for (const auto *DclIt : DS->decls()) {
838 const auto *TN = cast<TypedefNameDecl>(DclIt);
872 const auto *VD = cast<VarDecl>(DclIt);
930 const FunctionDecl *Dcl,
956 const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
968 CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S,
1086 bool Sema::CheckConstexprFunctionBody(const FunctionDecl *Dcl, Stmt *Body) {
1120 if (const CXXConstructorDecl *Constructor
1122 const CXXRecordDecl *RD = Constructor->getParent();
1160 for (const auto *I: Constructor->inits()) {
1225 bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
1226 const CXXScopeSpec *SS) {
1244 bool Sema::isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS) {
1269 static bool findCircularInheritance(const CXXRecordDecl *Class,
1270 const CXXRecordDecl *Current) {
1271 SmallVector<const CXXRecordDecl*, 8> Queue;
1275 for (const auto &I : Current->bases()) {
1573 if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
1574 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
1654 void Sema::BuildBasePathArray(const CXXBasePaths &Paths,
1659 const CXXBasePath &Path = Paths.front();
1679 bool Sema::BasePathInvolvesVirtualBase(const CXXCastPath &BasePath) {
1894 bool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
1895 const CXXMethodDecl *Old) {
1907 static bool InitializationHasSideEffects(const FieldDecl &FD) {
1908 const Type *T = FD.getType()->getBaseElementTypeUnsafe();
1910 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1932 Expr *BW, const VirtSpecifiers &VS,
1934 const DeclSpec &DS = D.getDeclSpec();
1997 // data members and cannot be applied to names declared const or static,
2033 B << FixItHint::CreateReplacement(ConstexprLoc, "const");
2035 const char *PrevSpec;
2040 assert(!Failed && "Making a constexpr member const shouldn't fail");
2044 const char *PrevSpec;
2207 const CXXConstructorDecl *Constructor;
2212 const CXXConstructorDecl *Constructor)
2246 const bool IsReference = FoundVD->getType()->isReferenceType();
2345 const CXXConstructorDecl *Constructor) {
2370 Sema &SemaRef, const CXXConstructorDecl *Constructor) {
2380 const CXXRecordDecl *RD = Constructor->getParent();
2394 for (const auto *FieldInit : Constructor->inits()) {
2474 const CXXBaseSpecifier *&DirectBaseSpec,
2475 const CXXBaseSpecifier *&VirtualBaseSpec) {
2478 for (const auto &Base : ClassDecl->bases()) {
2518 const DeclSpec &DS,
2534 const DeclSpec &DS,
2555 bool ValidateCandidate(const TypoCorrection &candidate) override {
2577 const DeclSpec &DS,
2679 const CXXBaseSpecifier *DirectBaseSpec;
2680 const CXXBaseSpecifier *VirtualBaseSpec;
2692 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
2738 const bool IsPointer = MemberTy->isPointerType();
2740 if (const UnaryOperator *Op
2754 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) {
2756 const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl());
2943 const CXXBaseSpecifier *DirectBaseSpec = nullptr;
2944 const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
2989 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
3073 const CXXRecordDecl *Inherited =
3075 const CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
3233 while (const ConstantArrayType *Array
3401 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
3418 bool isImplicitCopyOrMove() const {
3491 while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
3761 static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl<const void*> &IdealInits) {
3762 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
3763 const RecordDecl *RD = RT->getDecl();
3773 static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
3777 static const void *GetKeyForMember(ASTContext &Context,
3786 Sema &SemaRef, const CXXConstructorDecl *Constructor,
3808 SmallVector<const void*, 32> IdealInitKeys;
3810 const CXXRecordDecl *ClassDecl = Constructor->getParent();
3813 for (const auto &VBase : ClassDecl->vbases())
3817 for (const auto &Base : ClassDecl->bases()) {
3837 const void *InitKey = GetKeyForMember(SemaRef.Context, Init);
3891 const Type *BaseClass = Init->getBaseClass();
3963 llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
3976 const void *Key = GetKeyForMember(Context, Init);
3981 const void *Key = GetKeyForMember(Context, Init);
4033 const RecordType* RT = FieldType->getAs<RecordType>();
4057 llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
4060 for (const auto &Base : ClassDecl->bases()) {
4062 const RecordType *RT = Base.getType()->getAs<RecordType>();
4090 for (const auto &VBase : ClassDecl->vbases()) {
4092 const RecordType *RT = VBase.getType()->castAs<RecordType>();
4162 if (const ArrayType *AT = Context.getAsArrayType(T))
4165 if (const PointerType *PT = T->getAs<PointerType>()) {
4167 while (const PointerType *T = PT->getPointeeType()->getAs<PointerType>())
4170 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
4174 const RecordType *RT = T->getAs<RecordType>();
4178 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
4183 const CXXRecordDecl *Def = RD->getDefinition();
4196 void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) {
4213 llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
4267 void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
4272 const NamedDecl *Ctx;
4274 CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
4357 void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
4496 // complain about any non-static data members of reference or const scalar
4502 for (const auto *F : Record->fields()) {
4590 // const. [...] The class of which that function is a member shall be
4601 for (const auto *M : Record->methods()) {
4657 /// \param ConstRHS True if this is a copy operation with a const object
4659 /// function is 'const' and this is not a field marked 'mutable'.
4671 RHSQuals |= Qualifiers::Const;
4674 RHSQuals & Qualifiers::Const,
4677 LHSQuals & Qualifiers::Const,
4757 for (const auto &B : ClassDecl->bases()) {
4758 const RecordType *BaseType = B.getType()->getAs<RecordType>();
4773 for (const auto *F : ClassDecl->fields()) {
4777 if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
4829 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
4846 const FunctionProtoType *CanonicalFPT =
4869 // copy operation can take a non-const reference) as an implicit
4888 const FunctionProtoType *Type = MD->getType()->getAs<FunctionProtoType>();
4920 // Argument must be reference to possibly-const T.
4935 // FIXME: Explain why this special member can't be const.
5025 CXXMethodDecl *MD, const FunctionProtoType *SpecifiedType) {
5031 const FunctionProtoType *ImplicitType = cast<FunctionProtoType>(
5043 SmallVector<std::pair<const CXXDestructorDecl *, const CXXDestructorDecl *>,
5045 SmallVector<std::pair<CXXMethodDecl *, const FunctionProtoType *>, 2> Specs;
5053 const CXXDestructorDecl *Dtor = Checks[i].first;
5108 if (const ReferenceType *RT =
5114 bool inUnion() const { return MD->getParent()->isUnion(); }
5266 // and, if a union, it must have a non-const member.
5274 // const-qualified type (or array thereof) with no
5282 << MD->getParent() << FD << FD->getType() << /*Const*/1;
5307 // -- a non-static data member of const non-class type (or array thereof)
5310 << IsMove << MD->getParent() << FD << FD->getType() << /*Const*/1;
5335 // At least one member in each anonymous union must be non-const
5360 /// X is a union and all of its variant members are of const-qualified type.
5561 if (Quals == Qualifiers::Const)
5581 if (Quals == Qualifiers::Const)
5700 for (const auto *FI : RD->fields()) {
5747 void Sema::DiagnoseNontrivial(const CXXRecordDecl *RD, CXXSpecialMember CSM) {
5777 // Trivial copy operations always have const, non-volatile parameter types.
5779 const ParmVarDecl *Param0 = MD->getParamDecl(0);
5780 const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
5781 if (!RT || RT->getPointeeType().getCVRQualifiers() != Qualifiers::Const) {
5795 const ParmVarDecl *Param0 = MD->getParamDecl(0);
5796 const RValueReferenceType *RT =
5834 for (const auto &BI : RD->bases())
5880 for (const auto *MI : RD->methods()) {
5900 llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
5906 static bool CheckMostOverridenMethods(const CXXMethodDecl *MD,
5907 const llvm::SmallPtrSet<const CXXMethodDecl *, 8>& Methods) {
5921 static bool FindHiddenVirtualMethod(const CXXBaseSpecifier *Specifier,
5961 static void AddMostOverridenMethods(const CXXMethodDecl *MD,
5962 llvm::SmallPtrSet<const CXXMethodDecl *, 8>& Methods) {
6041 for (const AttributeList* l = AttrList; l; l = l->getNext()) {
6263 // constructor can be invoked for a const, volatile or const
6264 // volatile object. A constructor shall not be declared const,
6265 // volatile, or const volatile (9.3.2).
6293 if (FTI.TypeQuals & Qualifiers::Const)
6295 << "const" << SourceRange(D.getIdentifierLoc());
6317 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
6352 const char *ConstRef
6353 = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
6354 : " const &";
6412 if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
6415 else if (const TemplateSpecializationType *TST =
6426 // destructor can be invoked for a const, volatile or const
6427 // volatile object. A destructor shall not be declared const,
6428 // volatile or const volatile (9.3.2).
6464 if (FTI.TypeQuals & Qualifiers::Const)
6466 << "const" << SourceRange(D.getIdentifierLoc());
6507 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
6553 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
6626 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
6726 const unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Member |
6789 if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
6870 CXXRecordDecl *Sema::getStdBadAlloc() const {
6875 NamespaceDecl *Sema::getStdNamespace() const {
6908 const TemplateArgument *Arguments = nullptr;
6910 if (const RecordType *RT = Ty->getAs<RecordType>()) {
6919 } else if (const TemplateSpecializationType *TST =
7006 bool Sema::isInitListConstructor(const CXXConstructorDecl* Ctor) {
7017 if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
7041 bool ValidateCandidate(const TypoCorrection &candidate) override {
7265 const LookupResult &Previous,
7498 bool ValidateCandidate(const TypoCorrection &Candidate) override {
7775 const Type *SourceType = UD->getQualifier()->getAsType();
7804 const CXXScopeSpec &SS,
7806 const LookupResult &Prev) {
7861 const CXXScopeSpec &SS,
7862 const DeclarationNameInfo &NameInfo,
7997 llvm::SmallPtrSet<const CXXRecordDecl*, 4> Bases;
7999 static bool collect(const CXXRecordDecl *Base, void *OpaqueData) {
8005 bool hasDependentBases(const CXXRecordDecl *Class) {
8011 static bool doesNotContain(const CXXRecordDecl *Base, void *OpaqueData) {
8016 bool mightShareBases(const CXXRecordDecl *Class) {
8254 for (const auto &B : ClassDecl->bases()) {
8258 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8269 for (const auto &B : ClassDecl->vbases()) {
8270 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8281 for (const auto *F : ClassDecl->fields()) {
8301 } else if (const RecordType *RecordTy
8329 const CXXConstructorDecl *InheritedCD = CD->getInheritedConstructor();
8330 const CXXRecordDecl *InheritedDecl = InheritedCD->getParent();
8337 for (const auto &B : ClassDecl->bases()) {
8341 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8352 for (const auto &B : ClassDecl->vbases()) {
8353 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
8364 for (const auto *F : ClassDecl->fields()) {
8371 } else if (const RecordType *RecordTy
8407 bool isAlreadyBeingDeclared() const {
8537 const CXXConstructorDecl *BaseCtor;
8551 InheritingConstructor &getEntry(Sema &S, const CXXConstructorDecl *Ctor) {
8567 InheritingConstructor &getEntry(const CXXConstructorDecl *Ctor,
8573 typedef void (InheritingConstructorInfo::*VisitFn)(const CXXConstructorDecl*);
8576 void visitAll(const CXXRecordDecl *RD, VisitFn Callback) {
8577 for (const auto *Ctor : RD->ctors())
8582 const FunctionDecl *FD = (*I)->getTemplatedDecl();
8583 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
8589 void noteDeclaredInDerived(const CXXConstructorDecl *Ctor) {
8594 void inherit(const CXXConstructorDecl *Ctor) {
8595 const FunctionProtoType *CtorType =
8633 SourceLocation getUsingLoc(const CXXRecordDecl *Base) {
8643 unsigned minParamsToInherit(const CXXConstructorDecl *Ctor) {
8661 const ParmVarDecl *PD = Ctor->getParamDecl(0);
8662 const ReferenceType *RT = PD->getType()->getAs<ReferenceType>();
8668 void declareCtor(SourceLocation UsingLoc, const CXXConstructorDecl *BaseCtor,
8712 if (const FunctionTemplateDecl *FTD =
8735 const FunctionProtoType *FPT = DerivedType->castAs<FunctionProtoType>();
8781 typedef llvm::DenseMap<const Type *, InheritingConstructorsForType> MapType;
8794 for (const auto &BaseIt : ClassDecl->bases())
8849 for (const auto &B : ClassDecl->bases()) {
8853 if (const RecordType *BaseType = B.getType()->getAs<RecordType>())
8859 for (const auto &B : ClassDecl->vbases()) {
8860 if (const RecordType *BaseType = B.getType()->getAs<RecordType>())
8866 for (const auto *F : ClassDecl->fields()) {
8867 if (const RecordType *RecordTy
8986 const FunctionProtoType *DtorType = Destructor->getType()->
9011 ExprBuilder(const ExprBuilder&) LLVM_DELETED_FUNCTION;
9012 ExprBuilder &operator=(const ExprBuilder&) LLVM_DELETED_FUNCTION;
9024 virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
9032 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
9042 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
9048 const ExprBuilder &Builder;
9051 const CXXCastPath &Path;
9054 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
9060 CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
9061 const CXXCastPath &Path)
9066 const ExprBuilder &Builder;
9069 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
9074 DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9078 const ExprBuilder &Builder;
9085 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
9091 MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
9098 const ExprBuilder &Builder;
9101 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
9105 MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9109 const ExprBuilder &Builder;
9112 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
9117 LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
9121 const ExprBuilder &Base;
9122 const ExprBuilder &Index;
9125 virtual Expr *build(Sema &S, SourceLocation Loc) const override {
9130 SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
9142 const ExprBuilder &ToB, const ExprBuilder &FromB) {
9160 const Type *E = T->getBaseElementTypeUnsafe();
9221 const ExprBuilder &To, const ExprBuilder &From,
9238 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
9286 const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
9325 const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
9371 const ExprBuilder *FromIndex;
9411 const ExprBuilder &To, const ExprBuilder &From,
9438 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
9453 for (const auto &Base : ClassDecl->bases()) {
9464 for (const auto &Base : ClassDecl->vbases()) {
9472 for (const auto *Field : ClassDecl->fields()) {
9499 bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
9500 if (Const)
9506 Const);
9647 if (const LValueReferenceType *OtherRef
9727 // Check for members of const-qualified, non-class type.
9834 for (const auto &Base : ClassDecl->bases()) {
9845 for (const auto &Base : ClassDecl->vbases()) {
9853 for (const auto *Field : ClassDecl->fields()) {
10145 // Check for members of const-qualified, non-class type.
10244 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
10251 for (const auto &Base : ClassDecl->bases()) {
10262 for (const auto &Base : ClassDecl->vbases()) {
10269 for (const auto *Field : ClassDecl->fields()) {
10295 bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
10296 if (Const)
10302 Const);
10404 for (const auto &B : ClassDecl->bases()) {
10408 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
10420 for (const auto &B : ClassDecl->vbases()) {
10421 if (const RecordType *BaseType = B.getType()->getAs<RecordType>()) {
10433 for (const auto *F : ClassDecl->fields()) {
10564 const TemplateArgumentList *DeducedTemplateArgs = nullptr;
10758 void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
10802 const FunctionProtoType *Proto
10827 llvm::makeArrayRef<const Expr *>(AllArgs.data(),
10836 const FunctionDecl *FnDecl) {
10837 const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
10855 CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
10903 CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
11016 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
11140 const TemplateTypeParmType *TArgs =
11171 // Otherwise it must be a pointer to const; let's strip those qualifiers.
11172 const PointerType *PT = T->getAs<PointerType>();
11183 // If there is no second parameter, the first must be a const char *
11190 // const char *, const wchar_t*, const char16_t*, and const char32_t*
11332 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
11336 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
11356 if (const ReferenceType *RT = T->getAs<ReferenceType>())
11378 if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
11557 if (const RecordType *RT = T->getAs<RecordType>()) {
11744 Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
11815 const DeclSpec &DS = D.getDeclSpec();
12128 if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
12145 if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
12155 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn)) {
12200 const FunctionDecl *Primary = MD;
12201 if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern())
12270 bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
12271 const CXXMethodDecl *Old) {
12272 const FunctionType *NewFT = New->getType()->getAs<FunctionType>();
12273 const FunctionType *OldFT = Old->getType()->getAs<FunctionType>();
12295 bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
12296 const CXXMethodDecl *Old) {
12308 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
12309 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
12313 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
12314 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
12338 if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
12422 static bool isStaticDataMember(const Decl *D) {
12423 if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
12587 const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
12639 const FunctionDecl *KeyFunctionDef = nullptr;
12655 const CXXRecordDecl *RD) {
12656 for (const auto *I : RD->methods())
12662 const CXXRecordDecl *RD) {
12686 for (const auto &I : RD->bases()) {
12687 const CXXRecordDecl *Base =
12733 if (const RecordType *RecordTy
12764 const FunctionDecl *FNTarget = nullptr;
12797 const FunctionDecl *FNTarget = nullptr;
12863 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
12888 const FunctionProtoType *Proto = ProtoTL.getTypePtr();
12905 for (const auto &E : Proto->exceptions()) {
12919 for (const auto *A : Method->attrs()) {
12923 if (const auto *G = dyn_cast<GuardedByAttr>(A))
12925 else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
12927 else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
12929 else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
12931 else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
12934 } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
12937 } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
12939 else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
12941 else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
12943 else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
12945 else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
12947 else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
13019 Sema::CUDAFunctionTarget Sema::IdentifyCUDATarget(const FunctionDecl *D) {
13124 const AttributeList::PropertyData &Data = MSPropertyAttr->getPropertyData();
