clang-tidy readability-function-size does not check lambda functions or constructors with no statements or lines.

[bartlettroscoe]

While working on extracting function metrics using the clang-tidy checks readability-function-size and readability-function-cognitive-complexity, I noticed that the readability-function-size check does not produce any output for lambda functions, but the readability-function-cognitive-complexity check does.

For example, readability-function-cognitive-complexity produces output for the following inline lambda function:

    for_each_token(entry, [&](const std::string& s) {
      const size_t pos = s.find("main");
      if (pos != std::string::npos) {
        found_main = true;
        main_col   = col_count;
      }
      ++col_count;
    });

showing a cognitive-complexity and nesting-level of 1, but the readability-function-size check does not produce any output.

It would be nice to be able to get metrics about the number of lines, statements, branches, parameters and variables with lambda functions.

Also, it seems that the readability-function-size check does not produce output for constructors with no statements in the body.
For example, the readability-function-size check produces no output for the inline constructor:

class any {
public:
  ...
  //! Copy constructor
  any(const any & other)
    : content(other.content ? other.content->clone() : 0)
    {}
  ...
};

Now, that function has a non-zero number of parameters, so the readability-function-size check should produce output showing that.

NOTE: I am using the following configuration file so these checks should produce output if any of these metrics are greater than zero:

Checks: '-*,readability-function-cognitive-complexity,readability-function-size'
CheckOptions:
  - key: readability-function-cognitive-complexity.Threshold
    value: '0'
  - key: readability-function-cognitive-complexity.DescribeBasicIncrements
    value: true
  - key: readability-function-cognitive-complexity.IgnoreMacros
    value: true
  - key: readability-function-size.LineThreshold
    value: '0'
  - key: readability-function-size.StatementThreshold
    value: '0'
  - key: readability-function-size.BranchThreshold
    value: '0'
  - key: readability-function-size.ParameterThreshold
    value: '0'
  - key: readability-function-size.NestingThreshold
    value: '0'
  - key: readability-function-size.VariableThreshold
    value: '0'

[llvmbot]

@llvm/issue-subscribers-clang-tidy

Author: Roscoe A. Bartlett (bartlettroscoe)

While working on extracting function metrics using the `clang-tidy` checks `readability-function-size` and `readability-function-cognitive-complexity`, I noticed that the `readability-function-size` check does not produce any output for lambda functions, but the `readability-function-cognitive-complexity` check does. It would be nice to be able to get metrics about the number of lines, statements, branches, parameters and variables with lambda functions.

[bartlettroscoe]

But note that if the constructor has at least one line or statement like:

template<class T>
inline
RCP<T>::RCP(RCP<T>&& r_ptr)
  : ptr_(r_ptr.ptr_), node_(std::move(r_ptr.node_))
{
  r_ptr.ptr_ = 0;
}

the readability-function-size check does produce output and I can get the metrics:

  {
    "name": "RCP<T>",
    "type": "function",
    "location": "packages/teuchos/core/src/Teuchos_RCP.hpp:254:9",
    "code-line": "RCP<T>::RCP(RCP<T>&& r_ptr)",
    "cognitive-complexity": 0,
    "nesting-level": 0,
    "num-lines": 2,
    "num-statements": 1,
    "num-branches": 0,
    "num-parameters": 1,
    "num-variables": 0
  },

[vbvictor]

Could you please provide a minimal reproduction on readability-function-size with latest clang-tidy version using godbolt.
Here is a small template for readability-function-size. https://godbolt.org/z/rr33e4qxz
Modify CheckOptions as you need.

[bartlettroscoe]

@vbvictor, here is the reproducer for readability-function-size not providing output for a constructor with no statements but has non-zero parameters: https://godbolt.org/z/Whn59K531

The readability-function-size check produces no output for the constructor:

  A(int val_1):
    val_1_(val_1),
    val_2_(0)
    {}

but it should provide output showing there is 1 parameter like:

