Lines Matching defs:NewFD
9093 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
9095 DeclarationName Name = NewFD->getDeclName();
9096 DeclContext *NewDC = NewFD->getDeclContext();
9103 NewFD->getFriendObjectKind() ? diag::err_qualified_friend_no_match :
9105 LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
9110 NewFD->setInvalidDecl();
9117 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
9118 DifferentNameValidatorCCC CCC(SemaRef.Context, NewFD,
9125 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
9148 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
9167 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
9201 SemaRef.Diag(NewFD->getLocation(), DiagMsg)
9202 << Name << NewDC << IsDefinition << NewFD->getLocation();
9204 CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD);
9229 << NewFD->getParamDecl(Idx - 1)->getType();
9293 FunctionDecl *NewFD = nullptr;
9333 NewFD = FunctionDecl::Create(
9339 NewFD->setInvalidDecl();
9341 return NewFD;
9864 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
9866 if (!NewFD) return nullptr;
9869 NewFD->setTopLevelDeclInObjCContainer();
9874 NewFD->setLexicalDeclContext(CurContext);
9877 NewFD->setLocalExternDecl();
9887 !NewFD->getOwningModule() ||
9888 NewFD->isFromGlobalModule() ||
9889 NewFD->getOwningModule()->isHeaderLikeModule();
9901 NewFD->setImplicitlyInline();
9908 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
9909 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
9910 NewFD->setIsPureVirtual(true);
9916 NewFD->setInvalidDecl();
9920 NewFD->getKind() == Decl::Kind::CXXMethod && NewFD->getIdentifier() &&
9921 NewFD->getName() == "__init" && D.isFunctionDefinition()) {
9927 SetNestedNameSpecifier(*this, NewFD, D);
9931 NewFD->setInvalidDecl();
9948 NewFD->setInvalidDecl();
9955 Diag(NewFD->getLocation(), diag::err_destructor_template);
9956 NewFD->setInvalidDecl();
9961 NewFD->setInvalidDecl();
9974 NewFD->getLocation(),
9976 NewFD);
9978 NewFD->setDescribedFunctionTemplate(FunctionTemplate);
9982 NewFD->setTemplateParameterListsInfo(Context,
9991 NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
10025 NewFD->setInvalidDecl();
10031 NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
10057 NewFD->setInvalidDecl();
10062 NewFD->setInvalidDecl();
10072 if (isVirtual && !NewFD->isInvalidDecl()) {
10081 } else if (NewFD->getDescribedFunctionTemplate()) {
10089 NewFD->setVirtualAsWritten(true);
10093 NewFD->getReturnType()->isUndeducedType())
10100 if (isInline && !NewFD->isInvalidDecl()) {
10113 if (hasExplicit && !NewFD->isInvalidDecl() &&
10114 !isa<CXXDeductionGuideDecl>(NewFD)) {
10120 } else if (!isa<CXXConstructorDecl>(NewFD) &&
10121 !isa<CXXConversionDecl>(NewFD)) {
10134 NewFD->setImplicitlyInline();
10139 if (isa<CXXDestructorDecl>(NewFD) &&
10144 NewFD->setConstexprKind(getLangOpts().CPlusPlus20
10152 (NewFD->getOverloadedOperator() == OO_New ||
10153 NewFD->getOverloadedOperator() == OO_Array_New ||
10154 NewFD->getOverloadedOperator() == OO_Delete ||
10155 NewFD->getOverloadedOperator() == OO_Array_Delete)) {
10158 << NewFD;
10159 NewFD->setConstexprKind(ConstexprSpecKind::Constexpr);
10172 NewFD->setModulePrivate();
10183 NewFD->setObjectOfFriendDecl();
10184 NewFD->setAccess(AS_public);
10195 NewFD->setDefaulted();
10199 NewFD->setDeletedAsWritten();
10203 if (ImplicitInlineCXX20 && isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
10211 NewFD->setImplicitlyInline();
10230 assert(isa<CXXMethodDecl>(NewFD) &&
10247 NewFD->getDescribedFunctionTemplate()))
10262 NewFD->setType(Context.getFunctionType(
10274 NewFD->isInNamedModule()) {
10275 PendingInlineFuncDecls.insert(NewFD);
10280 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD),
10289 NewFD->addAttr(AsmLabelAttr::Create(Context, SE->getString(),
10294 ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier());
10296 if (isDeclExternC(NewFD)) {
10297 NewFD->addAttr(I->second);
10300 Diag(NewFD->getLocation(), diag::warn_redefine_extname_not_applied)
10301 << /*Variable*/0 << NewFD;
10306 // declaration NewFD, if they are available. First scavenge them into Params.
10320 assert(Param->getDeclContext() != NewFD && "Was set before ?");
10321 Param->setDeclContext(NewFD);
10325 NewFD->setInvalidDecl();
10335 getTagInjectionContext(NewFD->getLexicalDeclContext());
10351 TD->setDeclContext(NewFD);
10352 NewFD->addDecl(TD);
10376 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI);
10381 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
10386 NewFD->setParams(Params);
10389 NewFD->addAttr(
10394 if (!NewFD->isInvalidDecl() &&
10395 NewFD->getReturnType()->isVariablyModifiedType()) {
10396 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
10397 NewFD->setInvalidDecl();
10402 !NewFD->hasAttr<SectionAttr>())
10403 NewFD->addAttr(PragmaClangTextSectionAttr::CreateImplicit(
10409 !NewFD->hasAttr<SectionAttr>()) {
10410 NewFD->addAttr(SectionAttr::CreateImplicit(
10416 NewFD))
10417 NewFD->dropAttr<SectionAttr>();
10423 !NewFD->hasAttr<StrictGuardStackCheckAttr>())
10424 NewFD->addAttr(StrictGuardStackCheckAttr::CreateImplicit(
10429 if (!NewFD->hasAttr<CodeSegAttr>()) {
10430 if (Attr *SAttr = getImplicitCodeSegOrSectionAttrForFunction(NewFD,
10432 NewFD->addAttr(SAttr);
10437 ProcessDeclAttributes(S, NewFD, D);
10438 const auto *NewTVA = NewFD->getAttr<TargetVersionAttr>();
10444 return NewFD;
10453 LangAS AddressSpace = NewFD->getReturnType().getAddressSpace();
10455 Diag(NewFD->getLocation(), diag::err_return_value_with_address_space);
10456 NewFD->setInvalidDecl();
10462 if (!NewFD->isInvalidDecl() && NewFD->isMain())
10463 CheckMain(NewFD, D.getDeclSpec());
10465 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
10466 CheckMSVCRTEntryPoint(NewFD);
10468 if (!NewFD->isInvalidDecl())
10469 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
10475 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
10482 const FunctionType *FT = NewFD->getType()->castAs<FunctionType>();
10490 Diag(NewFD->getLocation(), DiagID)
10495 if (NewFD->getReturnType().hasNonTrivialToPrimitiveDestructCUnion() ||
10496 NewFD->getReturnType().hasNonTrivialToPrimitiveCopyCUnion())
10497 checkNonTrivialCUnion(NewFD->getReturnType(),
10498 NewFD->getReturnTypeSourceRange().getBegin(),
10509 NewFD->isReplaceableGlobalAllocationFunction() &&
10510 !NewFD->hasAttr<UsedAttr>())
10513 << NewFD->getDeclName();
10515 if (Expr *TRC = NewFD->getTrailingRequiresClause()) {
10553 } else if (isFriend && NewFD->isTemplated() &&
10558 Diag(NewFD->getBeginLoc(),
10560 NewFD->setInvalidDecl();
10561 } else if (!NewFD->isTemplated() ||
10562 !(isa<CXXMethodDecl>(NewFD) || D.isFunctionDefinition())) {
10576 CUDA().maybeAddHostDeviceAttrs(NewFD, Previous);
10588 DC->isDependentContext() || NewFD->getType()->isDependentType() ||
10614 NewFD, ExplicitTemplateArgs, Previous))
10615 NewFD->setInvalidDecl();
10616 } else if (!NewFD->isInvalidDecl()) {
10617 if (CheckFunctionTemplateSpecialization(NewFD, ExplicitTemplateArgs,
10619 NewFD->setInvalidDecl();
10622 if (CheckMemberSpecialization(NewFD, Previous))
10623 NewFD->setInvalidDecl();
10627 if (!NewFD->isInvalidDecl() && NewFD->isMain())
10628 CheckMain(NewFD, D.getDeclSpec());
10630 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
10631 CheckMSVCRTEntryPoint(NewFD);
10633 if (!NewFD->isInvalidDecl())
10634 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
10641 assert((NewFD->isInvalidDecl() || NewFD->isMultiVersion() ||
10648 : NewFD);
10650 if (isFriend && NewFD->getPreviousDecl()) {
10652 if (!NewFD->isInvalidDecl())
10653 Access = NewFD->getPreviousDecl()->getAccess();
10655 NewFD->setAccess(Access);
10659 if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
10682 if (NewFD->isInvalidDecl()) {
10688 if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
10689 NewFD->setAccess(AS_public);
10710 } else if (NewFD->isCPUDispatchMultiVersion() ||
10711 NewFD->isCPUSpecificMultiVersion()) {
10731 *this, Previous, NewFD, ExtraArgs, false, nullptr)) {
10741 *this, Previous, NewFD, ExtraArgs, true, S)) {
10747 isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() &&
10757 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
10764 if (!NewFD->isInvalidDecl() && S->getDepth() == 0 && Name.isIdentifier())
10765 HLSL().ActOnTopLevelFunction(NewFD);
10767 if (NewFD->hasAttr<HLSLShaderAttr>())
10768 HLSL().CheckEntryPoint(NewFD);
10778 NewFD->getDeclContext()->getRedeclContext()->isFileContext()) {
10779 if (NewFD->getLanguageLinkage() == CLanguageLinkage) {
10783 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID));
10791 NewFD->getType(), BuiltinType))
10792 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID));
10795 } else if (InStdNamespace && NewFD->isInStdNamespace() &&
10796 isStdBuiltin(Context, NewFD, BuiltinID)) {
10797 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID));
10803 ProcessPragmaWeak(S, NewFD);
10804 checkAttributesAfterMerging(*this, *NewFD);
10806 AddKnownFunctionAttributes(NewFD);
10808 if (NewFD->hasAttr<OverloadableAttr>() &&
10809 !NewFD->getType()->getAs<FunctionProtoType>()) {
10810 Diag(NewFD->getLocation(),
10812 << NewFD;
10813 NewFD->dropAttr<OverloadableAttr>();
10818 if (!DC->isRecord() && NewFD->isExternallyVisible())
10819 AddPushedVisibilityAttribute(NewFD);
10823 ObjC().AddCFAuditedAttribute(NewFD);
10828 AddRangeBasedOptnone(NewFD);
10829 AddImplicitMSFunctionNoBuiltinAttr(NewFD);
10830 AddSectionMSAllocText(NewFD);
10831 ModifyFnAttributesMSPragmaOptimize(NewFD);
10836 if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
10837 isIncompleteDeclExternC(*this, NewFD))
10838 RegisterLocallyScopedExternCDecl(NewFD, S);
10841 NewFD->setRangeEnd(D.getSourceRange().getEnd());
10845 checkDLLAttributeRedeclaration(*this, Prev, NewFD,
10852 IdentifierInfo *II = NewFD->getIdentifier();
10854 !NewFD->isInvalidDecl() &&
10855 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
10857 Diag(NewFD->getLocation(), diag::err_config_scalar_return)
10859 Context.setcudaConfigureCallDecl(NewFD);
10865 if (!getLangOpts().CUDAAllowVariadicFunctions && NewFD->isVariadic() &&
10866 (NewFD->hasAttr<CUDADeviceAttr>() ||
10867 NewFD->hasAttr<CUDAGlobalAttr>()) &&
10868 !(II && II->isStr("printf") && NewFD->isExternC() &&
10870 Diag(NewFD->getLocation(), diag::err_variadic_device_fn);
10874 MarkUnusedFileScopedDecl(NewFD);
10878 if (getLangOpts().OpenCL && NewFD->hasAttr<OpenCLKernelAttr>()) {
10886 if (!NewFD->getReturnType()->isVoidType()) {
10887 SourceRange RTRange = NewFD->getReturnTypeSourceRange();
10895 for (auto *Param : NewFD->parameters())
10914 FriendConstraintsDependOnEnclosingTemplate(NewFD)) {
10915 NewFD->setFriendConstraintRefersToEnclosingTemplate(true);
10921 Diag(NewFD->getBeginLoc(),
10923 NewFD->setInvalidDecl();
10928 if (NewFD->isInvalidDecl())
10933 if (isMemberSpecialization && !NewFD->isInvalidDecl())
10934 CompleteMemberSpecialization(NewFD, Previous);
10937 for (const ParmVarDecl *Param : NewFD->parameters()) {
10963 if (const auto *attr = NewFD->getAttr<AvailabilityAttr>()) {
10964 if (NewFD->hasAttr<ConstructorAttr>()) {
10967 NewFD->dropAttr<AvailabilityAttr>();
10969 if (NewFD->hasAttr<DestructorAttr>()) {
10972 NewFD->dropAttr<AvailabilityAttr>();
10983 if (const auto *NBA = NewFD->getAttr<NoBuiltinAttr>())
11003 !NewFD->isInvalidDecl() &&
11005 ExternalDeclarations.push_back(NewFD);
11007 return NewFD;
11235 const FunctionDecl *OldFD, const FunctionDecl *NewFD,
11270 !NewFD->getType()->getAs<FunctionProtoType>())
11271 return Diag(NewFD->getLocation(), NoProtoDiagID);
11274 NewFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
11278 if (const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
11292 if (NewFD->isDeleted())
11296 if (NewFD->isDefaulted())
11300 if (!ConstexprSupported && NewFD->isConstexpr())
11302 << (NewFD->isConsteval() ? ConstevalFuncs : ConstexprFuncs);
11304 QualType NewQType = Context.getCanonicalType(NewFD->getType());
11320 const auto *NewFPT = NewFD->getType()->getAs<FunctionProtoType>();
11341 if (OldFD->getConstexprKind() != NewFD->getConstexprKind())
11344 if (OldFD->isInlineSpecified() != NewFD->isInlineSpecified())
11347 if (OldFD->getFormalLinkage() != NewFD->getFormalLinkage())
11350 if (!CLinkageMayDiffer && OldFD->isExternC() != NewFD->isExternC())
11354 NewFD->getLocation()))
11361 const FunctionDecl *NewFD,
11365 S.Diag(NewFD->getLocation(), diag::err_multiversion_not_supported);
11376 checkNonMultiVersionCompatAttributes(S, OldFD, NewFD, MVKind))
11379 if (checkNonMultiVersionCompatAttributes(S, NewFD, nullptr, MVKind))
11384 S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used);
11390 OldFD, NewFD, S.PDiag(diag::err_multiversion_noproto),
11391 PartialDiagnosticAt(NewFD->getLocation(),
11393 PartialDiagnosticAt(NewFD->getLocation(),
11396 PartialDiagnosticAt(NewFD->getLocation(),
11406 /// This sets NewFD->isInvalidDecl() to true if there was an error.
11459 FunctionDecl *NewFD,
11465 const auto *NewTA = NewFD->getAttr<TargetAttr>();
11467 const auto *NewTVA = NewFD->getAttr<TargetVersionAttr>();
11475 patchDefaultTargetVersion(NewFD, OldFD);
11484 if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD, true,
11487 NewFD->setInvalidDecl();
11491 if (CheckMultiVersionValue(S, NewFD)) {
11492 NewFD->setInvalidDecl();
11502 NewFD->setIsMultiVersion();
11507 S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
11508 NewFD->setInvalidDecl();
11523 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
11525 NewFD->setInvalidDecl();
11540 S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
11541 NewFD->setInvalidDecl();
11547 NewFD->setIsMultiVersion();
11586 Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD,
11592 if (!MultiVersionTypesCompatible(OldFD, NewFD)) {
11593 S.Diag(NewFD->getLocation(), diag::err_multiversion_types_mixed);
11595 NewFD->setInvalidDecl();
11600 patchDefaultTargetVersion(OldFD, NewFD);
11601 patchDefaultTargetVersion(NewFD, OldFD);
11603 const auto *NewTA = NewFD->getAttr<TargetAttr>();
11604 const auto *NewTVA = NewFD->getAttr<TargetVersionAttr>();
11605 MultiVersionKind NewMVKind = NewFD->getMultiVersionKind();
11621 S.CurContext->isRecord() && !NewFD->getFriendObjectKind();
11624 AllowOverloadingOfFunction(Previous, S.Context, NewFD);
11633 S.IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
11644 NewFD->setIsMultiVersion();
11655 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
11657 NewFD->setInvalidDecl();
11665 NewFD->setIsMultiVersion();
11675 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
11677 NewFD->setInvalidDecl();
11691 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
11693 NewFD->setInvalidDecl();
11707 S.Diag(NewFD->getLocation(), diag::err_target_clone_doesnt_match);
11709 NewFD->setInvalidDecl();
11727 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
11729 NewFD->setInvalidDecl();
11737 NewFD->setIsMultiVersion();
11756 NewFD->setIsMultiVersion();
11763 S.Diag(NewFD->getLocation(), diag::err_cpu_dispatch_mismatch);
11765 NewFD->setInvalidDecl();
11776 NewFD->setIsMultiVersion();
11786 S.Diag(NewFD->getLocation(), diag::err_cpu_specific_multiple_defs)
11789 NewFD->setInvalidDecl();
11803 if ((NewTA || NewTVA) && CheckMultiVersionValue(S, NewFD)) {
11804 NewFD->setInvalidDecl();
11808 if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD,
11810 NewFD->setInvalidDecl();
11817 NewFD->setIsMultiVersion();
11823 NewFD->setIsMultiVersion();
11833 /// This sets NewFD->isInvalidDecl() to true if there was an error.
11836 static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD,
11845 const auto *NewTA = NewFD->getAttr<TargetAttr>();
11846 const auto *NewTVA = NewFD->getAttr<TargetVersionAttr>();
11847 const auto *NewCPUDisp = NewFD->getAttr<CPUDispatchAttr>();
11848 const auto *NewCPUSpec = NewFD->getAttr<CPUSpecificAttr>();
11849 const auto *NewClones = NewFD->getAttr<TargetClonesAttr>();
11850 MultiVersionKind MVKind = NewFD->getMultiVersionKind();
11855 if (NewFD->isMain()) {
11860 S.Diag(NewFD->getLocation(), diag::err_multiversion_not_allowed_on_main);
11861 NewFD->setInvalidDecl();
11877 NewFD->getDeclContext()->getRedeclContext())) {
11882 return CheckMultiVersionFirstFunction(S, NewFD);
11895 S.Diag(NewFD->getLocation(), diag::err_multiversion_required_in_redecl)
11897 NewFD->setInvalidDecl();
11906 S, OldFD, NewFD, Redeclaration, OldDecl, Previous);
11909 NewFD->setInvalidDecl();
11910 return S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used);
11925 return CheckMultiVersionAdditionalDecl(S, OldFD, NewFD, NewCPUDisp,
11930 static void CheckConstPureAttributesUsage(Sema &S, FunctionDecl *NewFD) {
11931 bool IsPure = NewFD->hasAttr<PureAttr>();
11932 bool IsConst = NewFD->hasAttr<ConstAttr>();
11943 S.Diag(NewFD->getLocation(), diag::warn_const_attr_with_pure_attr);
11944 NewFD->dropAttrs<PureAttr>();
11949 if (NewFD->getReturnType()->isVoidType()) {
11950 S.Diag(NewFD->getLocation(), diag::warn_pure_function_returns_void)
11952 NewFD->dropAttrs<PureAttr, ConstAttr>();
11956 bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
11960 assert(!NewFD->getReturnType()->isVariablyModifiedType() &&
11973 inferLifetimeCaptureByAttribute(NewFD);
11977 // Determine whether NewFD is an overload of PrevDecl or
11981 if (!AllowOverloadingOfFunction(Previous, Context, NewFD)) {
11983 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
11989 switch (CheckOverload(S, NewFD, Previous, OldDecl,
12008 checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) {
12018 NewFD->hasAttr<OverloadableAttr>()) {
12019 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) {
12028 if (CheckMultiVersionFunction(*this, NewFD, Redeclaration, OldDecl, Previous))
12033 PPC().CheckPPCMMAType(NewFD->getReturnType(), NewFD->getLocation())) {
12034 NewFD->setInvalidDecl();
12037 CheckConstPureAttributesUsage(*this, NewFD);
12059 (NewFD->isDependentContext() &&
12060 NewFD->getReturnType()->isUndeducedType())) {
12062 NewFD->getType()->castAs<FunctionProtoType>();
12064 NewFD->setType(Context.getFunctionType(NewReturnType, FPT->getParamTypes(),
12077 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
12107 // NewFD and OldDecl represent declarations that need to be
12109 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious,
12111 NewFD->setInvalidDecl();
12122 = NewFD->getDescribedFunctionTemplate();
12130 NewFD->setPreviousDeclaration(OldFD);
12131 if (NewFD->isCXXClassMember()) {
12132 NewFD->setAccess(OldTemplateDecl->getAccess());
12153 if (shouldLinkDependentDeclWithPrevious(NewFD, OldDecl)) {
12156 NewFD->setPreviousDeclaration(OldFD);
12157 if (NewFD->isCXXClassMember())
12158 NewFD->setAccess(OldFD->getAccess());
12162 !NewFD->getAttr<OverloadableAttr>()) {
12176 Diag(NewFD->getLocation(),
12182 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
12187 OpenMP().ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(NewFD);
12189 if (NewFD->hasAttr<SYCLKernelEntryPointAttr>())
12190 SYCL().CheckSYCLEntryPointFunctionDecl(NewFD);
12196 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
12199 dyn_cast<CXXDestructorDecl>(NewFD)) {
12206 if (NewFD->getFriendObjectKind() == Decl::FriendObjectKind::FOK_None ||
12213 if (NewFD->getDeclName() != Name) {
12214 Diag(NewFD->getLocation(), diag::err_destructor_name);
12215 NewFD->setInvalidDecl();
12219 } else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
12231 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
12237 if (Method->isVirtual() && NewFD->getTrailingRequiresClause())
12240 Diag(NewFD->getTrailingRequiresClause()->getBeginLoc(),
12247 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(NewFD))
12251 if (NewFD->isOverloadedOperator() &&
12252 CheckOverloadedOperatorDeclaration(NewFD)) {
12253 NewFD->setInvalidDecl();
12258 if (NewFD->getLiteralIdentifier() &&
12259 CheckLiteralOperatorDeclaration(NewFD)) {
12260 NewFD->setInvalidDecl();
12268 CheckCXXDefaultArguments(NewFD);
12274 if (Previous.empty() && NewFD->isExternC()) {
12275 QualType R = NewFD->getReturnType();
12277 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
12278 << NewFD << R;
12281 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
12293 if (!getLangOpts().CPlusPlus17 && !NewFD->getPrimaryTemplate()) {
12310 auto *FPT = NewFD->getType()->castAs<FunctionProtoType>();
12315 Diag(NewFD->getLocation(),
12317 << NewFD;
12321 bool IsKernel = NewFD->hasAttr<CUDAGlobalAttr>();
12322 for (auto *Parm : NewFD->parameters()) {
12329 CUDA().checkTargetOverload(NewFD, Previous);
12334 ARM().CheckSMEFunctionDefAttributes(NewFD);
18496 FieldDecl *NewFD
18500 if (NewFD->isInvalidDecl())
18504 NewFD->setModulePrivate();
18506 if (NewFD->isInvalidDecl() && PrevDecl) {
18507 // Don't introduce NewFD into scope; there's already something
18510 PushOnScopeChains(NewFD, S);
18512 Record->addDecl(NewFD);
18514 return NewFD;
18643 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
18646 NewFD->setInvalidDecl();
18652 NewFD->setInvalidDecl();
18665 if (CheckNontrivialField(NewFD))
18666 NewFD->setInvalidDecl();
18678 Diag(NewFD->getLocation(),
18681 << NewFD->getDeclName() << EltTy;
18683 NewFD->setInvalidDecl();
18692 ProcessDeclAttributes(getCurScope(), NewFD, *D);
18694 if (NewFD->hasAttrs())
18695 CheckAlignasUnderalignment(NewFD);
18700 if (getLangOpts().ObjCAutoRefCount && ObjC().inferObjCARCLifetime(NewFD))
18701 NewFD->setInvalidDecl();
18708 PPC().CheckPPCMMAType(T, NewFD->getLocation()))
18709 NewFD->setInvalidDecl();
18711 NewFD->setAccess(AS);
18712 return NewFD;