[clang-tidy] Added a new option to lambda-function-name to ignore warnings in macro expansion

[felix642]

Summary

Improved check lambda-function-name with option IgnoreMacros to ignore warnings in macro expansion.
Relates to #62857 (https://github.com/llvm/llvm-project/issues/62857)

[PiotrZSL]

Missing storeOptions metod, everyting else looks +- fine.

clang-tools-extra/clang-tidy/bugprone/LambdaFunctionNameCheck.cpp

97

Better would be to check IgnoreMacros before we read ER, in separate if

clang-tools-extra/clang-tidy/bugprone/LambdaFunctionNameCheck.h

35

use getLocalOrGlobal, in future it may become more usefull

41

Missing storeOptions metod

[felix642]

Code review

Move constructor to cpp file
Added store options

[felix642]

Updated commit message

[PiotrZSL]

LGTM

clang-tools-extra/clang-tidy/bugprone/LambdaFunctionNameCheck.cpp

91–93

[felix642]

Updated format

[felix642]

HI @PiotrZSL, I do not have the rights to commit to the LLVM repository. Could you please commit those changes for me?

clang-tools-extra/clang-tidy/bugprone/LambdaFunctionNameCheck.h

bool operator()(const SourceRange &L, const SourceRange &R) const {
       if (L.getBegin() == R.getBegin()) {
         return L.getEnd() < R.getEnd();
       }
       return L.getBegin() < R.getBegin();
     }
   };
   using SourceRangeSet = std::set<SourceRange, SourceRangeLessThan>;
 
-  LambdaFunctionNameCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
+  LambdaFunctionNameCheck(StringRef Name, ClangTidyContext *Context);
+
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   SourceRangeSet SuppressMacroExpansions;
+  bool IgnoreMacros;
 };
 
 } // namespace clang::tidy::bugprone
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_LAMBDAFUNCTIONNAMECHECK_H

clang-tools-extra/clang-tidy/bugprone/LambdaFunctionNameCheck.cpp

 #include "clang/Lex/Preprocessor.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::bugprone {
 
 namespace {
 
+static constexpr bool DefaultIgnoreMacros = false;
+
 // Keep track of macro expansions that contain both __FILE__ and __LINE__. If
 // such a macro also uses __func__ or __FUNCTION__, we don't want to issue a
 // warning because __FILE__ and __LINE__ may be useful even if __func__ or
 // __FUNCTION__ is not, especially if the macro could be used in the context of
 // either a function body or a lambda body.
 class MacroExpansionsWithFileAndLine : public PPCallbacks {
 public:
   explicit MacroExpansionsWithFileAndLine(
public:
   }
 
 private:
   LambdaFunctionNameCheck::SourceRangeSet* SuppressMacroExpansions;
 };
 
 } // namespace
 
+LambdaFunctionNameCheck::LambdaFunctionNameCheck(StringRef Name,
+                                                 ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      IgnoreMacros(
+          Options.getLocalOrGlobal("IgnoreMacros", DefaultIgnoreMacros)) {}
+
+void LambdaFunctionNameCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IgnoreMacros", IgnoreMacros);
+}
+
 void LambdaFunctionNameCheck::registerMatchers(MatchFinder *Finder) {
   // Match on PredefinedExprs inside a lambda.
   Finder->addMatcher(predefinedExpr(hasAncestor(lambdaExpr())).bind("E"),
                      this);
 }
 
 void LambdaFunctionNameCheck::registerPPCallbacks(
     const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
   PP->addPPCallbacks(std::make_unique<MacroExpansionsWithFileAndLine>(
       &SuppressMacroExpansions));
 }
 
 void LambdaFunctionNameCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getNodeAs<PredefinedExpr>("E");
   if (E->getIdentKind() != PredefinedExpr::Func &&
       E->getIdentKind() != PredefinedExpr::Function) {
     // We don't care about other PredefinedExprs.
     return;
   }
   if (E->getLocation().isMacroID()) {
+    if (IgnoreMacros)
+      return;
+
     auto ER =
         Result.SourceManager->getImmediateExpansionRange(E->getLocation());
     if (SuppressMacroExpansions.find(ER.getAsRange()) !=
         SuppressMacroExpansions.end()) {
       // This is a macro expansion for which we should not warn.
       return;
     }
   }
+
   diag(E->getLocation(),
        "inside a lambda, '%0' expands to the name of the function call "
        "operator; consider capturing the name of the enclosing function "
        "explicitly")
       << PredefinedExpr::getIdentKindName(E->getIdentKind());
 }
 
 } // namespace clang::tidy::bugprone

