Lines Matching defs:FD
1432 FunctionDecl *FD = D->getAsFunction();
1433 if (!FD)
1438 assert(CurContext == FD->getLexicalParent() &&
1440 CurContext = FD;
1443 for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
1444 ParmVarDecl *Param = FD->getParamDecl(P);
1840 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1841 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1845 if (FD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
1846 FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1849 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1854 if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation()))
1858 if (FD->doesThisDeclarationHaveABody() &&
1859 Context.DeclMustBeEmitted(FD))
1895 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1896 const FunctionDecl *First = FD->getFirstDecl();
1897 if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
2236 if (const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
2237 addDiagWithPrev(D->getLocation(), FD->getLocation(),
2239 << D << FD << FD->getParent());
2893 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2895 if (FD->isDefined(Def, true))
2923 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {
2925 S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def), &SkipBody);
3391 if (const auto *FD = dyn_cast<FunctionDecl>(Old)) {
3392 if (FD->getBuiltinID())
3405 static bool canRedefineFunction(const FunctionDecl *FD,
3407 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
3409 FD->isInlineSpecified() &&
3410 FD->getStorageClass() == SC_Extern);
3529 if (auto *FD = dyn_cast<FunctionDecl>(NewD))
3530 FixSemaDC(FD->getDescribedFunctionTemplate());
4865 if (auto *FD = dyn_cast<FieldDecl>(D)) {
4866 if (FD->hasInClassInitializer()) {
4867 auto *Init = FD->getInClassInitializer();
5421 const auto *FD = dyn_cast<FieldDecl>(I);
5423 FD = IFD->getAnonField();
5424 if (FD && FD->hasInClassInitializer())
5425 return FD->getLocation();
5540 if (auto *FD = dyn_cast<FieldDecl>(Mem)) {
5544 assert(FD->getAccess() != AS_none);
5545 if (FD->getAccess() != AS_public) {
5546 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
5547 << Record->isUnion() << (FD->getAccess() == AS_protected);
5556 if (CheckNontrivialField(FD))
6924 if (const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
6929 for (TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc();
6936 const auto *MD = dyn_cast<CXXMethodDecl>(FD);
6994 auto *FD = dyn_cast<FunctionDecl>(OldDecl);
6995 if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
7031 } else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
7032 IsInline = FD->isInlined();
7033 IsQualifiedFriend = FD->getQualifier() &&
7034 FD->getFriendObjectKind() == Decl::FOK_Declared;
7098 static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) {
7102 if (!FD->isInlined()) return false;
7105 if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
7109 return S.Context.GetGVALinkageForFunction(FD) == GVA_AvailableExternally;
7160 static bool shouldConsiderLinkage(const FunctionDecl *FD) {
7161 const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
7212 if (const auto *FD = dyn_cast<FunctionDecl>(D))
7213 return FD->isExternC();
8179 if (FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) {
8191 ShadowingDecls.insert({PVD->getCanonicalDecl(), FD});
8419 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev))
8420 Prev = FD->getFirstDecl();
8599 FunctionDecl *FD = getCurFunctionDecl();
8602 if (FD && !FD->hasAttr<OpenCLKernelAttr>()) {
8614 if (FD && FD->hasAttr<OpenCLKernelAttr>()) {
8776 const FunctionDecl *FD = cast<FunctionDecl>(CurContext);
8778 Context.getFunctionFeatureMap(CallerFeatureMap, FD);
8785 } else if (!IsArmStreamingFunction(FD,
8797 const FunctionDecl *FD = cast<FunctionDecl>(CurContext);
8799 Context.getFunctionFeatureMap(CallerFeatureMap, FD);
8901 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
8903 if (FD && !FD->hasBody() &&
8904 hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) {
8905 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
8974 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func);
8975 if (FD &&
8976 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
8981 NearMatches.push_back(std::make_pair(FD, ParamNum));
8997 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
8998 if (FD && !FD->hasBody() &&
8999 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
9000 Previous.addDecl(FD);
9062 FunctionDecl *FD = NearMatch->first;
9063 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
9069 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
9071 if (Loc.isInvalid()) Loc = FD->getLocation();
9077 auto DB = SemaRef.Diag(FD->getLocation(),
9079 << NewFDisConst << FD->getSourceRange().getEnd();
9087 SemaRef.Diag(FD->getLocation(),
9562 for (const auto *FD : RD->fields()) {
9563 QualType QT = FD->getType();
9573 VisitStack.push_back(FD);
9606 S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here)
9638 static bool isStdBuiltin(ASTContext &Ctx, FunctionDecl *FD,
9655 const auto *FPT = FD->getType()->castAs<FunctionProtoType>();
10204 // injection context of the FD. In this example, the semantic context of
10868 static Attr *getImplicitCodeSegAttrFromClass(Sema &S, const FunctionDecl *FD) {
10869 const auto *Method = dyn_cast<CXXMethodDecl>(FD);
10894 Attr *Sema::getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD,
10896 if (Attr *A = getImplicitCodeSegAttrFromClass(*this, FD))
10898 if (!FD->hasAttr<SectionAttr>() && IsDefinition &&
10961 static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD) {
10962 const auto *TA = FD->getAttr<TargetAttr>();
10963 const auto *TVA = FD->getAttr<TargetVersionAttr>();
10974 S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
10981 S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
10988 S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
11000 S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
11030 const FunctionDecl *FD,
11033 const auto Diagnose = [FD, CausedFD, MVKind](Sema &S, const Attr *A) {
11034 S.Diag(FD->getLocation(), diag::err_multiversion_disallowed_other_attr)
11041 for (const Attr *A : FD->attrs()) {
11244 static bool CheckMultiVersionFirstFunction(Sema &S, FunctionDecl *FD) {
11245 MultiVersionKind MVKind = FD->getMultiVersionKind();
11248 const auto *TA = FD->getAttr<TargetAttr>();
11249 const auto *TVA = FD->getAttr<TargetVersionAttr>();
11259 if ((TA || TVA) && CheckMultiVersionValue(S, FD)) {
11260 FD->setInvalidDecl();
11264 if (CheckMultiVersionAdditionalRules(S, nullptr, FD, true, MVKind)) {
11265 FD->setInvalidDecl();
11269 FD->setIsMultiVersion();
11273 static bool PreviousDeclsHaveMultiVersionAttribute(const FunctionDecl *FD) {
11274 for (const Decl *D = FD->getPreviousDecl(); D; D = D->getPreviousDecl()) {
11369 for (const auto *FD : OldFD->redecls()) {
11370 const auto *CurTA = FD->getAttr<TargetAttr>();
11371 const auto *CurTVA = FD->getAttr<TargetVersionAttr>();
11374 if (PreviousDeclsHaveMultiVersionAttribute(FD) &&
11377 S.Diag(FD->getLocation(), diag::err_multiversion_required_in_redecl)
12007 const auto *FD = dyn_cast<FunctionDecl>(ND);
12008 return FD && !FD->hasAttr<OverloadableAttr>();
12213 void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
12221 if (FD->getStorageClass() == SC_Static)
12225 if (FD->isInlineSpecified())
12235 if (FD->isConstexpr()) {
12237 << FD->isConsteval()
12239 FD->setConstexprKind(ConstexprSpecKind::Unspecified);
12243 Diag(FD->getLocation(), diag::err_opencl_no_main)
12244 << FD->hasAttr<OpenCLKernelAttr>();
12245 FD->setInvalidDecl();
12254 QualType T = FD->getType();
12261 FD->setType(QualType(FT, 0));
12262 T = Context.getCanonicalType(FD->getType());
12272 FD->setHasImplicitReturnZero(true);
12274 Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);
12275 SourceRange RTRange = FD->getReturnTypeSourceRange();
12287 FD->setHasImplicitReturnZero(true);
12290 SourceRange RTRange = FD->getReturnTypeSourceRange();
12291 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint)
12294 FD->setInvalidDecl(true);
12303 assert(FD->getNumParams() == nparams);
12308 Diag(FD->getLocation(), diag::ext_variadic_main);
12320 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
12321 FD->setInvalidDecl(true);
12357 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
12359 FD->setInvalidDecl(true);
12363 if (nparams == 1 && !FD->isInvalidDecl()) {
12364 Diag(FD->getLocation(), diag::warn_main_one_arg);
12367 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
12368 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
12369 FD->setInvalidDecl();
12373 static bool isDefaultStdCall(FunctionDecl *FD, Sema &S) {
12376 if (FD->getName() == "main" || FD->getName() == "wmain")
12392 void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) {
12393 QualType T = FD->getType();
12403 if (FD->getName() != "DllMain")
12404 FD->setHasImplicitReturnZero(true);
12408 if (isDefaultStdCall(FD, *this)) {
12412 FD->setType(QualType(FT, 0));
12417 FD->setType(QualType(FT, 0));
12421 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
12422 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
12423 FD->setInvalidDecl();
12508 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
12509 if (!FD)
12511 Fields.push_back(FD);
12512 if (FD->getType()->isReferenceType())
13012 bool shouldIgnoreForRecordTriviality(const FieldDecl *FD) {
13018 return FD->hasAttr<UnavailableAttr>();
13034 const FieldDecl *FD, bool InNonTrivialUnion) {
13036 return this->asDerived().visit(S.Context.getBaseElementType(AT), FD,
13038 return Super::visitWithKind(PDIK, QT, FD, InNonTrivialUnion);
13041 void visitARCStrong(QualType QT, const FieldDecl *FD,
13044 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
13045 << 1 << 0 << QT << FD->getName();
13048 void visitARCWeak(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
13050 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
13051 << 1 << 0 << QT << FD->getName();
13054 void visitStruct(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
13073 for (const FieldDecl *FD : RD->fields())
13074 if (!shouldIgnoreForRecordTriviality(FD))
13075 asDerived().visit(FD->getType(), FD, InNonTrivialUnion);
13078 void visitTrivial(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {}
13099 const FieldDecl *FD, bool InNonTrivialUnion) {
13101 return this->asDerived().visit(S.Context.getBaseElementType(AT), FD,
13103 return Super::visitWithKind(DK, QT, FD, InNonTrivialUnion);
13106 void visitARCStrong(QualType QT, const FieldDecl *FD,
13109 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
13110 << 1 << 1 << QT << FD->getName();
13113 void visitARCWeak(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
13115 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
13116 << 1 << 1 << QT << FD->getName();
13119 void visitStruct(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
13138 for (const FieldDecl *FD : RD->fields())
13139 if (!shouldIgnoreForRecordTriviality(FD))
13140 asDerived().visit(FD->getType(), FD, InNonTrivialUnion);
13143 void visitTrivial(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {}
13144 void visitCXXDestructor(QualType QT, const FieldDecl *FD,
13165 const FieldDecl *FD, bool InNonTrivialUnion) {
13167 return this->asDerived().visit(S.Context.getBaseElementType(AT), FD,
13169 return Super::visitWithKind(PCK, QT, FD, InNonTrivialUnion);
13172 void visitARCStrong(QualType QT, const FieldDecl *FD,
13175 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
13176 << 1 << 2 << QT << FD->getName();
13179 void visitARCWeak(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
13181 S.Diag(FD->getLocation(), diag::note_non_trivial_c_union)
13182 << 1 << 2 << QT << FD->getName();
13185 void visitStruct(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {
13204 for (const FieldDecl *FD : RD->fields())
13205 if (!shouldIgnoreForRecordTriviality(FD))
13206 asDerived().visit(FD->getType(), FD, InNonTrivialUnion);
13210 const FieldDecl *FD, bool InNonTrivialUnion) {}
13211 void visitTrivial(QualType QT, const FieldDecl *FD, bool InNonTrivialUnion) {}
13212 void visitVolatileTrivial(QualType QT, const FieldDecl *FD,
14484 auto *FD = dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod());
14487 while (FD && !getDLLAttr(FD) &&
14488 !FD->hasAttr<DLLExportStaticLocalAttr>() &&
14489 !FD->hasAttr<DLLImportStaticLocalAttr>()) {
14490 FD = dyn_cast_or_null<FunctionDecl>(FD->getParentFunctionOrMethod());
14493 if (!FD)
14497 if (Attr *A = getDLLAttr(FD)) {
14501 } else if (Attr *A = FD->getAttr<DLLExportStaticLocalAttr>()) {
14508 if (!FD->hasAttr<DLLExportAttr>())
14509 FD->addAttr(NewAttr);
14511 } else if (Attr *A = FD->getAttr<DLLImportStaticLocalAttr>()) {
15232 static bool FindPossiblePrototype(const FunctionDecl *FD,
15234 for (const FunctionDecl *Prev = FD->getPreviousDecl(); Prev;
15248 ShouldWarnAboutMissingPrototype(const FunctionDecl *FD,
15251 if (FD->isInvalidDecl())
15255 if (!FD->isGlobal())
15259 if (isa<CXXMethodDecl>(FD))
15263 if (isa<TranslationUnitDecl>(FD->getDeclContext()->getRedeclContext()))
15264 if (IdentifierInfo *II = FD->getIdentifier())
15268 if (FD->isMSVCRTEntryPoint())
15272 if (FD->isInlined())
15276 if (FD->getDescribedFunctionTemplate())
15280 if (FD->isFunctionTemplateSpecialization())
15284 if (FD->hasAttr<OpenCLKernelAttr>())
15288 if (FD->isDeleted())
15293 if (!FD->isExternallyVisible())
15297 if (FindPossiblePrototype(FD, PossiblePrototype))
15304 Sema::CheckForFunctionRedefinition(FunctionDecl *FD,
15309 !FD->isDefined(Definition, /*CheckForPendingFriendDefinition*/ true))
15314 if (FunctionDecl *OrigFD = FD->getInstantiatedFromMemberFunction()) {
15319 cast<Decl>(FD->getLexicalDeclContext())))
15349 Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
15350 << FD << getLangOpts().CPlusPlus;
15352 Diag(FD->getLocation(), diag::err_redefinition) << FD;
15355 FD->setInvalidDecl();
15422 FunctionDecl *FD = nullptr;
15425 FD = FunTmpl->getTemplatedDecl();
15427 FD = cast<FunctionDecl>(D);
15431 if (!isLambdaCallOperator(FD))
15437 FD->isConsteval() ? ExpressionEvaluationContext::ImmediateFunctionContext
15447 ExprEvalContexts.back().InImmediateFunctionContext = FD->isConsteval();
15449 getLangOpts().CPlusPlus20 && FD->isImmediateEscalating();
15452 if (const auto *Attr = FD->getAttr<AliasAttr>()) {
15453 Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 0;
15454 FD->dropAttr<AliasAttr>();
15455 FD->setInvalidDecl();
15457 if (const auto *Attr = FD->getAttr<IFuncAttr>()) {
15458 Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 1;
15459 FD->dropAttr<IFuncAttr>();
15460 FD->setInvalidDecl();
15462 if (const auto *Attr = FD->getAttr<TargetVersionAttr>()) {
15473 if (auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
15485 if (!FD->willHaveBody() && !FD->isLateTemplateParsed() &&
15486 !FD->isThisDeclarationInstantiatedFromAFriendDefinition()) {
15487 CheckForFunctionRedefinition(FD, nullptr, SkipBody);
15497 FD->setWillHaveBody();
15508 if (isGenericLambdaCallOperatorSpecialization(FD)) {
15511 if (FD->getTemplateSpecializationInfo()
15513 Diag(FD->getLocation(), diag::err_lambda_explicit_spec);
15514 FD->setInvalidDecl();
15528 if (unsigned BuiltinID = FD->getBuiltinID()) {
15531 Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
15532 FD->setInvalidDecl();
15541 QualType ResultType = FD->getReturnType();
15543 !FD->isInvalidDecl() && BodyKind != FnBodyKind::Delete &&
15544 (RequireCompleteType(FD->getLocation(), ResultType,
15546 RequireNonAbstractType(FD->getLocation(), FD->getReturnType(),
15549 FD->setInvalidDecl();
15552 PushDeclContext(FnBodyScope, FD);
15556 CheckParmsForFunctionDef(FD->parameters(),
15562 for (Decl *NPD : FD->decls()) {
15567 "parameters should not be in newly created FD yet");
15583 for (auto *Param : FD->parameters()) {
15584 Param->setOwningFunction(FD);
15600 !FD->isInvalidDecl() && !FD->isInlined() &&
15602 FD->getFormalLinkage() == Linkage::External && !FD->isTemplated() &&
15603 !FD->isTemplateInstantiation()) {
15604 assert(FD->isThisDeclarationADefinition());
15605 Diag(FD->getLocation(), diag::err_extern_def_in_header_unit);
15606 FD->setInvalidDecl();
15610 if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
15614 if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() &&
15615 !FD->isTemplateInstantiation()) {
15616 assert(!FD->hasAttr<DLLExportAttr>());
15617 Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition);
15618 FD->setInvalidDecl();
15632 Diag(FD->getLocation(), diag::warn_function_def_in_objc_container);
15637 void Sema::applyFunctionAttributesBeforeParsingBody(Decl *FD) {
15638 if (!FD || FD->isInvalidDecl())
15640 if (auto *TD = dyn_cast<FunctionTemplateDecl>(FD))
15641 FD = TD->getTemplatedDecl();
15642 if (FD && FD->hasAttr<OptimizeNoneAttr>()) {
15692 if (const FunctionDecl *FD = D->getAsFunction()) {
15693 if (FD->isConstexpr())
15698 if (FD->getReturnType()->getContainedDeducedType())
15707 if (FunctionDecl *FD = Decl->getAsFunction())
15708 FD->setHasSkippedBody();
15762 static bool methodHasName(const FunctionDecl *FD, StringRef Name) {
15763 return isa<CXXMethodDecl>(FD) && FD->param_empty() &&
15764 FD->getDeclName().isIdentifier() && FD->getName() == Name;
15767 bool Sema::CanBeGetReturnObject(const FunctionDecl *FD) {
15768 return methodHasName(FD, "get_return_object");
15771 bool Sema::CanBeGetReturnTypeOnAllocFailure(const FunctionDecl *FD) {
15772 return FD->isStatic() &&
15773 methodHasName(FD, "get_return_object_on_allocation_failure");
15776 void Sema::CheckCoroutineWrapper(FunctionDecl *FD) {
15777 RecordDecl *RD = FD->getReturnType()->getAsRecordDecl();
15781 if (CanBeGetReturnObject(FD) || CanBeGetReturnTypeOnAllocFailure(FD))
15783 if (!FD->hasAttr<CoroWrapperAttr>())
15784 Diag(FD->getLocation(), diag::err_coroutine_return_type) << RD;
15790 FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr;
15792 if (FSI->UsesFPIntrin && FD && !FD->hasAttr<StrictFPAttr>())
15793 FD->addAttr(StrictFPAttr::CreateImplicit(Context));
15799 if (getLangOpts().Coroutines && FD && !FD->hasSkippedBody()) {
15801 CheckCompletedCoroutineBody(FD, Body);
15803 CheckCoroutineWrapper(FD);
15810 ExitFunctionBodyRAII ExitRAII(*this, isLambdaCallOperator(FD));
15811 if (FD) {
15821 if (!FD->isDeletedAsWritten())
15822 FD->setBody(Body);
15823 FD->setWillHaveBody(false);
15824 CheckImmediateEscalatingFunctionDefinition(FD, FSI);
15827 if (!FD->isInvalidDecl() && Body && !FD->isDependentContext() &&
15828 FD->getReturnType()->isUndeducedType()) {
15832 if (!FD->getReturnType()->getAs<AutoType>()) {
15834 << FD->getReturnType();
15835 FD->setInvalidDecl();
15840 FD, dcl->getLocation(), Dummy,
15841 FD->getReturnType()->getAs<AutoType>()))
15842 FD->setInvalidDecl();
15845 } else if (getLangOpts().CPlusPlus && isLambdaCallOperator(FD)) {
15859 const auto *Proto = FD->getType()->castAs<FunctionProtoType>();
15860 FD->setType(Context.getFunctionType(RetType, Proto->getParamTypes(),
15867 if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>())
15872 if (getLangOpts().MicrosoftExt && FD->isPureVirtual() &&
15873 !FD->isOutOfLine())
15874 Diag(FD->getLocation(), diag::ext_pure_function_definition);
15876 if (!FD->isInvalidDecl()) {
15879 if (!FD->isDeleted() && !FD->isDefaulted() && !FD->hasSkippedBody() &&
15880 !FD->hasAttr<NakedAttr>())
15881 DiagnoseUnusedParameters(FD->parameters());
15882 DiagnoseSizeOfParametersAndReturnValue(FD->parameters(),
15883 FD->getReturnType(), FD);
15886 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
15887 MarkVTableUsed(FD->getLocation(), Constructor->getParent());
15889 dyn_cast<CXXDestructorDecl>(FD))
15890 MarkVTableUsed(FD->getLocation(), Destructor->getParent());
15895 if (FD->getReturnType()->isRecordType() &&
15896 (!getLangOpts().CPlusPlus || !FD->isDependentContext()))
15906 if (ShouldWarnAboutMissingPrototype(FD, PossiblePrototype)) {
15907 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
15917 << (FD->getNumParams() != 0)
15918 << (FD->getNumParams() == 0 ? FixItHint::CreateInsertion(
15949 if ((FD->getReturnType()->isAnyPointerType() &&
15950 FD->getReturnType()->getPointeeType().isConstQualified()) ||
15951 FD->getReturnType().isConstQualified()) {
15954 if (isLocAtConst(FD->getBeginLoc(), getSourceManager(),
15957 return FD->getBeginLoc();
15959 return FD->getTypeSpecStartLoc();
15961 Diag(FD->getTypeSpecStartLoc(),
15964 << (FD->getStorageClass() == SC_None
15974 (void)FindPossiblePrototype(FD, PossiblePrototype);
15988 if (!FD->hasWrittenPrototype() && FD->getNumParams() != 0 &&
16011 Diag(FD->getLocation(), diag::warn_non_prototype_changes_behavior)
16027 if (FD->isMultiVersion() && FD->hasAttr<CPUDispatchAttr>() && Body)
16033 if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
16040 if (FD->isInlined() &&
16052 MarkVTableUsed(FD->getLocation(), MD->getParent(), true);
16057 assert((FD == getCurFunctionDecl(/*AllowLambdas=*/true)) &&
16125 if (Body && (!FD || !FD->isDefaulted())) {
16129 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
16158 if (!IsInstantiation && FD &&
16159 (FD->isConstexpr() || FD->hasAttr<MSConstexprAttr>()) &&
16160 !FD->isInvalidDecl() &&
16161 !CheckConstexprFunctionDefinition(FD, CheckConstexprKind::Diagnose))
16162 FD->setInvalidDecl();
16164 if (FD && FD->hasAttr<NakedAttr>()) {
16183 Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
16184 FD->setInvalidDecl();
16213 if (FD && ((LangOpts.OpenMP && (LangOpts.OpenMPIsTargetDevice ||
16216 auto ES = getEmissionStatus(FD);
16219 DeclsToCheckForDeferredDiags.insert(FD);
16222 if (FD && !FD->isDeleted())
16223 checkTypeSupport(FD->getType(), FD->getLocation(), FD);
16367 FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(BlockScope, D));
16368 FD->setImplicit();
16370 AddKnownFunctionAttributes(FD);
16372 return FD;
16376 FunctionDecl *FD) {
16377 if (FD->isInvalidDecl())
16380 if (FD->getDeclName().getCXXOverloadedOperator() != OO_New &&
16381 FD->getDeclName().getCXXOverloadedOperator() != OO_Array_New)
16386 if (!FD->isReplaceableGlobalAllocationFunction(&AlignmentParam, &IsNothrow))
16397 if (!IsNothrow && !FD->hasAttr<ReturnsNonNullAttr>() &&
16399 FD->addAttr(ReturnsNonNullAttr::CreateImplicit(Context, FD->getLocation()));
16415 if (!FD->hasAttr<AllocSizeAttr>()) {
16416 FD->addAttr(AllocSizeAttr::CreateImplicit(
16417 Context, /*ElemSizeParam=*/ParamIdx(1, FD),
16418 /*NumElemsParam=*/ParamIdx(), FD->getLocation()));
16427 if (AlignmentParam && !FD->hasAttr<AllocAlignAttr>()) {
16428 FD->addAttr(AllocAlignAttr::CreateImplicit(
16429 Context, ParamIdx(*AlignmentParam, FD), FD->getLocation()));
16444 void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
16445 if (FD->isInvalidDecl())
16450 if (unsigned BuiltinID = FD->getBuiltinID()) {
16455 if (!FD->hasAttr<FormatAttr>()) {
16457 unsigned int NumParams = FD->getNumParams();
16459 FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType())
16461 FD->addAttr(FormatAttr::CreateImplicit(Context,
16465 FD->getLocation()));
16470 if (!FD->hasAttr<FormatAttr>())
16471 FD->addAttr(FormatAttr::CreateImplicit(Context,
16475 FD->getLocation()));
16480 if (!FD->hasAttr<CallbackAttr>() &&
16482 FD->addAttr(CallbackAttr::CreateImplicit(
16483 Context, Encoding.data(), Encoding.size(), FD->getLocation()));
16494 if (!FD->hasAttr<ConstAttr>() &&
16499 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
16506 !FD->hasAttr<ConstAttr>()) {
16514 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
16522 !FD->hasAttr<ReturnsTwiceAttr>())
16523 FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context,
16524 FD->getLocation()));
16525 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>())
16526 FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
16527 if (Context.BuiltinInfo.isPure(BuiltinID) && !FD->hasAttr<PureAttr>())
16528 FD->addAttr(PureAttr::CreateImplicit(Context, FD->getLocation()));
16529 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>())
16530 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
16532 !FD->hasAttr<CUDADeviceAttr>() && !FD->hasAttr<CUDAHostAttr>()) {
16538 FD->addAttr(CUDADeviceAttr::CreateImplicit(Context, FD->getLocation()));
16540 FD->addAttr(CUDAHostAttr::CreateImplicit(Context, FD->getLocation()));
16547 if (!FD->hasAttr<AllocAlignAttr>())
16548 FD->addAttr(AllocAlignAttr::CreateImplicit(Context, ParamIdx(1, FD),
16549 FD->getLocation()));
16558 FD->addAttr(AllocSizeAttr::CreateImplicit(
16559 Context, ParamIdx(1, FD), ParamIdx(2, FD), FD->getLocation()));
16564 FD->addAttr(AllocSizeAttr::CreateImplicit(Context, ParamIdx(2, FD),
16565 ParamIdx(), FD->getLocation()));
16568 FD->addAttr(AllocSizeAttr::CreateImplicit(Context, ParamIdx(1, FD),
16569 ParamIdx(), FD->getLocation()));
16585 if (ParmVarDecl *P = FD->getParamDecl(0u);
16588 LifetimeBoundAttr::CreateImplicit(Context, FD->getLocation()));
16595 AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(FD);
16601 FD->isExternC() && !FD->hasAttr<NoThrowAttr>()) {
16602 const auto *FPT = FD->getType()->getAs<FunctionProtoType>();
16604 FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
16607 IdentifierInfo *Name = FD->getIdentifier();
16610 if ((!getLangOpts().CPlusPlus && FD->getDeclContext()->isTranslationUnit()) ||
16611 (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
16612 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
16622 if (!FD->hasAttr<FormatAttr>())
16623 FD->addAttr(FormatAttr::CreateImplicit(Context,
16626 FD->getLocation()));
16632 if (!FD->hasAttr<FormatArgAttr>())
16633 FD->addAttr(FormatArgAttr::CreateImplicit(Context, ParamIdx(1, FD),
16634 FD->getLocation()));
18112 [](const FieldDecl *FD) { return FD->isBitField(); }))
18517 bool Sema::CheckNontrivialField(FieldDecl *FD) {
18518 assert(FD);
18521 if (FD->isInvalidDecl() || FD->getType()->isDependentType())
18524 QualType EltTy = Context.getBaseElementType(FD->getType());
18555 SourceLocation Loc = FD->getLocation();
18557 if (!FD->hasAttr<UnavailableAttr>())
18558 FD->addAttr(UnavailableAttr::CreateImplicit(Context, "",
18565 FD->getLocation(),
18569 << FD->getParent()->isUnion() << FD->getDeclName()
18868 FieldDecl *FD = cast<FieldDecl>(*i);
18871 const Type *FDTy = FD->getType().getTypePtr();
18873 if (!FD->isAnonymousStructOrUnion()) {
18875 RecFields.push_back(FD);
18880 if (FD->isInvalidDecl()) {
18898 Diag(FD->getLocation(), diag::err_field_declared_as_function)
18899 << FD->getDeclName();
18900 FD->setInvalidDecl();
18912 Diag(FD->getLocation(), diag::err_flexible_array_not_at_end)
18913 << FD->getDeclName() << FD->getType()
18916 FD->setInvalidDecl();
18929 Diag(FD->getLocation(), DiagID)
18930 << FD->getDeclName() << llvm::to_underlying(Record->getTagKind());
18937 Diag(FD->getLocation(), diag::err_flexible_array_virtual_base)
18938 << FD->getDeclName() << llvm::to_underlying(Record->getTagKind());
18940 Diag(FD->getLocation(), diag::ext_c99_flexible_array_member)
18941 << FD->getDeclName() << llvm::to_underlying(Record->getTagKind());
18948 QualType BaseElem = Context.getBaseElementType(FD->getType());
18950 Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
18951 << FD->getDeclName() << FD->getType();
18952 FD->setInvalidDecl();
18965 FD->getLocation(), FD->getType(),
18968 FD->setInvalidDecl();
18981 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
18982 << FD->getDeclName() << FD->getType();
18986 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
18987 << FD->getDeclName();
18992 RequireNonAbstractType(FD->getLocation(), FD->getType(),
18996 FD->setInvalidDecl();
19004 Diag(FD->getLocation(), diag::err_statically_allocated_object)
19005 << FixItHint::CreateInsertion(FD->getLocation(), "*");
19006 QualType T = Context.getObjCObjectPointerType(FD->getType());
19007 FD->setType(T);
19009 FD->getType().hasNonTrivialObjCLifetime() &&
19010 getSourceManager().isInSystemHeader(FD->getLocation()) &&
19011 !getLangOpts().CPlusPlus && !FD->hasAttr<UnavailableAttr>() &&
19012 (FD->getType().getObjCLifetime() != Qualifiers::OCL_Strong ||
19013 !Context.hasDirectOwnershipQualifier(FD->getType()))) {
19020 FD->addAttr(UnavailableAttr::CreateImplicit(
19022 FD->getLocation()));
19026 if (FD->getType()->isObjCObjectPointerType() ||
19027 FD->getType().isObjCGCStrong())
19029 else if (Context.getAsArrayType(FD->getType())) {
19030 QualType BaseType = Context.getBaseElementType(FD->getType());
19041 !shouldIgnoreForRecordTriviality(FD)) {
19042 QualType FT = FD->getType();
19072 if (Record && FD->getType().isVolatileQualified())
19075 if (FD->getIdentifier())
19156 const FieldDecl *FD = dyn_cast<FieldDecl>(D);
19157 if (!FD) {
19173 QualType FieldType = FD->getType().getDesugaredType(Context);
20162 Sema::FunctionEmissionStatus Sema::getEmissionStatus(const FunctionDecl *FD,
20164 assert(FD && "Expected non-null FunctionDecl");
20168 if (LangOpts.SYCLIsDevice && FD->hasAttr<SYCLKernelAttr>())
20172 if (FD->isDependentContext())
20176 auto IsEmittedForExternalSymbol = [this, FD]() {
20180 const FunctionDecl *Def = FD->getDefinition();
20190 OMPDeclareTargetDeclAttr::getDeviceType(FD->getCanonicalDecl());
20212 OMPDeclareTargetDeclAttr::getDeviceType(FD->getCanonicalDecl());
20226 CUDAFunctionTarget T = CUDA().IdentifyTarget(FD);