<source>:6:3: warning: function 'A' exceeds recommended size/complexity thresholds [readability-function-size]
    6 |   A(int val_1):
      |   ^
<source>:6:3: note: 1 parameters (threshold 0)

But if you add a statement to the constructor body:

  A(int val_1):
    val_1_(val_1),
    val_2_(0)
    {val_2_ = val_1_;}

as shown in https://godbolt.org/z/Th4cx77zr, it does provide the proper output:

<source>:6:3: warning: function 'A' exceeds recommended size/complexity thresholds [readability-function-size]
    6 |   A(int val_1):
      |   ^
<source>:6:3: note: 1 statements (threshold 0)
<source>:6:3: note: 1 parameters (threshold 0)
<source>:9:5: note: nesting level 1 starts here (threshold 0)
    9 |     {val_2_ = val_1_;}
      |     ^

[bartlettroscoe]

@vbvictor, here is a reproducer for the readability-function-size check not providing any output for lambda functions but the readability-function-cognitive-complexity check does: https://godbolt.org/z/evvhb69xq

This is for the lambda function:

  auto lambdaFunc = [](int val) {
    if (-4 < val && val < 0) {
        return val;
    }
    return val*val;
    };

The readability-function-cognitive-complexity check does provide the output:

<source>:5:21: warning: lambda has cognitive complexity of 2 (threshold 0) [readability-function-cognitive-complexity]
    5 |   auto lambdaFunc = [](int val) {
      |                     ^
<source>:6:5: note: +1, including nesting penalty of 0, nesting level increased to 1
    6 |     if (-4 < val && val < 0) {
      |     ^
<source>:6:18: note: +1
    6 |     if (-4 < val && val < 0) {
      |                  ^

but there is no output at all for the readability-function-size check.

We have a code base that has non-trivial lambda functions with cognitive-complexities up to 104 (with a nesting-level of 7, see here), but we have no metrics for the number of parameters, number of statements, number of branches, number of variables, etc.

[bartlettroscoe]

Respond to #131126 (comment) here (since this issue is about lambdas not reporting readability-function-size metrics) ...

lambdas currently not matched by design, but I think an option can be made for that.

That would be great! Thanks for considering this!

Would you call this new option something like:

• IncludeLambdaFunctions
  • If set to true, the check will compute, check, and report metrics for lambda functions as well, in addition to the parent functions for the lambda functions. Note, this will result in metrics being double reported for lambdas and their parent (lambda or non-lambda) functions because metrics for parent functions include metrics for the lambda functions defined inside of them. Default is false.

The issue is that the readability-function-cognitive-complexity check does report metrics for lambda functions, so it is inconsistent for the readability-function-size check not to as well.

I know that reporting line counts for lambda functions separate from the parent functions where they are defined is reporting metrics for the same code twice, but the readability-function-cognitive-complexity check is already does duplicate reporting of complexity as shown in https://godbolt.org/z/evvhb69xq for the function main():

int main() {
  auto lambdaFunc = [](int val) {
    if (-4 < val && val < 0) {
        return val;
    }
    return val*val;
    };
  std::cout << "lambdaFunc(-2) = " << lambdaFunc(-2) << "\n";
  std::cout << "lambdaFunc(3) = " << lambdaFunc(3) << "\n";
}

which produces the readability-function-cognitive-complexity complexity output for main():

<source>:4:5: warning: function 'main' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
    4 | int main() {
      |     ^

as well as for the lambda function defined inside of main():

<source>:5:21: warning: lambda has cognitive complexity of 2 (threshold 0) [readability-function-cognitive-complexity]
    5 |   auto lambdaFunc = [](int val) {
      |                     ^

Well, the cognitive complexity of 3 for main() includes the cognitive complexity of 2 for the lambda function. So this is technically double reporting the same complexity data. But one can argue this is useful and would be useful for readability-function-size complexity metrics as well.