[clang-tidy] readability-function-size: add NestingThreshold param.

[lebedev.ri]

Summary

Finds compound statements which create next nesting level after NestingThreshold and emits a warning.
Do note that it warns about each compound statement that breaches the threshold, but not any of it's sub-statements, to have readable warnings.

I was able to find only one coding style referencing nesting:

• https://www.kernel.org/doc/html/v4.10/process/coding-style.html#indentation > In short, 8-char indents make things easier to read, and have the added benefit of warning you when you’re nesting your functions too deep.

This seems too basic, i'm not sure what else to test. Are more tests needed?

[lebedev.ri]

Actually consider whether there are any such compound statements when outputting initial diagnostic.

[aaron.ballman]

Have you tried running this over a large code base to see how frequently the diagnostic triggers? I'm wondering why 10 was chosen as the default threshold.

clang-tidy/readability/FunctionSizeCheck.cpp

41 ↗

(On Diff #98072)

Comment should start with a capital letter and have punctuation.

compount -> compound

43 ↗

(On Diff #98072)

This can be replaced with TrackedParent.size() == Info.NestingThreshold.

71 ↗

(On Diff #98072)

Remove the newline here.

test/clang-tidy/readability-function-size.cpp

83–86 ↗

(On Diff #98072)

I think these messages would be easier to understand if they were placed near the line the diagnostic triggers.

[lebedev.ri]

Updated according to review notes.
Added one more test case with macro expansion.
Added parameter to one more doc file.

Now parameter defaults to -1 by default, because testing shows that otherwise it should be as high by default as 75+

[lebedev.ri]

clang-tidy/readability/FunctionSizeCheck.cpp

43 ↗

(On Diff #98072)

(IRC)

[18:40:55] <LebedevRI> AaronBallman: are you really sure about TrackedParent.size() == Info.NestingThreshold ? TrackedParent can contain false too..
[18:43:11] <AaronBallman> LebedevRI: nope, I'm definitely wrong there. Thank you for pointing that out. :-D
[18:43:59] <AaronBallman> LebedevRI: instead, consider using llvm::count(TrackedParent, true); It's far more clear as to what you are trying to accomplish.

[aaron.ballman]

clang-tidy/readability/FunctionSizeCheck.h

31 ↗

(On Diff #98345)

Good catch! You should add the parenthetical that explains what the default does (as in the other cases).

34 ↗

(On Diff #98345)

You should add the parenthetical that explains what the default does (as in the other cases).

[lebedev.ri]

Revise the docs.

[aaron.ballman]

LGTM!

[lebedev.ri]

In D32942#751324, @aaron.ballman wrote:

LGTM!

Thanks.
I guess we want to wait a bit more for @alexfh to leave any comment?

[aaron.ballman]

In D32942#751338, @lebedev.ri wrote:

In D32942#751324, @aaron.ballman wrote:

LGTM!

Thanks.
I guess we want to wait a bit more for @alexfh to leave any comment?

You can deal with any of Alex's comments post-commit. If you still don't have commit privileges, now might be a good time to ask Chris Lattner for them: http://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

[alexfh]

clang-tidy/readability/FunctionSizeCheck.cpp

44 ↗

(On Diff #98493)

This code used to be the single hungriest cycle eater in all of clang-tidy, so changing this code should be done very carefully.

In particular, can we avoid calling count on each compound statement? Is it possible to use an additional counter and update it whenever a tracked statement is pushed/popped?

[lebedev.ri]

clang-tidy/readability/FunctionSizeCheck.cpp

44 ↗

(On Diff #98493)

This code used to be the single hungriest cycle eater in all of clang-tidy, so changing this code should be done very carefully.

Good to know. Are there any automated benchmarks for clang-tidy in-tree?

In particular, can we avoid calling count on each compound statement?
Is it possible to use an additional counter and update it whenever a tracked statement is pushed/popped?

Yep, sounds like a pretty safe, straight-forward optimization, will do.

[lebedev.ri]

As suggested by alexfh, use dedicated variable to track the current nesting level.
This results in less operations, namely, no need to foreach through the TrackedParent vector, and count how many of the entries are true each time the new CompoundStmt is encountered.
I did think about doing so in the first place, but decided against it because it seemed to be unnecessary at that time.

[alexfh]

LG

[lebedev.ri]

Thank you.
I'll wait until after D33102 is accepted, then ask for commit rights, and if successful, will either commit myself, or will ask for it to be committed by someone else.

[lebedev.ri]

No changes at all, rebased before commit.

[malcolm.parsons]

Does this check consider else if chains to be nesting?

void nesting() { // 1
  if (true) { // 2
     int j;
  } else if (true) { // 2 or 3?
     int j;
  } else if (true) { // 2 or 4?
     int j;
  } else if (true) { // 2 or 5?
     int j;
  }
}

[lebedev.ri]

In D32942#776915, @malcolm.parsons wrote:

Does this check consider else if chains to be nesting?

void nesting() { // 1
  if (true) { // 2
     int j;
  } else if (true) { // 2 or 3?
     int j;
  } else if (true) { // 2 or 4?
     int j;
  } else if (true) { // 2 or 5?
     int j;
  }
}

Yes, this check, like does consider else if chains to be nesting, as you can see from the following output:

$ ./bin/clang-tidy -checks=readability-function-size -config='{CheckOptions: [{key: readability-function-size.NestingThreshold, value: 2}]}' /tmp/if-nest.cpp
Error while trying to load a compilation database:
Could not auto-detect compilation database for file "/tmp/if-nest.cpp"
No compilation database found in /tmp or any parent directory
json-compilation-database: Error while opening JSON database: No such file or directory
Running without flags.
1 warning generated.
/tmp/if-nest.cpp:1:6: warning: function 'nesting' exceeds recommended size/complexity thresholds [readability-function-size]
void nesting() { // 1
     ^
/tmp/if-nest.cpp:2:13: note: nesting level 3 starts here (threshold 2)
  if (true) { // 2
            ^
/tmp/if-nest.cpp:4:10: note: nesting level 3 starts here (threshold 2)
  } else if (true) { // 2 or 3?
         ^

Which makes sense, since in AST, they are nested:

$ clang -Xclang -ast-dump -fsyntax-only  /tmp/if-nest.cpp
TranslationUnitDecl 0x560a93687b60 <<invalid sloc>> <invalid sloc>
|-TypedefDecl 0x560a936880f0 <<invalid sloc>> <invalid sloc> implicit __int128_t '__int128'
| `-BuiltinType 0x560a93687dd0 '__int128'
|-TypedefDecl 0x560a93688160 <<invalid sloc>> <invalid sloc> implicit __uint128_t 'unsigned __int128'
| `-BuiltinType 0x560a93687df0 'unsigned __int128'
|-TypedefDecl 0x560a936884a8 <<invalid sloc>> <invalid sloc> implicit __NSConstantString 'struct __NSConstantString_tag'
| `-RecordType 0x560a93688250 'struct __NSConstantString_tag'
|   `-CXXRecord 0x560a936881b8 '__NSConstantString_tag'
|-TypedefDecl 0x560a93688540 <<invalid sloc>> <invalid sloc> implicit __builtin_ms_va_list 'char *'
| `-PointerType 0x560a93688500 'char *'
|   `-BuiltinType 0x560a93687bf0 'char'
|-TypedefDecl 0x560a936bd730 <<invalid sloc>> <invalid sloc> implicit __builtin_va_list 'struct __va_list_tag [1]'
| `-ConstantArrayType 0x560a93688820 'struct __va_list_tag [1]' 1 
|   `-RecordType 0x560a93688630 'struct __va_list_tag'
|     `-CXXRecord 0x560a93688598 '__va_list_tag'
`-FunctionDecl 0x560a936bd7e0 </tmp/if-nest.cpp:1:1, line:11:1> line:1:6 nesting 'void (void)'
  `-CompoundStmt 0x560a936bdcb8 <col:16, line:11:1>
    `-IfStmt 0x560a936bdc80 <line:2:3, line:10:3>
      |-<<<NULL>>>
      |-<<<NULL>>>
      |-CXXBoolLiteralExpr 0x560a936bd8b8 <line:2:7> '_Bool' true
      |-CompoundStmt 0x560a936bd960 <col:13, line:4:3>
      | `-DeclStmt 0x560a936bd948 <line:3:6, col:11>
      |   `-VarDecl 0x560a936bd8e8 <col:6, col:10> col:10 j 'int'
      `-IfStmt 0x560a936bdc48 <line:4:10, line:10:3>
        |-<<<NULL>>>
        |-<<<NULL>>>
        |-CXXBoolLiteralExpr 0x560a936bd980 <line:4:14> '_Bool' true
        |-CompoundStmt 0x560a936bda28 <col:20, line:6:3>
        | `-DeclStmt 0x560a936bda10 <line:5:6, col:11>
        |   `-VarDecl 0x560a936bd9b0 <col:6, col:10> col:10 j 'int'
        `-IfStmt 0x560a936bdc10 <line:6:10, line:10:3>
          |-<<<NULL>>>
          |-<<<NULL>>>
          |-CXXBoolLiteralExpr 0x560a936bda48 <line:6:14> '_Bool' true
          |-CompoundStmt 0x560a936bdaf0 <col:20, line:8:3>
          | `-DeclStmt 0x560a936bdad8 <line:7:6, col:11>
          |   `-VarDecl 0x560a936bda78 <col:6, col:10> col:10 j 'int'
          `-IfStmt 0x560a936bdbd8 <line:8:10, line:10:3>
            |-<<<NULL>>>
            |-<<<NULL>>>
            |-CXXBoolLiteralExpr 0x560a936bdb10 <line:8:14> '_Bool' true
            |-CompoundStmt 0x560a936bdbb8 <col:20, line:10:3>
            | `-DeclStmt 0x560a936bdba0 <line:9:6, col:11>
            |   `-VarDecl 0x560a936bdb40 <col:6, col:10> col:10 j 'int'
            `-<<<NULL>>>

However what i'm not totally understanding right now is

/tmp/if-nest.cpp:2:13: note: nesting level 3 starts here (threshold 2)
  if (true) { // 2
            ^

If we look at clang-query output, that *should* be second nesting level...

$ clang-query-5.0 /tmp/if-nest.cpp
Error while trying to load a compilation database:
Could not auto-detect compilation database for file "/tmp/if-nest.cpp"
No compilation database found in /tmp or any parent directory
json-compilation-database: Error while opening JSON database: No such file or directory
Running without flags.
clang-query> match compoundStmt()

Match #1:

/tmp/if-nest.cpp:1:16: note: "root" binds here
void nesting() { // 1
               ^~~~~~

Match #2:

/tmp/if-nest.cpp:2:13: note: "root" binds here
  if (true) { // 2
            ^~~~~~

Match #3:

/tmp/if-nest.cpp:4:20: note: "root" binds here
  } else if (true) { // 2 or 3?
                   ^~~~~~~~~~~~

Match #4:

/tmp/if-nest.cpp:6:20: note: "root" binds here
  } else if (true) { // 2 or 4?
                   ^~~~~~~~~~~~

Match #5:

/tmp/if-nest.cpp:8:20: note: "root" binds here
  } else if (true) { // 2 or 5?
                   ^~~~~~~~~~~~
5 matches.

[malcolm.parsons]

In D32942#777001, @lebedev.ri wrote:

Which makes sense, since in AST, they are nested:

They're not nested in the formatting, so I don't think it makes sense.

[lebedev.ri]

In D32942#778729, @malcolm.parsons wrote:

In D32942#777001, @lebedev.ri wrote:

Which makes sense, since in AST, they are nested:

They're not nested in the formatting, so I don't think it makes sense.

As usual, all the meaningful review happens post-factum :)
So, it should warn on:

void yes_nesting() { // 1
  if (true) {    // 2
    int j;
  } else {
    if (true) { // 2 or 3?
      int j;
    } else {
      if (true) { // 2 or 4?
        int j;
      } else {
        if (true) { // 2 or 5?
          int j;
        }
      }
    }
  }
}

which is

`-FunctionDecl <line:12:1, line:28:1> line:12:6 yes_nesting 'void (void)'
  `-CompoundStmt <col:20, line:28:1>
    `-IfStmt <line:13:3, line:27:3>
      |-<<<NULL>>>
      |-<<<NULL>>>
      |-CXXBoolLiteralExpr <line:13:7> '_Bool' true
      |-CompoundStmt <col:13, line:15:3>
      | `-DeclStmt <line:14:5, col:10>
      |   `-VarDecl <col:5, col:9> col:9 j 'int'
      `-CompoundStmt <line:15:10, line:27:3>
        `-IfStmt <line:16:5, line:26:5>
          |-<<<NULL>>>
          |-<<<NULL>>>
          |-CXXBoolLiteralExpr <line:16:9> '_Bool' true
          |-CompoundStmt <col:15, line:18:5>
          | `-DeclStmt <line:17:7, col:12>
          |   `-VarDecl <col:7, col:11> col:11 j 'int'
          `-CompoundStmt <line:18:12, line:26:5>
            `-IfStmt <line:19:7, line:25:7>
              |-<<<NULL>>>
              |-<<<NULL>>>
              |-CXXBoolLiteralExpr <line:19:11> '_Bool' true
              |-CompoundStmt <col:17, line:21:7>
              | `-DeclStmt <line:20:9, col:14>
              |   `-VarDecl <col:9, col:13> col:13 j 'int'
              `-CompoundStmt <line:21:14, line:25:7>
                `-IfStmt <line:22:9, line:24:9>
                  |-<<<NULL>>>
                  |-<<<NULL>>>
                  |-CXXBoolLiteralExpr <line:22:13> '_Bool' true
                  |-CompoundStmt <col:19, line:24:9>
                  | `-DeclStmt <line:23:11, col:16>
                  |   `-VarDecl <col:11, col:15> col:15 j 'int'
                  `-<<<NULL>>>

but should not on what you/i posted in the previous comment.
The difference seems to be some kind of implicit CompoundStmt added by IfStmt?
Assuming that is the case, maybe this is as simple as checking whether this CompoundStmt is implicit or not?
Best to move open a new bug about this. I'll see what can be done.

[malcolm.parsons]

In D32942#779143, @lebedev.ri wrote:

In D32942#778729, @malcolm.parsons wrote:

In D32942#777001, @lebedev.ri wrote:

Which makes sense, since in AST, they are nested:

They're not nested in the formatting, so I don't think it makes sense.

As usual, all the meaningful review happens post-factum :)

I didn't get an email about this change until it was pushed.

So, it should warn on:
...
but should not on what you/I posted in the previous comment.

Yes.

The difference seems to be some kind of implicit CompoundStmt added by IfStmt?

CompoundStmt represents the {}.

Assuming that is the case, maybe this is as simple as checking whether this CompoundStmt is implicit or not?

My prototype of this feature used ifStmt(stmt().bind("if"), unless(hasParent(ifStmt(hasElse(equalsBoundNode("if")))))).

Best to move open a new bug about this. I'll see what can be done.

Do you need me to report a bug?

[lebedev.ri]

In D32942#780053, @malcolm.parsons wrote:

In D32942#779143, @lebedev.ri wrote:

In D32942#778729, @malcolm.parsons wrote:

In D32942#777001, @lebedev.ri wrote:

Which makes sense, since in AST, they are nested:

They're not nested in the formatting, so I don't think it makes sense.

As usual, all the meaningful review happens post-factum :)

I didn't get an email about this change until it was pushed.

So, it should warn on:
...
but should not on what you/I posted in the previous comment.

Yes.

The difference seems to be some kind of implicit CompoundStmt added by IfStmt?

CompoundStmt represents the {}.

Assuming that is the case, maybe this is as simple as checking whether this CompoundStmt is implicit or not?

My prototype of this feature used ifStmt(stmt().bind("if"), unless(hasParent(ifStmt(hasElse(equalsBoundNode("if")))))).

The fix should ideally be fully contained in the TraverseStmt(), and should not be noticeably slower.

Best to move open a new bug about this. I'll see what can be done.

(that should have been "Best to open a new bug about this. I'll see what can be done.")

Do you need me to report a bug?

Yes, and assign it to me, if possible.

[lebedev.ri]

Hm, oh, maybe this is as simple as a partially-unintentional switch fallthrough

[malcolm.parsons]

In D32942#780090, @lebedev.ri wrote:

In D32942#780053, @malcolm.parsons wrote:

My prototype of this feature used ifStmt(stmt().bind("if"), unless(hasParent(ifStmt(hasElse(equalsBoundNode("if")))))).

The fix should ideally be fully contained in the TraverseStmt(), and should not be noticeably slower.

Yes, my prototype wasn't part of readability-function-size.

clang-tools-extra/trunk/clang-tidy/readability/FunctionSizeCheck.h

 ///
 ///   * `LineThreshold` - flag functions exceeding this number of lines. The
 ///     default is `-1` (ignore the number of lines).
 ///   * `StatementThreshold` - flag functions exceeding this number of
 ///     statements. This may differ significantly from the number of lines for
 ///     macro-heavy code. The default is `800`.
 ///   * `BranchThreshold` - flag functions exceeding this number of control
 ///     statements. The default is `-1` (ignore the number of branches).
-///   * `ParameterThreshold` - flag functions having a high number of parameters.
-///     The default is `6`.
+///   * `ParameterThreshold` - flag functions having a high number of
+///     parameters. The default is `-1` (ignore the number of parameters).
+///   * `NestingThreshold` - flag compound statements which create next nesting
+///     level after `NestingThreshold`. This may differ significantly from the
+///     expected value for macro-heavy code. The default is `-1` (ignore the
+///     nesting level).
 class FunctionSizeCheck : public ClangTidyCheck {
 public:
   FunctionSizeCheck(StringRef Name, ClangTidyContext *Context);
 
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const unsigned LineThreshold;
   const unsigned StatementThreshold;
   const unsigned BranchThreshold;
   const unsigned ParameterThreshold;
+  const unsigned NestingThreshold;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_FUNCTIONSIZECHECK_H

clang-tools-extra/trunk/clang-tidy/readability/FunctionSizeCheck.cpp

bool TraverseStmt(Stmt *Node) {
     case Stmt::WhileStmtClass:
     case Stmt::DoStmtClass:
     case Stmt::CXXForRangeStmtClass:
     case Stmt::ForStmtClass:
     case Stmt::SwitchStmtClass:
       ++Info.Branches;
     // fallthrough
     case Stmt::CompoundStmtClass:
+      // If this new compound statement is located in a compound statement,
+      // which is already nested NestingThreshold levels deep, record the start
+      // location of this new compound statement
+      if (CurrentNestingLevel == Info.NestingThreshold)
+        Info.NestingThresholders.push_back(Node->getLocStart());
+
+      ++CurrentNestingLevel;
       TrackedParent.push_back(true);
       break;
     default:
       TrackedParent.push_back(false);
       break;
     }
 
     Base::TraverseStmt(Node);
 
+    if (TrackedParent.back())
+      --CurrentNestingLevel;
     TrackedParent.pop_back();
+
     return true;
   }
 
   bool TraverseDecl(Decl *Node) {
     TrackedParent.push_back(false);
     Base::TraverseDecl(Node);
     TrackedParent.pop_back();
     return true;
   }
 
   struct FunctionInfo {
-    FunctionInfo() : Lines(0), Statements(0), Branches(0) {}
-    unsigned Lines;
-    unsigned Statements;
-    unsigned Branches;
+    unsigned Lines = 0;
+    unsigned Statements = 0;
+    unsigned Branches = 0;
+    unsigned NestingThreshold = 0;
+    std::vector<SourceLocation> NestingThresholders;
   };
   FunctionInfo Info;
   std::vector<bool> TrackedParent;
+  unsigned CurrentNestingLevel = 0;
 };
 
 FunctionSizeCheck::FunctionSizeCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       LineThreshold(Options.get("LineThreshold", -1U)),
       StatementThreshold(Options.get("StatementThreshold", 800U)),
       BranchThreshold(Options.get("BranchThreshold", -1U)),
-      ParameterThreshold(Options.get("ParameterThreshold", -1U)) {}
+      ParameterThreshold(Options.get("ParameterThreshold", -1U)),
+      NestingThreshold(Options.get("NestingThreshold", -1U)) {}
 
 void FunctionSizeCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "LineThreshold", LineThreshold);
   Options.store(Opts, "StatementThreshold", StatementThreshold);
   Options.store(Opts, "BranchThreshold", BranchThreshold);
   Options.store(Opts, "ParameterThreshold", ParameterThreshold);
+  Options.store(Opts, "NestingThreshold", NestingThreshold);
 }
 
 void FunctionSizeCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(functionDecl(unless(isInstantiated())).bind("func"), this);
 }
 
 void FunctionSizeCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
 
   FunctionASTVisitor Visitor;
+  Visitor.Info.NestingThreshold = NestingThreshold;
   Visitor.TraverseDecl(const_cast<FunctionDecl *>(Func));
   auto &FI = Visitor.Info;
 
   if (FI.Statements == 0)
     return;
 
   // Count the lines including whitespace and comments. Really simple.
   if (const Stmt *Body = Func->getBody()) {
     SourceManager *SM = Result.SourceManager;
     if (SM->isWrittenInSameFile(Body->getLocStart(), Body->getLocEnd())) {
       FI.Lines = SM->getSpellingLineNumber(Body->getLocEnd()) -
                  SM->getSpellingLineNumber(Body->getLocStart());
     }
   }
 
   unsigned ActualNumberParameters = Func->getNumParams();
 
   if (FI.Lines > LineThreshold || FI.Statements > StatementThreshold ||
       FI.Branches > BranchThreshold ||
-      ActualNumberParameters > ParameterThreshold) {
+      ActualNumberParameters > ParameterThreshold ||
+      !FI.NestingThresholders.empty()) {
     diag(Func->getLocation(),
          "function %0 exceeds recommended size/complexity thresholds")
         << Func;
   }
 
   if (FI.Lines > LineThreshold) {
     diag(Func->getLocation(),
          "%0 lines including whitespace and comments (threshold %1)",
diag(Func->getLocation(), "%0 branches (threshold %1)", DiagnosticIDs::Note)
         << FI.Branches << BranchThreshold;
   }
 
   if (ActualNumberParameters > ParameterThreshold) {
     diag(Func->getLocation(), "%0 parameters (threshold %1)",
          DiagnosticIDs::Note)
         << ActualNumberParameters << ParameterThreshold;
   }
+
+  for (const auto &CSPos : FI.NestingThresholders) {
+    diag(CSPos, "nesting level %0 starts here (threshold %1)",
+         DiagnosticIDs::Note)
+        << NestingThreshold + 1 << NestingThreshold;
+  }
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/docs/ReleaseNotes.rst

- New `modernize-use-noexcept
   Replaces dynamic exception specifications with ``noexcept`` or a user defined macro.
 
 - New `performance-inefficient-vector-operation
   <http://clang.llvm.org/extra/clang-tidy/checks/performance-inefficient-vector-operation.html>`_ check
 
   Finds possible inefficient vector operations in for loops that may cause
   unnecessary memory reallocations.
 
+- Added `NestingThreshold` to `readability-function-size
+  <http://clang.llvm.org/extra/clang-tidy/checks/readability-function-size.html>`_ check
+
+  Finds compound statements which create next nesting level after `NestingThreshold` and emits a warning.
+
 - Added `ParameterThreshold` to `readability-function-size
   <http://clang.llvm.org/extra/clang-tidy/checks/readability-function-size.html>`_ check
 
   Finds functions that have more than `ParameterThreshold` parameters and emits a warning.
 
 - New `readability-misleading-indentation
   <http://clang.llvm.org/extra/clang-tidy/checks/readability-misleading-indentation.html>`_ check
 

clang-tools-extra/trunk/docs/clang-tidy/checks/readability-function-size.rst

 
 .. option:: BranchThreshold
 
    Flag functions exceeding this number of control statements. The default is
    `-1` (ignore the number of branches).
 
 .. option:: ParameterThreshold
 
-   Flag functions that exceed a specified number of parameters. The default 
+   Flag functions that exceed a specified number of parameters. The default
    is `-1` (ignore the number of parameters).
+
+.. option:: NestingThreshold
+
+    Flag compound statements which create next nesting level after
+    `NestingThreshold`. This may differ significantly from the expected value
+    for macro-heavy code. The default is `-1` (ignore the nesting level).

clang-tools-extra/trunk/test/clang-tidy/readability-function-size.cpp

-// RUN: %check_clang_tidy %s readability-function-size %t -- -config='{CheckOptions: [{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: 5}]}' -- -std=c++11
+// RUN: %check_clang_tidy %s readability-function-size %t -- -config='{CheckOptions: [{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: 5}, {key: readability-function-size.NestingThreshold, value: 2}]}' -- -std=c++11
 
 // Bad formatting is intentional, don't run clang-format over the whole file!
 
 void foo1() {
 }
 
 void foo2() {;}
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'foo2' exceeds recommended size/complexity thresholds [readability-function-size]

 // CHECK-MESSAGES: :[[@LINE-7]]:6: note: 1 branches (threshold 0)
 
 void bar2() { class A { void barx() {;;} }; }
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'bar2' exceeds recommended size/complexity
 // CHECK-MESSAGES: :[[@LINE-2]]:6: note: 3 statements (threshold 0)
 //
 // CHECK-MESSAGES: :[[@LINE-4]]:30: warning: function 'barx' exceeds recommended size/complexity
 // CHECK-MESSAGES: :[[@LINE-5]]:30: note: 2 statements (threshold 0)
+
+#define macro() {int x; {int y; {int z;}}}
+
+void baz0() { // 1
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'baz0' exceeds recommended size/complexity
+// CHECK-MESSAGES: :[[@LINE-2]]:6: note: 9 statements (threshold 0)
+  int a;
+  { // 2
+    int b;
+    { // 3
+// CHECK-MESSAGES: :[[@LINE-1]]:5: note: nesting level 3 starts here (threshold 2)
+      int c;
+      { // 4
+        int d;
+      }
+    }
+  }
+  { // 2
+    int e;
+  }
+  { // 2
+    { // 3
+// CHECK-MESSAGES: :[[@LINE-1]]:5: note: nesting level 3 starts here (threshold 2)
+      int j;
+    }
+  }
+  macro()
+// CHECK-MESSAGES: :[[@LINE-1]]:3: note: nesting level 3 starts here (threshold 2)
+// CHECK-MESSAGES: :[[@LINE-27]]:25: note: expanded from macro 'macro'
+}