Author: Doug Wyatt Date: 2025-07-16T08:24:28-07:00 New Revision: cfc20ea15eea5704a79dd4e8d0eaeef4cf053268
URL: https://github.com/llvm/llvm-project/commit/cfc20ea15eea5704a79dd4e8d0eaeef4cf053268 DIFF: https://github.com/llvm/llvm-project/commit/cfc20ea15eea5704a79dd4e8d0eaeef4cf053268.diff LOG: [Clang] FunctionEffects: Make a separate diagnostic group for redeclarations/overrides where effects are implicit. (#148690) The current function effect diagnostics include these behaviors: When you declare a function `nonblocking` (typically in a header) and then omit the attribute on the implementation (or any other redeclaration), Clang warns: attribute 'nonblocking' on function does not match previous declaration. But if a `nonblocking` function is a C++ virtual method, then overrides are implicitly nonblocking; the attribute doesn't need to be explicitly stated. These behaviors are arguably inconsistent -- and also, both, more pedantic than the rest of the function effect diagnostics. This PR accomplishes two things: - Separates the diagnostic on a redeclaration into a new group, `-Wfunction-effect-redeclarations`, so it can be disabled independently. - Adds a second diagnostic to this new group, for the case of an override method missing the attribute. (This helps in a situation where I'm trying to add `nonblocking` via a macro that does other things and I want to know that the macro is missing on an override declaration.) --------- Co-authored-by: Doug Wyatt <dwy...@apple.com> Co-authored-by: Sirraide <aeternalm...@gmail.com> Added: Modified: clang/docs/ReleaseNotes.rst clang/include/clang/Basic/DiagnosticGroups.td clang/include/clang/Basic/DiagnosticSemaKinds.td clang/lib/Sema/SemaDeclCXX.cpp clang/test/Sema/attr-nonblocking-sema.cpp Removed: ################################################################################ diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 2f1705ba7db06..fcd3887ec7a09 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -710,6 +710,12 @@ Improvements to Clang's diagnostics pointer, provided it can be proven that the pointer only points to ``[[noreturn]]`` functions. +- Added a separate diagnostic group ``-Wfunction-effect-redeclarations``, for the more pedantic + diagnostics for function effects (``[[clang::nonblocking]]`` and ``[[clang::nonallocating]]``). + Moved the warning for a missing (though implied) attribute on a redeclaration into this group. + Added a new warning in this group for the case where the attribute is missing/implicit on + an override of a virtual method. + Improvements to Clang's time-trace ---------------------------------- diff --git a/clang/include/clang/Basic/DiagnosticGroups.td b/clang/include/clang/Basic/DiagnosticGroups.td index c28a919e35d08..ccb18aa37447e 100644 --- a/clang/include/clang/Basic/DiagnosticGroups.td +++ b/clang/include/clang/Basic/DiagnosticGroups.td @@ -1293,6 +1293,7 @@ def ThreadSafetyBeta : DiagGroup<"thread-safety-beta">; // Warnings and notes related to the function effects system which underlies // the nonblocking and nonallocating attributes. def FunctionEffects : DiagGroup<"function-effects">; +def FunctionEffectRedeclarations : DiagGroup<"function-effect-redeclarations">; def PerfConstraintImpliesNoexcept : DiagGroup<"perf-constraint-implies-noexcept">; // Uniqueness Analysis warnings diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 2781ff81ab4cf..e94e91cbd56d9 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -11530,17 +11530,28 @@ def note_in_evaluating_default_argument : Note< def warn_invalid_add_func_effects : Warning< "attribute '%0' should not be added via type conversion">, InGroup<FunctionEffects>, DefaultIgnore; -def warn_mismatched_func_effect_override : Warning< - "attribute '%0' on overriding function does not match base declaration">, - InGroup<FunctionEffects>, DefaultIgnore; -def warn_mismatched_func_effect_redeclaration : Warning< - "attribute '%0' on function does not match previous declaration">, - InGroup<FunctionEffects>, DefaultIgnore; +def warn_conflicting_func_effect_override + : Warning<"attribute '%0' on overriding function conflicts with base " + "declaration">, + InGroup<FunctionEffects>, + DefaultIgnore; def warn_conflicting_func_effects : Warning< "effects conflict when merging declarations; kept '%0', discarded '%1'">, InGroup<FunctionEffects>, DefaultIgnore; def err_func_with_effects_no_prototype : Error< "'%0' function must have a prototype">; +// These are more pedantic: in redeclarations and virtual method overrides, +// the effect attribute(s) should be restated. +def warn_mismatched_func_effect_override + : Warning<"overriding function is missing '%0' attribute from base " + "declaration">, + InGroup<FunctionEffectRedeclarations>, + DefaultIgnore; +def warn_mismatched_func_effect_redeclaration + : Warning< + "redeclaration is missing '%0' attribute from previous declaration">, + InGroup<FunctionEffectRedeclarations>, + DefaultIgnore; } // end of sema category diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index f60ab4f0da7a0..c8638420aebb5 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -18682,7 +18682,7 @@ bool Sema::CheckOverridingFunctionAttributes(CXXMethodDecl *New, case FunctionEffectDiff::OverrideResult::NoAction: break; case FunctionEffectDiff::OverrideResult::Warn: - Diag(New->getLocation(), diag::warn_mismatched_func_effect_override) + Diag(New->getLocation(), diag::warn_conflicting_func_effect_override) << Diff.effectName(); Diag(Old->getLocation(), diag::note_overridden_virtual_function) << Old->getReturnTypeSourceRange(); @@ -18695,6 +18695,14 @@ bool Sema::CheckOverridingFunctionAttributes(CXXMethodDecl *New, QualType ModQT = Context.getFunctionType(NewFT->getReturnType(), NewFT->getParamTypes(), EPI); New->setType(ModQT); + if (Errs.empty()) { + // A warning here is somewhat pedantic. Skip this if there was + // already a merge conflict, which is more serious. + Diag(New->getLocation(), diag::warn_mismatched_func_effect_override) + << Diff.effectName(); + Diag(Old->getLocation(), diag::note_overridden_virtual_function) + << Old->getReturnTypeSourceRange(); + } break; } } diff --git a/clang/test/Sema/attr-nonblocking-sema.cpp b/clang/test/Sema/attr-nonblocking-sema.cpp index f13cc783dfc33..c8fb40693eec0 100644 --- a/clang/test/Sema/attr-nonblocking-sema.cpp +++ b/clang/test/Sema/attr-nonblocking-sema.cpp @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -fsyntax-only -fblocks -fcxx-exceptions -verify -Wfunction-effects %s -// RUN: %clang_cc1 -fsyntax-only -fblocks -verify -x c -std=c23 -Wfunction-effects %s +// RUN: %clang_cc1 -fsyntax-only -fblocks -fcxx-exceptions -verify -Wfunction-effects -Wfunction-effect-redeclarations %s +// RUN: %clang_cc1 -fsyntax-only -fblocks -verify -x c -std=c23 -Wfunction-effects -Wfunction-effect-redeclarations %s #if !__has_attribute(nonblocking) #error "the 'nonblocking' attribute is not available" @@ -127,29 +127,35 @@ void type_conversions_2() #endif // --- VIRTUAL METHODS --- -// Attributes propagate to overridden methods, so no diagnostics except for conflicts. +// Attributes propagate to overridden methods. // Check this in the syntax tests too. #ifdef __cplusplus struct Base { virtual void f1(); - virtual void nonblocking() noexcept [[clang::nonblocking]]; - virtual void nonallocating() noexcept [[clang::nonallocating]]; + virtual void nonblocking() noexcept [[clang::nonblocking]]; // expected-note {{overridden virtual function is here}} + virtual void nonallocating() noexcept [[clang::nonallocating]]; // expected-note {{overridden virtual function is here}} virtual void f2() [[clang::nonallocating]]; // expected-note {{previous declaration is here}} + virtual void f3() [[clang::nonblocking]]; // expected-note {{overridden virtual function is here}} }; struct Derived : public Base { void f1() [[clang::nonblocking]] override; - void nonblocking() noexcept override; - void nonallocating() noexcept override; + void nonblocking() noexcept override; // expected-warning {{overriding function is missing 'nonblocking' attribute from base declaration}} + void nonallocating() noexcept override; // expected-warning {{overriding function is missing 'nonallocating' attribute from base declaration}} void f2() [[clang::allocating]] override; // expected-warning {{effects conflict when merging declarations; kept 'allocating', discarded 'nonallocating'}} }; + +template <bool B> +struct TDerived : public Base { + void f3() [[clang::nonblocking(B)]] override; // expected-warning {{attribute 'nonblocking' on overriding function conflicts with base declaration}} +}; #endif // __cplusplus // --- REDECLARATIONS --- void f2(); void f2() [[clang::nonblocking]]; // expected-note {{previous declaration is here}} -void f2(); // expected-warning {{attribute 'nonblocking' on function does not match previous declaration}} +void f2(); // expected-warning {{redeclaration is missing 'nonblocking' attribute from previous declaration}} // Note: we verify that the attribute is actually seen during the constraints tests. void f3() [[clang::blocking]]; // expected-note {{previous declaration is here}} _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
