[all-commits] [llvm/llvm-project] 8a944d: [clang-tidy] Add option to ignore macros in readab...

[alexfh via All-commits]

  Branch: refs/heads/main
  Home:   https://github.com/llvm/llvm-project
  Commit: 8a944d82cd14001a92ef088229041ee0fb1fd1e6
      https://github.com/llvm/llvm-project/commit/8a944d82cd14001a92ef088229041ee0fb1fd1e6
  Author: Jens Massberg <massberg at google.com>
  Date:   2021-04-12 (Mon, 12 Apr 2021)

  Changed paths:
    M clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp
    M clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.h
    M clang-tools-extra/docs/clang-tidy/checks/readability-function-cognitive-complexity.rst
    M clang-tools-extra/test/clang-tidy/checkers/readability-function-cognitive-complexity-flags.cpp

  Log Message:
  -----------
  [clang-tidy] Add option to ignore macros in readability-function-cognitive-complexity check.

(this was originally part of https://reviews.llvm.org/D96281 and has been split off into its own patch)

If a macro is used within a function, the code inside the macro
doesn't make the code less readable. Instead, for a reader a macro is
more like a function that is called. Thus the code inside a macro
shouldn't increase the complexity of the function in which it is called.
Thus the flag 'IgnoreMacros' is added. If set to 'true' code inside
macros isn't considered during analysis.

This isn't perfect, as now the code of a macro isn't considered at all,
even if it has a high cognitive complexity itself. It might be better if
a macro is considered in the analysis like a function and gets its own
cognitive complexity. Implementing such an analysis seems to be very
complex (if possible at all with the given AST), so we give the user the
option to either ignore macros completely or to let the expanded code
count to the calling function's complexity.

See the code example from vgeof (originally added as note in https://reviews.llvm.org/D96281)

   bool doStuff(myClass* objectPtr){
         if(objectPtr == nullptr){
             LOG_WARNING("empty object");
             return false;
         }
         if(objectPtr->getAttribute() == nullptr){
             LOG_WARNING("empty object");
             return false;
         }
         use(objectPtr->getAttribute());
     }

The LOG_WARNING macro itself might have a high complexity, but it do not make the
the function more complex to understand like e.g. a 'printf'.

By default 'IgnoreMacros' is set to 'false', which is the original behavior of the check.

Reviewed By: lebedev.ri, alexfh

Differential Revision: https://reviews.llvm.org/D98070


  Commit: 8883cb3e4004aebddf9bd0f92ea47ba897397794
      https://github.com/llvm/llvm-project/commit/8883cb3e4004aebddf9bd0f92ea47ba897397794
  Author: Alexander Kornienko <alexfh at google.com>
  Date:   2021-04-12 (Mon, 12 Apr 2021)

  Changed paths:
    M clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp
    M clang-tools-extra/docs/clang-tidy/checks/readability-function-cognitive-complexity.rst

  Log Message:
  -----------
  Fix nits.


Compare: https://github.com/llvm/llvm-project/compare/50386fe1db3c...8883cb3e4004