Lines Matching defs:NewFD
8944 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
8946 DeclarationName Name = NewFD->getDeclName();
8947 DeclContext *NewDC = NewFD->getDeclContext();
8954 NewFD->getFriendObjectKind() ? diag::err_qualified_friend_no_match :
8956 LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
8961 NewFD->setInvalidDecl();
8968 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
8969 DifferentNameValidatorCCC CCC(SemaRef.Context, NewFD,
8976 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
8999 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
9018 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
9052 SemaRef.Diag(NewFD->getLocation(), DiagMsg)
9053 << Name << NewDC << IsDefinition << NewFD->getLocation();
9056 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
9075 << NewFD->getParamDecl(Idx - 1)->getType();
9139 FunctionDecl *NewFD = nullptr;
9179 NewFD = FunctionDecl::Create(
9185 NewFD->setInvalidDecl();
9187 return NewFD;
9713 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
9715 if (!NewFD) return nullptr;
9718 NewFD->setTopLevelDeclInObjCContainer();
9723 NewFD->setLexicalDeclContext(CurContext);
9726 NewFD->setLocalExternDecl();
9735 NewFD->isConstexpr() || NewFD->isConsteval() ||
9736 !NewFD->getOwningModule() ||
9737 NewFD->isFromGlobalModule() ||
9738 NewFD->getOwningModule()->isHeaderLikeModule();
9750 NewFD->setImplicitlyInline(ImplicitInlineCXX20);
9757 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
9758 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
9759 NewFD->setIsPureVirtual(true);
9765 NewFD->setInvalidDecl();
9769 NewFD->getKind() == Decl::Kind::CXXMethod && NewFD->getIdentifier() &&
9770 NewFD->getName() == "__init" && D.isFunctionDefinition()) {
9776 SetNestedNameSpecifier(*this, NewFD, D);
9780 NewFD->setInvalidDecl();
9797 NewFD->setInvalidDecl();
9804 Diag(NewFD->getLocation(), diag::err_destructor_template);
9805 NewFD->setInvalidDecl();
9810 NewFD->setInvalidDecl();
9823 NewFD->getLocation(),
9825 NewFD);
9827 NewFD->setDescribedFunctionTemplate(FunctionTemplate);
9831 NewFD->setTemplateParameterListsInfo(Context,
9840 NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
9874 NewFD->setInvalidDecl();
9880 NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
9906 NewFD->setInvalidDecl();
9911 NewFD->setInvalidDecl();
9921 if (isVirtual && !NewFD->isInvalidDecl()) {
9930 } else if (NewFD->getDescribedFunctionTemplate()) {
9938 NewFD->setVirtualAsWritten(true);
9942 NewFD->getReturnType()->isUndeducedType())
9949 if (isInline && !NewFD->isInvalidDecl()) {
9962 if (hasExplicit && !NewFD->isInvalidDecl() &&
9963 !isa<CXXDeductionGuideDecl>(NewFD)) {
9969 } else if (!isa<CXXConstructorDecl>(NewFD) &&
9970 !isa<CXXConversionDecl>(NewFD)) {
9983 NewFD->setImplicitlyInline();
9988 if (isa<CXXDestructorDecl>(NewFD) &&
9993 NewFD->setConstexprKind(getLangOpts().CPlusPlus20
10001 (NewFD->getOverloadedOperator() == OO_New ||
10002 NewFD->getOverloadedOperator() == OO_Array_New ||
10003 NewFD->getOverloadedOperator() == OO_Delete ||
10004 NewFD->getOverloadedOperator() == OO_Array_Delete)) {
10007 << NewFD;
10008 NewFD->setConstexprKind(ConstexprSpecKind::Constexpr);
10021 NewFD->setModulePrivate();
10032 NewFD->setObjectOfFriendDecl();
10033 NewFD->setAccess(AS_public);
10044 NewFD->setDefaulted();
10048 NewFD->setDeletedAsWritten();
10052 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
10060 NewFD->setImplicitlyInline(ImplicitInlineCXX20);
10079 assert(isa<CXXMethodDecl>(NewFD) &&
10096 NewFD->getDescribedFunctionTemplate()))
10111 NewFD->setType(Context.getFunctionType(
10123 NewFD->isInNamedModule()) {
10124 PendingInlineFuncDecls.insert(NewFD);
10129 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD),
10138 NewFD->addAttr(AsmLabelAttr::Create(Context, SE->getString(),
10143 ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier());
10145 if (isDeclExternC(NewFD)) {
10146 NewFD->addAttr(I->second);
10149 Diag(NewFD->getLocation(), diag::warn_redefine_extname_not_applied)
10150 << /*Variable*/0 << NewFD;
10155 // declaration NewFD, if they are available. First scavenge them into Params.
10169 assert(Param->getDeclContext() != NewFD && "Was set before ?");
10170 Param->setDeclContext(NewFD);
10174 NewFD->setInvalidDecl();
10184 getTagInjectionContext(NewFD->getLexicalDeclContext());
10200 TD->setDeclContext(NewFD);
10201 NewFD->addDecl(TD);
10225 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI);
10230 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
10235 NewFD->setParams(Params);
10238 NewFD->addAttr(
10243 if (!NewFD->isInvalidDecl() &&
10244 NewFD->getReturnType()->isVariablyModifiedType()) {
10245 Diag(NewFD->getLocation(), diag::err_vm_func_decl);
10246 NewFD->setInvalidDecl();
10251 !NewFD->hasAttr<SectionAttr>())
10252 NewFD->addAttr(PragmaClangTextSectionAttr::CreateImplicit(
10258 !NewFD->hasAttr<SectionAttr>()) {
10259 NewFD->addAttr(SectionAttr::CreateImplicit(
10265 NewFD))
10266 NewFD->dropAttr<SectionAttr>();
10272 !NewFD->hasAttr<StrictGuardStackCheckAttr>())
10273 NewFD->addAttr(StrictGuardStackCheckAttr::CreateImplicit(
10278 if (!NewFD->hasAttr<CodeSegAttr>()) {
10279 if (Attr *SAttr = getImplicitCodeSegOrSectionAttrForFunction(NewFD,
10281 NewFD->addAttr(SAttr);
10286 ProcessDeclAttributes(S, NewFD, D);
10287 const auto *NewTVA = NewFD->getAttr<TargetVersionAttr>();
10292 return NewFD;
10301 LangAS AddressSpace = NewFD->getReturnType().getAddressSpace();
10303 Diag(NewFD->getLocation(), diag::err_return_value_with_address_space);
10304 NewFD->setInvalidDecl();
10310 if (!NewFD->isInvalidDecl() && NewFD->isMain())
10311 CheckMain(NewFD, D.getDeclSpec());
10313 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
10314 CheckMSVCRTEntryPoint(NewFD);
10316 if (!NewFD->isInvalidDecl())
10317 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
10323 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
10330 const FunctionType *FT = NewFD->getType()->castAs<FunctionType>();
10338 Diag(NewFD->getLocation(), DiagID)
10343 if (NewFD->getReturnType().hasNonTrivialToPrimitiveDestructCUnion() ||
10344 NewFD->getReturnType().hasNonTrivialToPrimitiveCopyCUnion())
10345 checkNonTrivialCUnion(NewFD->getReturnType(),
10346 NewFD->getReturnTypeSourceRange().getBegin(),
10357 NewFD->isReplaceableGlobalAllocationFunction() &&
10358 !NewFD->hasAttr<UsedAttr>())
10361 << NewFD->getDeclName();
10363 if (Expr *TRC = NewFD->getTrailingRequiresClause()) {
10401 } else if (isFriend && NewFD->isTemplated() &&
10406 Diag(NewFD->getBeginLoc(),
10408 NewFD->setInvalidDecl();
10409 } else if (!NewFD->isTemplated() ||
10410 !(isa<CXXMethodDecl>(NewFD) || D.isFunctionDefinition())) {
10424 CUDA().maybeAddHostDeviceAttrs(NewFD, Previous);
10436 DC->isDependentContext() || NewFD->getType()->isDependentType() ||
10462 NewFD, ExplicitTemplateArgs, Previous))
10463 NewFD->setInvalidDecl();
10464 } else if (!NewFD->isInvalidDecl()) {
10465 if (CheckFunctionTemplateSpecialization(NewFD, ExplicitTemplateArgs,
10467 NewFD->setInvalidDecl();
10469 } else if (isMemberSpecialization && isa<CXXMethodDecl>(NewFD)) {
10470 if (CheckMemberSpecialization(NewFD, Previous))
10471 NewFD->setInvalidDecl();
10475 if (!NewFD->isInvalidDecl() && NewFD->isMain())
10476 CheckMain(NewFD, D.getDeclSpec());
10478 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
10479 CheckMSVCRTEntryPoint(NewFD);
10481 if (!NewFD->isInvalidDecl())
10482 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
10489 assert((NewFD->isInvalidDecl() || NewFD->isMultiVersion() ||
10496 : NewFD);
10498 if (isFriend && NewFD->getPreviousDecl()) {
10500 if (!NewFD->isInvalidDecl())
10501 Access = NewFD->getPreviousDecl()->getAccess();
10503 NewFD->setAccess(Access);
10507 if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
10530 if (NewFD->isInvalidDecl()) {
10536 if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
10537 NewFD->setAccess(AS_public);
10558 } else if (NewFD->isCPUDispatchMultiVersion() ||
10559 NewFD->isCPUSpecificMultiVersion()) {
10579 *this, Previous, NewFD, ExtraArgs, false, nullptr)) {
10589 *this, Previous, NewFD, ExtraArgs, true, S)) {
10595 isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() &&
10605 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
10612 if (!NewFD->isInvalidDecl() && S->getDepth() == 0 && Name.isIdentifier())
10613 HLSL().ActOnTopLevelFunction(NewFD);
10615 if (NewFD->hasAttr<HLSLShaderAttr>())
10616 HLSL().CheckEntryPoint(NewFD);
10626 NewFD->getDeclContext()->getRedeclContext()->isFileContext()) {
10627 if (NewFD->getLanguageLinkage() == CLanguageLinkage) {
10631 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID));
10639 NewFD->getType(), BuiltinType))
10640 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID));
10643 } else if (InStdNamespace && NewFD->isInStdNamespace() &&
10644 isStdBuiltin(Context, NewFD, BuiltinID)) {
10645 NewFD->addAttr(BuiltinAttr::CreateImplicit(Context, BuiltinID));
10651 ProcessPragmaWeak(S, NewFD);
10652 checkAttributesAfterMerging(*this, *NewFD);
10654 AddKnownFunctionAttributes(NewFD);
10656 if (NewFD->hasAttr<OverloadableAttr>() &&
10657 !NewFD->getType()->getAs<FunctionProtoType>()) {
10658 Diag(NewFD->getLocation(),
10660 << NewFD;
10661 NewFD->dropAttr<OverloadableAttr>();
10666 if (!DC->isRecord() && NewFD->isExternallyVisible())
10667 AddPushedVisibilityAttribute(NewFD);
10671 ObjC().AddCFAuditedAttribute(NewFD);
10676 AddRangeBasedOptnone(NewFD);
10677 AddImplicitMSFunctionNoBuiltinAttr(NewFD);
10678 AddSectionMSAllocText(NewFD);
10679 ModifyFnAttributesMSPragmaOptimize(NewFD);
10684 if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
10685 isIncompleteDeclExternC(*this, NewFD))
10686 RegisterLocallyScopedExternCDecl(NewFD, S);
10689 NewFD->setRangeEnd(D.getSourceRange().getEnd());
10693 checkDLLAttributeRedeclaration(*this, Prev, NewFD,
10700 IdentifierInfo *II = NewFD->getIdentifier();
10702 !NewFD->isInvalidDecl() &&
10703 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
10705 Diag(NewFD->getLocation(), diag::err_config_scalar_return)
10707 Context.setcudaConfigureCallDecl(NewFD);
10713 if (!getLangOpts().CUDAAllowVariadicFunctions && NewFD->isVariadic() &&
10714 (NewFD->hasAttr<CUDADeviceAttr>() ||
10715 NewFD->hasAttr<CUDAGlobalAttr>()) &&
10716 !(II && II->isStr("printf") && NewFD->isExternC() &&
10718 Diag(NewFD->getLocation(), diag::err_variadic_device_fn);
10722 MarkUnusedFileScopedDecl(NewFD);
10726 if (getLangOpts().OpenCL && NewFD->hasAttr<OpenCLKernelAttr>()) {
10734 if (!NewFD->getReturnType()->isVoidType()) {
10735 SourceRange RTRange = NewFD->getReturnTypeSourceRange();
10743 for (auto *Param : NewFD->parameters())
10762 FriendConstraintsDependOnEnclosingTemplate(NewFD)) {
10763 NewFD->setFriendConstraintRefersToEnclosingTemplate(true);
10769 Diag(NewFD->getBeginLoc(),
10771 NewFD->setInvalidDecl();
10776 if (NewFD->isInvalidDecl())
10781 if (isMemberSpecialization && !NewFD->isInvalidDecl())
10782 CompleteMemberSpecialization(NewFD, Previous);
10785 for (const ParmVarDecl *Param : NewFD->parameters()) {
10811 if (const auto *attr = NewFD->getAttr<AvailabilityAttr>()) {
10812 if (NewFD->hasAttr<ConstructorAttr>()) {
10815 NewFD->dropAttr<AvailabilityAttr>();
10817 if (NewFD->hasAttr<DestructorAttr>()) {
10820 NewFD->dropAttr<AvailabilityAttr>();
10831 if (const auto *NBA = NewFD->getAttr<NoBuiltinAttr>())
10851 !NewFD->isInvalidDecl() &&
10853 ExternalDeclarations.push_back(NewFD);
10855 return NewFD;
11073 const FunctionDecl *OldFD, const FunctionDecl *NewFD,
11108 !NewFD->getType()->getAs<FunctionProtoType>())
11109 return Diag(NewFD->getLocation(), NoProtoDiagID);
11112 NewFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
11116 if (const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
11130 if (NewFD->isDeleted())
11134 if (NewFD->isDefaulted())
11138 if (!ConstexprSupported && NewFD->isConstexpr())
11140 << (NewFD->isConsteval() ? ConstevalFuncs : ConstexprFuncs);
11142 QualType NewQType = Context.getCanonicalType(NewFD->getType());
11158 const auto *NewFPT = NewFD->getType()->getAs<FunctionProtoType>();
11179 if (OldFD->getConstexprKind() != NewFD->getConstexprKind())
11182 if (OldFD->isInlineSpecified() != NewFD->isInlineSpecified())
11185 if (OldFD->getFormalLinkage() != NewFD->getFormalLinkage())
11188 if (!CLinkageMayDiffer && OldFD->isExternC() != NewFD->isExternC())
11192 NewFD->getLocation()))
11199 const FunctionDecl *NewFD,
11203 S.Diag(NewFD->getLocation(), diag::err_multiversion_not_supported);
11214 checkNonMultiVersionCompatAttributes(S, OldFD, NewFD, MVKind))
11217 if (checkNonMultiVersionCompatAttributes(S, NewFD, nullptr, MVKind))
11222 return S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used);
11225 OldFD, NewFD, S.PDiag(diag::err_multiversion_noproto),
11226 PartialDiagnosticAt(NewFD->getLocation(),
11228 PartialDiagnosticAt(NewFD->getLocation(),
11231 PartialDiagnosticAt(NewFD->getLocation(),
11241 /// This sets NewFD->isInvalidDecl() to true if there was an error.
11297 FunctionDecl *NewFD,
11306 patchDefaultTargetVersion(NewFD, OldFD);
11308 const auto *NewTA = NewFD->getAttr<TargetAttr>();
11309 const auto *NewTVA = NewFD->getAttr<TargetVersionAttr>();
11324 if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD, true,
11327 NewFD->setInvalidDecl();
11331 if (CheckMultiVersionValue(S, NewFD)) {
11332 NewFD->setInvalidDecl();
11341 NewFD->setIsMultiVersion();
11346 S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
11347 NewFD->setInvalidDecl();
11362 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
11364 NewFD->setInvalidDecl();
11379 S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
11380 NewFD->setInvalidDecl();
11386 NewFD->setIsMultiVersion();
11425 Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD,
11431 if (!MultiVersionTypesCompatible(OldFD, NewFD)) {
11432 S.Diag(NewFD->getLocation(), diag::err_multiversion_types_mixed);
11434 NewFD->setInvalidDecl();
11439 patchDefaultTargetVersion(OldFD, NewFD);
11440 patchDefaultTargetVersion(NewFD, OldFD);
11442 const auto *NewTA = NewFD->getAttr<TargetAttr>();
11443 const auto *NewTVA = NewFD->getAttr<TargetVersionAttr>();
11444 MultiVersionKind NewMVKind = NewFD->getMultiVersionKind();
11460 S.CurContext->isRecord() && !NewFD->getFriendObjectKind();
11463 AllowOverloadingOfFunction(Previous, S.Context, NewFD);
11472 S.IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
11483 NewFD->setIsMultiVersion();
11494 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
11496 NewFD->setInvalidDecl();
11504 NewFD->setIsMultiVersion();
11514 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
11516 NewFD->setInvalidDecl();
11530 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
11532 NewFD->setInvalidDecl();
11546 S.Diag(NewFD->getLocation(), diag::err_target_clone_doesnt_match);
11548 NewFD->setInvalidDecl();
11566 S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
11568 NewFD->setInvalidDecl();
11576 NewFD->setIsMultiVersion();
11595 NewFD->setIsMultiVersion();
11602 S.Diag(NewFD->getLocation(), diag::err_cpu_dispatch_mismatch);
11604 NewFD->setInvalidDecl();
11615 NewFD->setIsMultiVersion();
11625 S.Diag(NewFD->getLocation(), diag::err_cpu_specific_multiple_defs)
11628 NewFD->setInvalidDecl();
11644 CheckMultiVersionValue(S, NewFD)) {
11645 NewFD->setInvalidDecl();
11649 if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD,
11651 NewFD->setInvalidDecl();
11658 NewFD->setIsMultiVersion();
11664 NewFD->setIsMultiVersion();
11674 /// This sets NewFD->isInvalidDecl() to true if there was an error.
11677 static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD,
11680 const auto *NewTA = NewFD->getAttr<TargetAttr>();
11681 const auto *NewTVA = NewFD->getAttr<TargetVersionAttr>();
11682 const auto *NewCPUDisp = NewFD->getAttr<CPUDispatchAttr>();
11683 const auto *NewCPUSpec = NewFD->getAttr<CPUSpecificAttr>();
11684 const auto *NewClones = NewFD->getAttr<TargetClonesAttr>();
11685 MultiVersionKind MVKind = NewFD->getMultiVersionKind();
11690 if (NewFD->isMain()) {
11695 S.Diag(NewFD->getLocation(), diag::err_multiversion_not_allowed_on_main);
11696 NewFD->setInvalidDecl();
11714 NewFD->getDeclContext()->getRedeclContext())) {
11719 return CheckMultiVersionFirstFunction(S, NewFD);
11732 S.Diag(NewFD->getLocation(), diag::err_multiversion_required_in_redecl)
11734 NewFD->setInvalidDecl();
11743 S, OldFD, NewFD, Redeclaration, OldDecl, Previous);
11746 NewFD->setInvalidDecl();
11747 return S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used);
11762 return CheckMultiVersionAdditionalDecl(S, OldFD, NewFD, NewCPUDisp,
11767 static void CheckConstPureAttributesUsage(Sema &S, FunctionDecl *NewFD) {
11768 bool IsPure = NewFD->hasAttr<PureAttr>();
11769 bool IsConst = NewFD->hasAttr<ConstAttr>();
11780 S.Diag(NewFD->getLocation(), diag::warn_const_attr_with_pure_attr);
11781 NewFD->dropAttrs<PureAttr>();
11786 if (NewFD->getReturnType()->isVoidType()) {
11787 S.Diag(NewFD->getLocation(), diag::warn_pure_function_returns_void)
11789 NewFD->dropAttrs<PureAttr, ConstAttr>();
11793 bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
11797 assert(!NewFD->getReturnType()->isVariablyModifiedType() &&
11813 // Determine whether NewFD is an overload of PrevDecl or
11817 if (!AllowOverloadingOfFunction(Previous, Context, NewFD)) {
11819 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
11825 switch (CheckOverload(S, NewFD, Previous, OldDecl,
11844 checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) {
11854 NewFD->hasAttr<OverloadableAttr>()) {
11855 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) {
11864 if (CheckMultiVersionFunction(*this, NewFD, Redeclaration, OldDecl, Previous))
11869 PPC().CheckPPCMMAType(NewFD->getReturnType(), NewFD->getLocation())) {
11870 NewFD->setInvalidDecl();
11873 CheckConstPureAttributesUsage(*this, NewFD);
11895 (NewFD->isDependentContext() &&
11896 NewFD->getReturnType()->isUndeducedType())) {
11898 NewFD->getType()->castAs<FunctionProtoType>();
11900 NewFD->setType(Context.getFunctionType(NewReturnType, FPT->getParamTypes(),
11913 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
11943 // NewFD and OldDecl represent declarations that need to be
11945 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious,
11947 NewFD->setInvalidDecl();
11958 = NewFD->getDescribedFunctionTemplate();
11966 NewFD->setPreviousDeclaration(OldFD);
11967 if (NewFD->isCXXClassMember()) {
11968 NewFD->setAccess(OldTemplateDecl->getAccess());
11989 if (shouldLinkDependentDeclWithPrevious(NewFD, OldDecl)) {
11992 NewFD->setPreviousDeclaration(OldFD);
11993 if (NewFD->isCXXClassMember())
11994 NewFD->setAccess(OldFD->getAccess());
11998 !NewFD->getAttr<OverloadableAttr>()) {
12012 Diag(NewFD->getLocation(),
12018 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
12023 OpenMP().ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(NewFD);
12029 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
12032 dyn_cast<CXXDestructorDecl>(NewFD)) {
12039 if (NewFD->getFriendObjectKind() == Decl::FriendObjectKind::FOK_None ||
12046 if (NewFD->getDeclName() != Name) {
12047 Diag(NewFD->getLocation(), diag::err_destructor_name);
12048 NewFD->setInvalidDecl();
12052 } else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
12064 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
12070 if (Method->isVirtual() && NewFD->getTrailingRequiresClause())
12073 Diag(NewFD->getTrailingRequiresClause()->getBeginLoc(),
12080 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(NewFD))
12084 if (NewFD->isOverloadedOperator() &&
12085 CheckOverloadedOperatorDeclaration(NewFD)) {
12086 NewFD->setInvalidDecl();
12091 if (NewFD->getLiteralIdentifier() &&
12092 CheckLiteralOperatorDeclaration(NewFD)) {
12093 NewFD->setInvalidDecl();
12101 CheckCXXDefaultArguments(NewFD);
12107 if (Previous.empty() && NewFD->isExternC()) {
12108 QualType R = NewFD->getReturnType();
12110 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
12111 << NewFD << R;
12114 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
12126 if (!getLangOpts().CPlusPlus17 && !NewFD->getPrimaryTemplate()) {
12143 auto *FPT = NewFD->getType()->castAs<FunctionProtoType>();
12148 Diag(NewFD->getLocation(),
12150 << NewFD;
12154 CUDA().checkTargetOverload(NewFD, Previous);
12161 const auto *Attr = NewFD->getAttr<ArmNewAttr>();
12162 bool UsesSM = NewFD->hasAttr<ArmLocallyStreamingAttr>();
12166 if (NewFD->hasAttr<ArmLocallyStreamingAttr>()) {
12167 if (NewFD->getReturnType()->isSizelessVectorType())
12168 Diag(NewFD->getLocation(),
12171 if (llvm::any_of(NewFD->parameters(), [](ParmVarDecl *P) {
12174 Diag(NewFD->getLocation(),
12178 if (const auto *FPT = NewFD->getType()->getAs<FunctionProtoType>()) {
12190 Context.getFunctionFeatureMap(FeatureMap, NewFD);
12193 Diag(NewFD->getLocation(),
12196 Diag(NewFD->getLocation(),
12202 Context.getFunctionFeatureMap(FeatureMap, NewFD);
12204 Diag(NewFD->getLocation(),
18306 FieldDecl *NewFD
18310 if (NewFD->isInvalidDecl())
18314 NewFD->setModulePrivate();
18316 if (NewFD->isInvalidDecl() && PrevDecl) {
18317 // Don't introduce NewFD into scope; there's already something
18320 PushOnScopeChains(NewFD, S);
18322 Record->addDecl(NewFD);
18324 return NewFD;
18449 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
18452 NewFD->setInvalidDecl();
18458 NewFD->setInvalidDecl();
18471 if (CheckNontrivialField(NewFD))
18472 NewFD->setInvalidDecl();
18480 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
18483 << NewFD->getDeclName() << EltTy;
18485 NewFD->setInvalidDecl();
18494 ProcessDeclAttributes(getCurScope(), NewFD, *D);
18496 if (NewFD->hasAttrs())
18497 CheckAlignasUnderalignment(NewFD);
18502 if (getLangOpts().ObjCAutoRefCount && ObjC().inferObjCARCLifetime(NewFD))
18503 NewFD->setInvalidDecl();
18510 PPC().CheckPPCMMAType(T, NewFD->getLocation()))
18511 NewFD->setInvalidDecl();
18513 NewFD->setAccess(AS);
18514 return NewFD;