clang-tools-extra/docs/ReleaseNotes.rst

 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Fixed bug in :doc:`bugprone-reserved-identifier
   <clang-tidy/checks/bugprone/reserved-identifier>`, so that it does not warn
   on macros starting with underscore and lowercase letter.
 
+- Improved :doc:`bugprone-lambda-function-name
+  <clang-tidy/checks/bugprone/lambda-function-name>` check by adding option
+  `IgnoreMacros` to ignore warnings in macros.
+
 - Improved :doc:`cppcoreguidelines-avoid-non-const-global-variables
   <clang-tidy/checks/cppcoreguidelines/avoid-non-const-global-variables>` check
   to ignore ``static`` variables declared within the scope of
   ``class``/``struct``.
 
 - Improved :doc:`cppcoreguidelines-prefer-member-initializer
   <clang-tidy/checks/cppcoreguidelines/prefer-member-initializer>` check to
   ignore delegate constructors.

clang-tools-extra/docs/clang-tidy/checks/bugprone/lambda-function-name.rst

Output::
 
   Called from operator()
   Now called from operator()
 
 Likely intended output::
 
   Called from FancyFunction
   Now called from FancyFunction
+
+Options
+-------
+
+.. option::  IgnoreMacros
+
+  The value `true` specifies that attempting to get the name of a function from
+  within a macro should not be diagnosed. The default value is `false`.

clang-tools-extra/test/clang-tidy/checkers/bugprone/lambda-function-name.cpp

-// RUN: %check_clang_tidy %s bugprone-lambda-function-name %t
+// RUN: %check_clang_tidy -check-suffixes=,NO-CONFIG %s bugprone-lambda-function-name %t
+// RUN: %check_clang_tidy %s bugprone-lambda-function-name %t -- -config="{CheckOptions: [{key: bugprone-lambda-function-name.IgnoreMacros, value: true}]}" --
+
 
 void Foo(const char* a, const char* b, int c) {}
 
 #define FUNC_MACRO Foo(__func__, "", 0)
 #define FUNCTION_MACRO Foo(__FUNCTION__, "", 0)
 #define EMBED_IN_ANOTHER_MACRO1 FUNC_MACRO
 
 void Positives() {
   [] { __func__; }();
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: inside a lambda, '__func__' expands to the name of the function call operator; consider capturing the name of the enclosing function explicitly [bugprone-lambda-function-name]
   [] { __FUNCTION__; }();
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: inside a lambda, '__FUNCTION__' expands to the name of the function call operator; consider capturing the name of the enclosing function explicitly [bugprone-lambda-function-name]
   [] { FUNC_MACRO; }();
-  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: inside a lambda, '__func__' expands to the name of the function call operator; consider capturing the name of the enclosing function explicitly [bugprone-lambda-function-name]
+  // CHECK-MESSAGES-NO-CONFIG: :[[@LINE-1]]:8: warning: inside a lambda, '__func__' expands to the name of the function call operator; consider capturing the name of the enclosing function explicitly [bugprone-lambda-function-name]
   [] { FUNCTION_MACRO; }();
-  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: inside a lambda, '__FUNCTION__' expands to the name of the function call operator; consider capturing the name of the enclosing function explicitly [bugprone-lambda-function-name]
+  // CHECK-MESSAGES-NO-CONFIG: :[[@LINE-1]]:8: warning: inside a lambda, '__FUNCTION__' expands to the name of the function call operator; consider capturing the name of the enclosing function explicitly [bugprone-lambda-function-name]
   [] { EMBED_IN_ANOTHER_MACRO1; }();
-  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: inside a lambda, '__func__' expands to the name of the function call operator; consider capturing the name of the enclosing function explicitly [bugprone-lambda-function-name]
+  // CHECK-MESSAGES-NO-CONFIG: :[[@LINE-1]]:8: warning: inside a lambda, '__func__' expands to the name of the function call operator; consider capturing the name of the enclosing function explicitly [bugprone-lambda-function-name]
 }
 
 #define FUNC_MACRO_WITH_FILE_AND_LINE Foo(__func__, __FILE__, __LINE__)
 #define FUNCTION_MACRO_WITH_FILE_AND_LINE Foo(__FUNCTION__, __FILE__, __LINE__)
 #define EMBED_IN_ANOTHER_MACRO2 FUNC_MACRO_WITH_FILE_AND_LINE
 
 void Negatives() {
   __func__;