[clang-tidy] Implement readability-function-cognitive-complexity check

[lebedev.ri]

Summary

Currently, there is basically just one clang-tidy check to impose some sanity limits on functions - clang-tidy-readability-function-size.
It is nice, allows to limit line count, total number of statements, number of branches, number of function parameters (not counting implicit this), nesting level.
However, those are simple generic metrics. It is still trivially possible to write a function, which does not violate any of these metrics, yet is still rather unreadable.

Thus, some additional, slightly more complicated metric is needed.
There is a well-known Cyclomatic complexity, but certainly has its downsides.
And there is a COGNITIVE COMPLEXITY by SonarSource, which is available for opensource on https://sonarcloud.io/.
I did ask them, and received an answer that it is it can be implemented in clang-tidy.

There is a number of official open-source LGPL-3 implementations already:

• https://github.com/SonarSource/SonarTS/pull/378
• https://github.com/SonarSource/sonar-java/pull/1385
• https://github.com/SonarSource/SonarJS/pull/449
• https://github.com/SonarSource/sonar-php/pull/173

There are other open-source LGPL-3 implementations already:

• https://pypi.org/project/cognitive-complexity/ (MIT)
• https://github.com/rossmacarthur/complexity (APACHE/MIT)

There are other 3rd party implementations:

• https://docs.codeclimate.com/docs/cognitive-complexity

This check checks function Cognitive Complexity metric, and flags the functions with Cognitive Complexity exceeding the configured limit.
The default limit is 25, same as in 'upstream'.

The metric is implemented as per COGNITIVE COMPLEXITY by SonarSource specification version 1.2 (19 April 2017), with two notable exceptions:

• preprocessor conditionals (#ifdef, #if, #elif, #else, #endif) are not accounted for. Could be done. Currently, upstream does not account for them either.
• each method in a recursion cycle is not accounted for. It can't be fully implemented, because cross-translational-unit analysis would be needed, which is not possible in clang-tidy. Thus, at least right now, i completely avoided implementing it.

[lebedev.ri]

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

102–114 ↗

(On Diff #114549)

Actually, found a combination that works, done.
FIXME: so should const std::array<const StringRef, 4> CognitiveComplexity::Msgs be static and initialized out-of-line, or not static, but initialized in-line?

228–234 ↗

(On Diff #114549)

Actually, it turned out to be much simper now that i cross-referenced with the output of the "reference implementation"

206 ↗

(On Diff #115482)

Modified, but without templates.

docs/ReleaseNotes.rst

138 ↗

(On Diff #114549)

Reworded once more

docs/clang-tidy/checks/readability-function-cognitive-complexity.rst

10 ↗

(On Diff #114549)

did you test them?

No, actually.
Thanks for the hint on how to build them, now fixed.

[JonasToth]

For my part the current state is ok. but @alexfh and @aaron.ballman should do their review before committing.
I would be interested in a exampleoutput for any real project.

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

102–114 ↗

(On Diff #114549)

Since it is already in an anonymous namespace, static would be duplicated, wouldn't it? I like it now!

docs/ReleaseNotes.rst

138 ↗

(On Diff #114549)

Sounds good. :)

[lebedev.ri]

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

102–114 ↗

(On Diff #114549)

Msgs is in a struct CognitiveComplexity, which is in anonymous namespace

[JonasToth]

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

102–114 ↗

(On Diff #114549)

Ups. But that solution wouldn't be that bad in term of structure size, would it? The messages themself should land in static program storage, so only 4 pointers would be saved. I would leave it as is, maybe make it constexpr.

[lebedev.ri]

In D36836#873246, @JonasToth wrote:

For my part the current state is ok.

@JonasToth thank you for the review!

but @alexfh and @aaron.ballman should do their review before committing.

+1 :)
Now what one full review pass is done, it may be easier to start for the other reviewers..

I would be interested in a exampleoutput for any real project.

TBD

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

102–114 ↗

(On Diff #114549)

But that solution wouldn't be that bad in term of structure size, would it?

I *think* so

constexpr

Comment from before const std::array<const StringRef, 4> Msgs = {{

// Yes, this member variable would be better off being `static`. But then
// either `StringRef` does not have `constexpr` constructor (because `strlen` is not
// `constexpr`), which is needed for `static constexpr` variable; or if `char*` is
// used, there is a linking problem (Msgs is missing).
// So either static out-of-line or non-static in-line.

[alexfh]

The metric is implemented as per COGNITIVE COMPLEXITY by SonarSource specification version 1.2 (19 April 2017),

Err, "I did ask them, and received an answer that it is it can be implemented in clang-tidy" might not be enough.

[lebedev.ri]

In D36836#877636, @alexfh wrote:

The metric is implemented as per COGNITIVE COMPLEXITY by SonarSource specification version 1.2 (19 April 2017),

Err, "I did ask them, and received an answer that it is it can be implemented in clang-tidy" might not be enough.

original_msg.txt8 KBDownload

Hello Roman,

It would not, and I would be happy to be notified once done.

Thanks

Olivier

> On Fri, Jul 28, 2017 at 6:17 PM Roman Lebedev <[e-mail]> wrote:
> Hi.
> 
> I would like to know, what is the legal status of
> https://www.sonarsource.com/docs/CognitiveComplexity.pdf ?
> 
> If i (or someone else) is to implement the Specification described in
> that paper,
> which will produce the same results as the Cognitive Complexity in SonarSource
> as part of some other static analyzer, for example as a LLVM's clang-tidy check,
> would that be illegal thing to do?
> 
> Roman.
-- 
Olivier Gaudin | SonarSource
CEO & Co-Founder
[phone]
http://sonarsource.com

Might not be enough?

[JonasToth]

Hi Roman, there are still some comments marked as not done from my review. Maybe other reviewers wait for there 'resolution', but from my side there are resolved.
One more attempt to get the review rolling.

[lebedev.ri]

Ping.

In D36836#877642, @lebedev.ri wrote:

In D36836#877636, @alexfh wrote:

The metric is implemented as per COGNITIVE COMPLEXITY by SonarSource specification version 1.2 (19 April 2017),

Err, "I did ask them, and received an answer that it is it can be implemented in clang-tidy" might not be enough.

original_msg.txt8 KBDownload

Hello Roman,

It would not, and I would be happy to be notified once done.

Thanks

Olivier

> On Fri, Jul 28, 2017 at 6:17 PM Roman Lebedev <[e-mail]> wrote:
> Hi.
> 
> I would like to know, what is the legal status of
> https://www.sonarsource.com/docs/CognitiveComplexity.pdf ?
> 
> If i (or someone else) is to implement the Specification described in
> that paper,
> which will produce the same results as the Cognitive Complexity in SonarSource
> as part of some other static analyzer, for example as a LLVM's clang-tidy check,
> would that be illegal thing to do?
> 
> Roman.
-- 
Olivier Gaudin | SonarSource
CEO & Co-Founder
[phone]
http://sonarsource.com

Might not be enough?

@alexfh please specify, is that enough or not?

[aaron.ballman]

In D36836#883214, @lebedev.ri wrote:

@alexfh please specify, is that enough or not?

I think it's sufficient, but we should put that information somewhere pertinent rather than just the review. In the past, we've put something into LICENSE.TXT to identify that we're in the clear, and that might be appropriate here as well. What do you think, @alexfh?

[lebedev.ri]

Ping.

• Rebased
• Added the legal status info into LICENSE.txt, referencing clang-tidy/readability/FunctionCognitiveComplexityCheck.LICENSE.txt, as suggested by @aaron.ballman

Question:
Is it expected that clang-tidy somehow parses the DiagnosticIDs::Note's as FixIt's, and thus fails with the following assert:

Running ['clang-tidy', '/build/llvm-build-Clang-release/tools/clang/tools/extra/test/clang-tidy/Output/readability-function-cognitive-complexity.cpp.tmp.cpp', '-fix', '--checks=-*,readability-function-cognitive-complexity', '-config={CheckOptions: [{key: readability-function-cognitive-complexity.Threshold, value: 0}]}', '--', '-std=c++11', '-nostdinc++']...
clang-tidy failed:
Fix conflicts with existing fix! The new replacement overlaps with an existing replacement.
New replacement: /build/llvm-build-Clang-release/tools/clang/tools/extra/test/clang-tidy/Output/readability-function-cognitive-complexity.cpp.tmp.cpp: 3484:+5:""
Existing replacement: /build/llvm-build-Clang-release/tools/clang/tools/extra/test/clang-tidy/Output/readability-function-cognitive-complexity.cpp.tmp.cpp: 3485:+2:"&"
clang-tidy: /build/clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp:86: virtual void (anonymous namespace)::ClangTidyDiagnosticRenderer::emitCodeContext(clang::FullSourceLoc, DiagnosticsEngine::Level, SmallVectorImpl<clang::CharSourceRange> &, ArrayRef<clang::FixItHint>): Assertion `false && "Fix conflicts with existing fix!"' failed.

[aaron.ballman]

Adding @dberlin for licensing discussion questions.

LICENSE.TXT

64 ↗

(On Diff #117824)

This should point to a directory instead of an individual file.

clang-tidy/readability/FunctionCognitiveComplexityCheck.LICENSE.txt

2 ↗

(On Diff #117824)

I think that this file should be a general LICENSE.TXT instead of a tied to a specific file name. The license is for the algorithm, not for the file name.

13 ↗

(On Diff #117824)

This isn't actually a license, however. I think we need to ask sonarsource either for a license statement they're comfortable with, or approach them with one in hand that they can approve. However, @dberlin might have more input here.

[lebedev.ri]

In D36836#889375, @aaron.ballman wrote:

Adding @dberlin for licensing discussion questions.

Ping.

Yes, i agree that what i have added is not a directory, and not a proper license.
That is more of a template to hopefully stat moving things in the right direction.

To clarify, my problem with this Differential is that i'we yet to see any opinion on
the proposed check from the people who will actually have the final say whether
it will be accepted or not. It will be *really* sad if we go through all this trouble
with the legal matters, and then it will be NACK'ed...

[aaron.ballman]

(I've not had the chance to complete a full review, but these are some thoughts thus far.)

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

76 ↗

(On Diff #117824)

I don't think this needs to be a member of the class -- it can be a static const char *[] at file scope, can it not?

77 ↗

(On Diff #117824)

Are you intending to fix this -- that sounds rather serious?

97 ↗

(On Diff #117824)

occurence -> occurrence

98 ↗

(On Diff #117824)

Missing a full stop.

99 ↗

(On Diff #117824)

I don't think the final adds value here.

102 ↗

(On Diff #117824)

Why is this turned into a bit-field? If that is important, it should be of type unsigned to prevent differences between compilers (MSVC treats bit-fields differently than GCC and Clang).

118 ↗

(On Diff #117824)

We use // instead of /// unless we're specifically documenting something for doxygen.

139 ↗

(On Diff #117824)

Why is this commented out?

150 ↗

(On Diff #117824)

Missing full-stop (here and elsewhere, I'll stop commenting on them).

191 ↗

(On Diff #117824)

Please use = instead of () here.

210 ↗

(On Diff #117824)

What's with the comment?

215–218 ↗

(On Diff #117824)

I don't think this macro adds clarify for its two uses.

[lebedev.ri]

@aaron.ballman, thank you for the review!

Rebased, addressed most of review notes.

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

76 ↗

(On Diff #117824)

It seemed fitting to keep it in the class, because it is directly related to the previous enum.
But i guess i agree, it is better to move it back out of the class...

77 ↗

(On Diff #117824)

I do intend to fix it, as soon as i'm aware of how to fix this.
Specifically, https://reviews.llvm.org/D36836#889350

Question:
Is it expected that clang-tidy somehow parses the DiagnosticIDs::Note's as FixIt's, and thus fails with the following assert:
...

I.e. what is the proper way to fix this, should i change the message, or change the code not to parse the message as FixIt?

99 ↗

(On Diff #117824)

I don't think it hurts, either?
I *personally* prefer to specify it always, and remove if subclassing is needed.
But if you insist i can certainly drop it

102 ↗

(On Diff #117824)

The comment right after this member variable should have explained it:

/// Criteria C is a bitfield. Even though Criteria is an unsigned char; and
/// only using 3 bits will still result in padding, the fact that it is a
/// bitfield is a reminder that it is important to min(sizeof(Detail))

It is already unsigned:

enum Criteria : unsigned char {

150 ↗

(On Diff #117824)

Poured-in some full-stops. I doubt i caught all the places / did not add it in wrong places.

210 ↗

(On Diff #117824)

An ugly attempt to align the same substring Optional<BinaryOperator::Opcode> on both lines.
I can either drop the comment, or do using OBO = Optional<BinaryOperator::Opcode>; and use it.

[aaron.ballman]

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

111 ↗

(On Diff #119091)

This static_assert should come with some further comments explaining that size being small is good, but not critical for correctness.

212 ↗

(On Diff #119091)

Declare with its initialization below.

220 ↗

(On Diff #119091)

Declare with its initialization below.

250 ↗

(On Diff #119091)

Missing a closing paren in the comment.

275–276 ↗

(On Diff #119091)

Would be better to just get the AST node directly instead of isa<>() and dyn_cast<>().

if (const auto *E = dyn_cast<IfStmt>(Node->getElse()))

317 ↗

(On Diff #119091)

encounter function call -> encounter a function call

325 ↗

(On Diff #119091)

typo: nonexistent

332 ↗

(On Diff #119091)

if new operator -> if the new operator

333 ↗

(On Diff #119091)

previous-one -> previous one

338 ↗

(On Diff #119091)

creates new stack -> creates a new stack

347 ↗

(On Diff #119091)

Can drop the const.

370 ↗

(On Diff #119091)

This FIXME doesn't describe what needs to be fixed very well, you might want to expound (or fix it).

384 ↗

(On Diff #119091)

regular -> Regular

391 ↗

(On Diff #119091)

else are -> else are (remove extra space)

392 ↗

(On Diff #119091)

nested -> Nested

411 ↗

(On Diff #119091)

extra space between else and are

433 ↗

(On Diff #119091)

if -> If

444 ↗

(On Diff #119091)

The second non-standard parameter -> The parameter

448 ↗

(On Diff #119091)

Explaination -> Explanation

495 ↗

(On Diff #119091)

You only need to match function *definitions* (not declarations), correct? It might be useful to specify that in the matcher so that it matches less code.

513–514 ↗

(On Diff #119091)

I would reword this to: Output all the basic increments of complexity.

520 ↗

(On Diff #119091)

Increase on the -> Increase, on the

77 ↗

(On Diff #117824)

This is one for @alexfh to answer, I think. My gut says that the code should not be parsing notes as fixits (as a separate commit).

99 ↗

(On Diff #117824)

That's not the typical coding style for the project, so I would prefer to leave it off. It's reasonable to use when there are vtables involved, however.

102 ↗

(On Diff #117824)

No, it's underlying type is unsigned char, but the type is Criteria. I meant the field itself needs to be unsigned. However, since that means you have to do more type casting, I think making the type uint8_t instead of a bit-field would be an improvement.

118 ↗

(On Diff #117824)

This change is marked as done but wasn't applied consistently. For instance, see lines 130-131 where it switches between uses. I would use // consistently everywhere unless documenting a public interface in a header.

docs/clang-tidy/checks/readability-function-cognitive-complexity.rst

8 ↗

(On Diff #119091)

as per -> as per the

85 ↗

(On Diff #119091)

And this -> This

141 ↗

(On Diff #119091)

I would drop Could be done.

[lebedev.ri]

Rebased.
Addressed @aaron.ballman review notes (mainly stylistic)

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

495 ↗

(On Diff #119091)

Good idea!

102 ↗

(On Diff #117824)

Better?

118 ↗

(On Diff #117824)

OK.

[aaron.ballman]

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

499 ↗

(On Diff #119766)

Since we're restricting this, might as well add deleted and defaulted functions to the list of unless items (as I think those are still definitions).

102 ↗

(On Diff #117824)

Much, thank you!

[lebedev.ri]

Rebased.
Tighten matchers.
Add an assert that the function we matched does have the body (the check analyses the function bodies, so if there is no body, there is nothing to do.)

clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

499 ↗

(On Diff #119766)

Good idea!
It seems only the deleted were still matched, not defaulted.

[lebedev.ri]

Ping.

Rebased.
Silenced (via the -w flag in the RUN line) the Fix conflicts with existing fix! assertion since this differential does not actually cause it, but the testcase just happens to trigger it...
Reported it as PR35136 with minimal reproducer.

In D36836#889375, @aaron.ballman wrote:

Adding @dberlin for licensing discussion questions.

@dberlin ping? I'm wondering if you had the chance to look at this? :)

[lebedev.ri]

Ping.

In D36836#889375, @aaron.ballman wrote:

Adding @dberlin for licensing discussion questions.

@dberlin ping? I'm wondering if you had the chance to look at this? :)

[lebedev.ri]

Ping.

In D36836#889375, @aaron.ballman wrote:

Adding @dberlin for licensing discussion questions.

@dberlin ping? I'm wondering if you had the chance to look at this? :)

[lebedev.ri]

• Rebased
• As advised by @aaron.ballman, moved into it's own directory/module. Please review that, i'm not entirely sure i have done that fully correctly.

@chandlerc Hi!
@aaron.ballman has suggested for me to try to talk to you about this.
Is there some precedent for the licensing 'issue' at hand? Do you have any opinion?
@dberlin did not react to the pings, so i'm not sure i personally can come up with anything better for LICENSE.txt

If there are no further ideas, i'll try to contact sonarsource.

[lebedev.ri]

Rebased.

[lebedev.ri]

Rebased.

[lebedev.ri]

Rebased.

[chandlerc]

In D36836#931995, @lebedev.ri wrote:

• Rebased
• As advised by @aaron.ballman, moved into it's own directory/module. Please review that, i'm not entirely sure i have done that fully correctly.

@chandlerc Hi!
@aaron.ballman has suggested for me to try to talk to you about this.
Is there some precedent for the licensing 'issue' at hand? Do you have any opinion?
@dberlin did not react to the pings, so i'm not sure i personally can come up with anything better for LICENSE.txt

Sadly, what you need here is legal advice for a good way to handle this, and I'm not a lawyer and so I can't really give you that advice.

To be clear, what you currently have isn't OK for several reasons, not least of which what Aaron brought up that this is not in fact a license.

If there are no further ideas, i'll try to contact sonarsource.

Unless Danny can volunteer his time, we finish with relicensing efforts and can devote the foundation's lawyer's (sadly precious) time to this, I think either you or sonarsource working to understand the best legal way to contribute this would be the best way forward. Sorry that this is a tricky situation. Happy to have a private discussion w/ your or sonarsources's lawyer via my @llvm.org email address if useful.

[lebedev.ri]

In D36836#1021863, @chandlerc wrote:

In D36836#931995, @lebedev.ri wrote:

• Rebased
• As advised by @aaron.ballman, moved into it's own directory/module. Please review that, i'm not entirely sure i have done that fully correctly.

@chandlerc Hi!
@aaron.ballman has suggested for me to try to talk to you about this.
Is there some precedent for the licensing 'issue' at hand? Do you have any opinion?
@dberlin did not react to the pings, so i'm not sure i personally can come up with anything better for LICENSE.txt

Sadly, what you need here is legal advice for a good way to handle this, and I'm not a lawyer and so I can't really give you that advice.

To be clear, what you currently have isn't OK for several reasons, not least of which what Aaron brought up that this is not in fact a license.

If there are no further ideas, i'll try to contact sonarsource.

Unless Danny can volunteer his time, we finish with relicensing efforts and can devote the foundation's lawyer's (sadly precious) time to this, I think either you or sonarsource working to understand the best legal way to contribute this would be the best way forward. Sorry that this is a tricky situation. Happy to have a private discussion w/ your or sonarsources's lawyer via my @llvm.org email address if useful.

Mailed and heard back (yay!).
They don't want to take active stance/first steps in this,
but they also did *not* retract that initial 'agreement' i quoted earlier (i did ask about that explicitly.).
So nothing is changed so far, this will have to wait until someone can volunteer their precious lawyer time.
(Can show the mail exchange if needed.)

[alexfh]

Removing from my dashboard until the licensing stuff gets sorted out.

[lebedev.ri]

Rebased, just to control bitrot, no changes.

[JonasToth]

Anything new here? Is there a LLVM foundation lawyer or something like that we can ask?

[alexfh]

In D36836#1249971, @JonasToth wrote:

Anything new here? Is there a LLVM foundation lawyer or something like that we can ask?

I didn't notice any substantial changes w.r.t. license since Chandler's comment on Feb. 28th.

[lebedev.ri]

In D36836#1021863, @chandlerc wrote:

In D36836#931995, @lebedev.ri wrote:

• Rebased
• As advised by @aaron.ballman, moved into it's own directory/module. Please review that, i'm not entirely sure i have done that fully correctly.

@chandlerc Hi!
@aaron.ballman has suggested for me to try to talk to you about this.
Is there some precedent for the licensing 'issue' at hand? Do you have any opinion?
@dberlin did not react to the pings, so i'm not sure i personally can come up with anything better for LICENSE.txt

Sadly, what you need here is legal advice for a good way to handle this, and I'm not a lawyer and so I can't really give you that advice.

To be clear, what you currently have isn't OK for several reasons, not least of which what Aaron brought up that this is not in fact a license.

If there are no further ideas, i'll try to contact sonarsource.

Unless Danny can volunteer his time, we finish with relicensing efforts

Hi @chandlerc !
I was just wondering what percentage of "finish" was meant here, and where at it's now?

and can devote the foundation's lawyer's (sadly precious) time to this, I think either you or sonarsource working to understand the best legal way to contribute this would be the best way forward. Sorry that this is a tricky situation. Happy to have a private discussion w/ your or sonarsources's lawyer via my @ llvm.org email address if useful.

[lebedev.ri]

In D36836#1426884, @lebedev.ri wrote:

In D36836#1021863, @chandlerc wrote:

In D36836#931995, @lebedev.ri wrote:

• Rebased
• As advised by @aaron.ballman, moved into it's own directory/module. Please review that, i'm not entirely sure i have done that fully correctly.

@chandlerc Hi!
@aaron.ballman has suggested for me to try to talk to you about this.
Is there some precedent for the licensing 'issue' at hand? Do you have any opinion?
@dberlin did not react to the pings, so i'm not sure i personally can come up with anything better for LICENSE.txt

Sadly, what you need here is legal advice for a good way to handle this, and I'm not a lawyer and so I can't really give you that advice.

To be clear, what you currently have isn't OK for several reasons, not least of which what Aaron brought up that this is not in fact a license.

If there are no further ideas, i'll try to contact sonarsource.

Unless Danny can volunteer his time, we finish with relicensing efforts

Hi @chandlerc !
I was just wondering what percentage of "finish" was meant here, and where at it's now?

And how far along is LLVM now, one year later? :)

and can devote the foundation's lawyer's (sadly precious) time to this, I think either you or sonarsource working to understand the best legal way to contribute this would be the best way forward. Sorry that this is a tricky situation. Happy to have a private discussion w/ your or sonarsources's lawyer via my @ llvm.org email address if useful.

[lebedev.ri]

Rebased.

There is a number of official open-source LGPL-3 implementations already:

• https://github.com/SonarSource/SonarTS/pull/378
• https://github.com/SonarSource/sonar-java/pull/1385
• https://github.com/SonarSource/SonarJS/pull/449
• https://github.com/SonarSource/sonar-php/pull/173

There are other open-source LGPL-3 implementations already:

• https://pypi.org/project/cognitive-complexity/ (MIT)
• https://github.com/rossmacarthur/complexity (APACHE/MIT)

There are other 3rd party implementations:

• https://docs.codeclimate.com/docs/cognitive-complexity

Quite honestly, i do not understand how did the license question arose.
Would have it been fine if i based this on the open-source-licensed code?
Would have it not been? Would same license question be raised?
Somehow i don't think it would have been.

Is this really just about Copyright SonarSource S.A., 2018, Switzerland. All content is copyright protected. in https://www.sonarsource.com/docs/CognitiveComplexity.pdf ?
But that is only about the document, not the algorithm.
But even if we enternain the idea that all of the implementations must bow to that license,
then surely this is not the first code in LLVM that is implicitly/explicitly based on copyrighted doc.

This is rather frustrating.

[JonasToth]

In D36836#2289639, @lebedev.ri wrote:

Rebased.

There is a number of official open-source LGPL-3 implementations already:

• https://github.com/SonarSource/SonarTS/pull/378
• https://github.com/SonarSource/sonar-java/pull/1385
• https://github.com/SonarSource/SonarJS/pull/449
• https://github.com/SonarSource/sonar-php/pull/173

There are other open-source LGPL-3 implementations already:

• https://pypi.org/project/cognitive-complexity/ (MIT)
• https://github.com/rossmacarthur/complexity (APACHE/MIT)

There are other 3rd party implementations:

• https://docs.codeclimate.com/docs/cognitive-complexity

Quite honestly, i do not understand how did the license question arose.
Would have it been fine if i based this on the open-source-licensed code?
Would have it not been? Would same license question be raised?
Somehow i don't think it would have been.

Is this really just about Copyright SonarSource S.A., 2018, Switzerland. All content is copyright protected. in https://www.sonarsource.com/docs/CognitiveComplexity.pdf ?
But that is only about the document, not the algorithm.
But even if we enternain the idea that all of the implementations must bow to that license,
then surely this is not the first code in LLVM that is implicitly/explicitly based on copyrighted doc.

This is rather frustrating.

Given there are open source implementations, this is in my eyes completly acceptable to implement this in llvm.
The document is copyrighted, true. The algorithm itself is not, in european law it is even very hard to patent algorithms, software in general is not patentable.
The code is not copy&pasted, so there are no infringements on anything.

[aaron.ballman]

In D36836#2289639, @lebedev.ri wrote:

Rebased.

There is a number of official open-source LGPL-3 implementations already:

• https://github.com/SonarSource/SonarTS/pull/378
• https://github.com/SonarSource/sonar-java/pull/1385
• https://github.com/SonarSource/SonarJS/pull/449
• https://github.com/SonarSource/sonar-php/pull/173

There are other open-source LGPL-3 implementations already:

• https://pypi.org/project/cognitive-complexity/ (MIT)
• https://github.com/rossmacarthur/complexity (APACHE/MIT)

There are other 3rd party implementations:

• https://docs.codeclimate.com/docs/cognitive-complexity

Quite honestly, i do not understand how did the license question arose.

It arose in a comment that I can't seem to get phab to show me the context for (which is a bit strange, I don't think I've run into that before): https://reviews.llvm.org/D36836#877636 Perhaps part of this was carrying discussion over from the IRC channel?

Would have it been fine if i based this on the open-source-licensed code?

I believe that would require legal analysis to answer.

Would have it not been? Would same license question be raised?

Likewise here (I suspect the answer would depend on what the license of the open source code is).

Somehow i don't think it would have been.

I don't wish to speculate about legal licensing issues on the mailing lists.

Is this really just about Copyright SonarSource S.A., 2018, Switzerland. All content is copyright protected. in https://www.sonarsource.com/docs/CognitiveComplexity.pdf ?
But that is only about the document, not the algorithm.
But even if we enternain the idea that all of the implementations must bow to that license,
then surely this is not the first code in LLVM that is implicitly/explicitly based on copyrighted doc.

This is rather frustrating.

I am sorry and I agree that it's frustrating. As far as I know, this captures the current state of affairs: https://reviews.llvm.org/D36836#1031600 and basically we're waiting for help from the foundation to clear the last hurdle.

[lebedev.ri]

In D36836#2292541, @aaron.ballman wrote:

In D36836#2289639, @lebedev.ri wrote:

Rebased.

There is a number of official open-source LGPL-3 implementations already:

• https://github.com/SonarSource/SonarTS/pull/378
• https://github.com/SonarSource/sonar-java/pull/1385
• https://github.com/SonarSource/SonarJS/pull/449
• https://github.com/SonarSource/sonar-php/pull/173

There are other open-source LGPL-3 implementations already:

• https://pypi.org/project/cognitive-complexity/ (MIT)
• https://github.com/rossmacarthur/complexity (APACHE/MIT)

There are other 3rd party implementations:

• https://docs.codeclimate.com/docs/cognitive-complexity

Quite honestly, i do not understand how did the license question arose.

It arose in a comment that I can't seem to get phab to show me the context for (which is a bit strange, I don't think I've run into that before): https://reviews.llvm.org/D36836#877636 Perhaps part of this was carrying discussion over from the IRC channel?

Would have it been fine if i based this on the open-source-licensed code?

I believe that would require legal analysis to answer.

Would have it not been? Would same license question be raised?

Likewise here (I suspect the answer would depend on what the license of the open source code is).

Somehow i don't think it would have been.

I don't wish to speculate about legal licensing issues on the mailing lists.

Is this really just about Copyright SonarSource S.A., 2018, Switzerland. All content is copyright protected. in https://www.sonarsource.com/docs/CognitiveComplexity.pdf ?
But that is only about the document, not the algorithm.
But even if we enternain the idea that all of the implementations must bow to that license,
then surely this is not the first code in LLVM that is implicitly/explicitly based on copyrighted doc.

This is rather frustrating.

I am sorry and I agree that it's frustrating.

As far as I know, this captures the current state of affairs: https://reviews.llvm.org/D36836#1031600

As far as I know, yes. Some further back&forth reiterated:

@Roman so you know, none of the non-SonarSource implementations have an official license from us.
We put the spec out in the world and we're happy when someone uses it. And that's all.
I appreciate how frustrated you must be with your implementation caught between a proverbial rock and a hard place.
Unfortunately, we (the company) just aren't willing to do the paperwork.
(G. Ann Campbell)

reply.eml14 KBDownload

and basically we're waiting for help from the foundation to clear the last hurdle.

Is foundation even aware of this controversy/situation?
https://reviews.llvm.org/D36836#1021863, which is the last response i got, was 2.5 years ago.
For all we/i know this has gone off their radar.
I understand that it is fully possible that they simply haven't gotten around to it,
but i think it would be important to check that it isn't the case of lost mail.

[aaron.ballman]

In D36836#2292727, @lebedev.ri wrote:

In D36836#2292541, @aaron.ballman wrote:

In D36836#2289639, @lebedev.ri wrote:

Rebased.

There is a number of official open-source LGPL-3 implementations already:

• https://github.com/SonarSource/SonarTS/pull/378
• https://github.com/SonarSource/sonar-java/pull/1385
• https://github.com/SonarSource/SonarJS/pull/449
• https://github.com/SonarSource/sonar-php/pull/173

There are other open-source LGPL-3 implementations already:

• https://pypi.org/project/cognitive-complexity/ (MIT)
• https://github.com/rossmacarthur/complexity (APACHE/MIT)

There are other 3rd party implementations:

• https://docs.codeclimate.com/docs/cognitive-complexity

Quite honestly, i do not understand how did the license question arose.

It arose in a comment that I can't seem to get phab to show me the context for (which is a bit strange, I don't think I've run into that before): https://reviews.llvm.org/D36836#877636 Perhaps part of this was carrying discussion over from the IRC channel?

Would have it been fine if i based this on the open-source-licensed code?

I believe that would require legal analysis to answer.

Would have it not been? Would same license question be raised?

Likewise here (I suspect the answer would depend on what the license of the open source code is).

Somehow i don't think it would have been.

I don't wish to speculate about legal licensing issues on the mailing lists.

Is this really just about Copyright SonarSource S.A., 2018, Switzerland. All content is copyright protected. in https://www.sonarsource.com/docs/CognitiveComplexity.pdf ?
But that is only about the document, not the algorithm.
But even if we enternain the idea that all of the implementations must bow to that license,
then surely this is not the first code in LLVM that is implicitly/explicitly based on copyrighted doc.

This is rather frustrating.

I am sorry and I agree that it's frustrating.

As far as I know, this captures the current state of affairs: https://reviews.llvm.org/D36836#1031600

As far as I know, yes. Some further back&forth reiterated:

@Roman so you know, none of the non-SonarSource implementations have an official license from us.
We put the spec out in the world and we're happy when someone uses it. And that's all.
I appreciate how frustrated you must be with your implementation caught between a proverbial rock and a hard place.
Unfortunately, we (the company) just aren't willing to do the paperwork.
(G. Ann Campbell)

reply.eml14 KBDownload

Personally, I'm hopeful that this is sufficient to get us unstuck, but I'm not willing to make the determination simply because of the typical community view on making licensing decisions.

and basically we're waiting for help from the foundation to clear the last hurdle.

Is foundation even aware of this controversy/situation?
https://reviews.llvm.org/D36836#1021863, which is the last response i got, was 2.5 years ago.
For all we/i know this has gone off their radar.
I understand that it is fully possible that they simply haven't gotten around to it,
but i think it would be important to check that it isn't the case of lost mail.

I totally agree that we should double-check as it feels like this fell off the radar and I appreciate you pinging the review. @chandlerc is no longer on the foundation board and it looks like Danny is no longer on phabricator, so I've added some current LLVM foundation board members as reviewers to see if any of them can help us make progress.

[tonic]

Licensing questions are best sent to the [e-mail] mailing address. Can you reach out there?

[lattner]

Hi all,

The LLVM foundation board discussed this offline -- it looks like the contributor is a bit confused about the LLVM project policies towards copyright, license, patent stuff etc. I really appreciate the dilligence here to capture the ideas that went into this code.

My understanding is that the code and documentation are not derived from anyone else's code or documentation -- they are fresh implementations based on a paper written in english prose. If that is the case, please remove the LICENSE.TXT file -- it isn't necessary and it is confusing for people. I would also recommend replacing all the references to sonar source with a functional description of what this patch is doing - we aren't talking about adding a feature because of sonar source, my understanding is that this is adding a cyclomatic complexity checker. If and when the feature evolves over time, it would be misleading for it to be called sonar source.

Please note that I didn't do a full code review here, others should do that.

-Chris

[lebedev.ri]

@aaron.ballman @alexfh it is my understanding that i'm to proceed with commit. No explicit acknowledgement from your side is needed.

In D36836#2308981, @lattner wrote:

Hi all,

The LLVM foundation board discussed this offline

Yay, thank you!

it looks like the contributor is a bit confused about the LLVM project policies towards copyright, license, patent stuff etc.

...

I really appreciate the dilligence here to capture the ideas that went into this code.

My understanding is that the code and documentation are not derived from anyone else's code or documentation -- they are fresh implementations based on a paper written in english prose. If that is the case,

That is the case, yes. This is based on the spec.

please remove the LICENSE.TXT file -- it isn't necessary and it is confusing for people. I would also recommend replacing all the references to sonar source with a functional description of what this patch is doing - we aren't talking about adding a feature because of sonar source,

Done, as much as possible. I'd still prefer to maintain a reference to the spec on which it is based.
Note that it was done because that is what was requested previously by reviewers.

my understanding is that this is adding a cyclomatic complexity checker.

Well, yes and no. Note that this is *NOT* a well-known cyclomatic complexity metric, but a novel cognitive complexity metric.

If and when the feature evolves over time, it would be misleading for it to be called sonar source.

Yes.

Please note that I didn't do a full code review here, others should do that.

All good on that front, this has been quite extensively reviewed years ago :)

-Chris

Roman

[aaron.ballman]

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

94–97

I'm not certain this comment adds a whole lot.

155

outputed -> output

156

Criteria's -> Criteria

223

of binary -> of the binary

368–369

If there's not a node, do we really need to traverse it?

382

BinaryConditionalOperatorClass as well (for all the places we're dealing with ConditionalOperatorClass)?

389

Should IndirectGotoStmtClass be handled the same way?

411

BlockExprClass as well?

Should GNU statement expressions also be treated like a lambda or block?

429

SEHExceptStmtClass as well?

474

What about other special member functions like overloaded operators and whatnot? How about block declarations?

Namespaces is another one I was curious about but suspect may not want to be handled here.

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.h

17–21

This shouldn't be necessary, right?

[aaron.ballman]

In D36836#2308981, @lattner wrote:

Hi all,

The LLVM foundation board discussed this offline -- it looks like the contributor is a bit confused about the LLVM project policies towards copyright, license, patent stuff etc. I really appreciate the dilligence here to capture the ideas that went into this code.

My understanding is that the code and documentation are not derived from anyone else's code or documentation -- they are fresh implementations based on a paper written in english prose. If that is the case, please remove the LICENSE.TXT file -- it isn't necessary and it is confusing for people. I would also recommend replacing all the references to sonar source with a functional description of what this patch is doing - we aren't talking about adding a feature because of sonar source, my understanding is that this is adding a cyclomatic complexity checker. If and when the feature evolves over time, it would be misleading for it to be called sonar source.

Please note that I didn't do a full code review here, others should do that.

Thank you to you and the board for looking into this and helping us reach the right decision!

In D36836#2309103, @lebedev.ri wrote:

please remove the LICENSE.TXT file -- it isn't necessary and it is confusing for people. I would also recommend replacing all the references to sonar source with a functional description of what this patch is doing - we aren't talking about adding a feature because of sonar source,

Done, as much as possible. I'd still prefer to maintain a reference to the spec on which it is based.
Note that it was done because that is what was requested previously by reviewers.

I agree that we should still document that this is based off the Sonar Source paper because it's not a generic implementation but a specific one. I think you've struck a good balance with the current patch.

[lebedev.ri]

In D36836#2309243, @aaron.ballman wrote:

In D36836#2308981, @lattner wrote:

Hi all,

The LLVM foundation board discussed this offline -- it looks like the contributor is a bit confused about the LLVM project policies towards copyright, license, patent stuff etc. I really appreciate the dilligence here to capture the ideas that went into this code.

My understanding is that the code and documentation are not derived from anyone else's code or documentation -- they are fresh implementations based on a paper written in english prose. If that is the case, please remove the LICENSE.TXT file -- it isn't necessary and it is confusing for people. I would also recommend replacing all the references to sonar source with a functional description of what this patch is doing - we aren't talking about adding a feature because of sonar source, my understanding is that this is adding a cyclomatic complexity checker. If and when the feature evolves over time, it would be misleading for it to be called sonar source.

Please note that I didn't do a full code review here, others should do that.

Thank you to you and the board for looking into this and helping us reach the right decision!

+1.

In D36836#2309103, @lebedev.ri wrote:

please remove the LICENSE.TXT file -- it isn't necessary and it is confusing for people. I would also recommend replacing all the references to sonar source with a functional description of what this patch is doing - we aren't talking about adding a feature because of sonar source,

Done, as much as possible. I'd still prefer to maintain a reference to the spec on which it is based.
Note that it was done because that is what was requested previously by reviewers.

I agree that we should still document that this is based off the Sonar Source paper because it's not a generic implementation but a specific one. I think you've struck a good balance with the current patch.

Good!

I've addressed most of the review comments, excluding the one about Microsoft SEH support - i'd prefer to leave that for a follow-up :)
There may be other straddlers anyway.

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

368–369

This is consistent across this whole FunctionASTVisitor, and is consistent with other RecursiveASTVisitor<>s,
so i'll leave this as-is. If this is wrong, other places should be changed too.

382

No, BinaryConditionalOperator is explicitly exempt.

389

Right, it should be.

411

BlockExprClass as well?

Thank you for the example, that seems obvious & straight-forward to support.
As discussed, we should handle decls thought, not exprs.

Should GNU statement expressions also be treated like a lambda or block?

Hm, i guess it should be.

429

I'm very much unfamiliar with that extension.
I would prefer to leave it as-is for now.

474

What about other special member functions like overloaded operators and whatnot?

Those are CXXMethodDecl, but i'll add a test.

How about block declarations?

Right, we should handle them, not blockstatements.

Namespaces is another one I was curious about but suspect may not want to be handled here.

To the best of my knowledge, those can only appear at the global scope.

[lebedev.ri]

Maybe fine tune comments - we count block decls, not block statements/expressions.

[aaron.ballman]

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

368–369

Fine by me, thanks.

382

I didn't see anything in the paper that talked about this (it's a GNU extension). I feel like anywhere we handle a ternary conditional we should also handle a binary conditional, e.g.,

foo ? foo : bar; // ternary form
foo ? : bar; // binary form of the same thing

but maybe I'm misunderstanding something.

429

I'm fine handling it in a follow-up. I suspect there may be other esoteric AST nodes we want to add, I just tried to hit the ones that were most obvious to me.

474

Namespaces is another one I was curious about but suspect may not want to be handled here.

To the best of my knowledge, those can only appear at the global scope.

They can, but I wasn't certain if they'd add to complexity or not given that you can nest them deeply. But now I see that the paper doesn't mention them in terms of C++ but does talk about something similar with JavaScript that suggests they should not contribute to complexity.

[lebedev.ri]

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

382

As discussed, it does seem like they should at least cause increase in nesting level.
I suspect, they should also cause increase in cognitive complexity IFF they're nested somehow,
because foo ?: bar?: baz doesn't really seem straight-forward.
But likewise, they're an extension, so i think we could fine-tune that later.

429

Okay, thanks.

474

What i mean is, can you define a new namespace within the function's body?
I don't believe that to be possible, therefore we shouldn't/couldn't care about that,
because we start at function scope.

[aaron.ballman]

LGTM, thank you for your patience with the process.

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

382

Agreed, this can be done in a follow-up.

474

What i mean is, can you define a new namespace within the function's body?

You cannot.

I don't believe that to be possible, therefore we shouldn't/couldn't care about that, because we start at function scope.

Agreed.

[lebedev.ri]

@aaron.ballman @JonasToth thank you for the review!
@tonic @lattner thank you for helping resolve the misunderstading :)

! In D36836#2309432, @aaron.ballman wrote:
LGTM, thank you for your patience with the process.

HURRAY!

[RKSimon]

@lebedev.ri This is failing on the windows arm build bots - please can you take a look?

http://lab.llvm.org:8011/builders/llvm-clang-win-x-armv7l/builds/1482
http://lab.llvm.org:8011/builders/llvm-clang-win-x-aarch64/builds/3285

[lebedev.ri]

In D36836#2310168, @RKSimon wrote:

@lebedev.ri This is failing on the windows arm build bots - please can you take a look?

http://lab.llvm.org:8011/builders/llvm-clang-win-x-armv7l/builds/1482
http://lab.llvm.org:8011/builders/llvm-clang-win-x-aarch64/builds/3285

Hm, let me take a look..

[lebedev.ri]

In D36836#2310169, @lebedev.ri wrote:

In D36836#2310168, @RKSimon wrote:

@lebedev.ri This is failing on the windows arm build bots - please can you take a look?

http://lab.llvm.org:8011/builders/llvm-clang-win-x-armv7l/builds/1482
http://lab.llvm.org:8011/builders/llvm-clang-win-x-aarch64/builds/3285

Hm, let me take a look..

Will push likely fix once tests pass locally.

[lebedev.ri]

In D36836#2310170, @lebedev.ri wrote:

In D36836#2310169, @lebedev.ri wrote:

In D36836#2310168, @RKSimon wrote:

@lebedev.ri This is failing on the windows arm build bots - please can you take a look?

http://lab.llvm.org:8011/builders/llvm-clang-win-x-armv7l/builds/1482
http://lab.llvm.org:8011/builders/llvm-clang-win-x-aarch64/builds/3285

Hm, let me take a look..

Will push likely fix once tests pass locally.

rG1596cc83509342eb37dbfe6b95e906759afc6741, let's see if that does it.

clang-tools-extra/clang-tidy/readability/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 add_clang_library(clangTidyReadabilityModule
   AvoidConstParamsInDecls.cpp
   BracesAroundStatementsCheck.cpp
   ConstReturnTypeCheck.cpp
   ContainerSizeEmptyCheck.cpp
   ConvertMemberFunctionsToStatic.cpp
   DeleteNullPointerCheck.cpp
   DeletedDefaultCheck.cpp
   ElseAfterReturnCheck.cpp
+  FunctionCognitiveComplexityCheck.cpp
   FunctionSizeCheck.cpp
   IdentifierNamingCheck.cpp
   ImplicitBoolConversionCheck.cpp
   InconsistentDeclarationParameterNameCheck.cpp
   IsolateDeclarationCheck.cpp
   MagicNumbersCheck.cpp
   MakeMemberFunctionConstCheck.cpp
   MisleadingIndentationCheck.cpp

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.h

+//===--- FunctionCognitiveComplexityCheck.h - clang-tidy --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_FUNCTIONCOGNITIVECOMPLEXITYCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_FUNCTIONCOGNITIVECOMPLEXITYCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+/// Checks function Cognitive Complexity metric.
+///
+/// There is only one configuration option:
+///
+///   * `Threshold` - flag functions with Cognitive Complexity exceeding
+///     this number. The default is `25`.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/readability-function-cognitive-complexity.html
+class FunctionCognitiveComplexityCheck : public ClangTidyCheck {
+public:
+  FunctionCognitiveComplexityCheck(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 Threshold;
+};
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_FUNCTIONCOGNITIVECOMPLEXITYCHECK_H

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

+//===--- FunctionCognitiveComplexityCheck.cpp - clang-tidy ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "FunctionCognitiveComplexityCheck.h"
+#include "../ClangTidyDiagnosticConsumer.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/Stmt.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/ASTMatchers/ASTMatchersInternal.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticIDs.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <array>
+#include <cassert>
+#include <stack>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace readability {
+namespace {
+
+struct CognitiveComplexity final {
+  // Any increment is based on some combination of reasons.
+  // For details you can look at the Specification at
+  // https://www.sonarsource.com/docs/CognitiveComplexity.pdf
+  // or user-facing docs at
+  // http://clang.llvm.org/extra/clang-tidy/checks/readability-function-cognitive-complexity.html
+  // Here are all the possible reasons:
+  enum Criteria : uint8_t {
+    None = 0U,
+
+    // B1, increases cognitive complexity (by 1)
+    // What causes it:
+    // * if, else if, else, ConditionalOperator (not BinaryConditionalOperator)
+    // * SwitchStmt
+    // * ForStmt, CXXForRangeStmt
+    // * WhileStmt, DoStmt
+    // * CXXCatchStmt
+    // * GotoStmt, IndirectGotoStmt (but not BreakStmt, ContinueStmt)
+    // * sequences of binary logical operators (BinOpLAnd, BinOpLOr)
+    // * each method in a recursion cycle (not implemented)
+    Increment = 1U << 0,
+
+    // B2, increases current nesting level (by 1)
+    // What causes it:
+    // * if, else if, else, ConditionalOperator (not BinaryConditionalOperator)
+    // * SwitchStmt
+    // * ForStmt, CXXForRangeStmt
+    // * WhileStmt, DoStmt
+    // * CXXCatchStmt
+    // * nested CXXConstructor, CXXDestructor, CXXMethod (incl. C++11 Lambda)
+    // * GNU Statement Expression
+    // * Apple Block declaration
+    IncrementNesting = 1U << 1,
+
+    // B3, increases cognitive complexity by the current nesting level
+    // Applied before IncrementNesting
+    // What causes it:
+    // * IfStmt, ConditionalOperator (not BinaryConditionalOperator)
+    // * SwitchStmt
+    // * ForStmt, CXXForRangeStmt
+    // * WhileStmt, DoStmt
+    // * CXXCatchStmt
+    PenalizeNesting = 1U << 2,
+
+    All = Increment | PenalizeNesting | IncrementNesting,
+  };
+
+  // The helper struct used to record one increment occurrence, with all the
+  // details nessesary.
+  struct Detail {
+    const SourceLocation Loc;     // What caused the increment?
+    const unsigned short Nesting; // How deeply nested is Loc located?
+    const Criteria C;             // The criteria of the increment
+
+    Detail(SourceLocation SLoc, unsigned short CurrentNesting, Criteria Crit)
+        : Loc(SLoc), Nesting(CurrentNesting), C(Crit) {}
+
+    // To minimize the sizeof(Detail), we only store the minimal info there.
+    // This function is used to convert from the stored info into the usable
+    // information - what message to output, how much of an increment did this
+    // occurrence actually result in.
+    std::pair<unsigned, unsigned short> process() const {
+      assert(C != Criteria::None && "invalid criteria");
+
+      unsigned MsgId;           // The id of the message to output.
+      unsigned short Increment; // How much of an increment?
+
+      if (C == Criteria::All) {
+        Increment = 1 + Nesting;
+        MsgId = 0;
+      } else if (C == (Criteria::Increment | Criteria::IncrementNesting)) {
+        Increment = 1;
+        MsgId = 1;
+      } else if (C == Criteria::Increment) {
+        Increment = 1;
+        MsgId = 2;
+      } else if (C == Criteria::IncrementNesting) {
+        Increment = 0; // Unused in this message.
+        MsgId = 3;
+      } else
+        llvm_unreachable("should not get to here.");
+
+      return std::make_pair(MsgId, Increment);
+    }
+  };
+
+  // Limit of 25 is the "upstream"'s default.
+  static constexpr unsigned DefaultLimit = 25U;
+
+  // Based on the publicly-avaliable numbers for some big open-source projects
+  // https://sonarcloud.io/projects?languages=c%2Ccpp&size=5   we can estimate:
+  // value ~20 would result in no allocs for 98% of functions, ~12 for 96%, ~10
+  // for 91%, ~8 for 88%, ~6 for 84%, ~4 for 77%, ~2 for 64%, and ~1 for 37%.
+  static_assert(sizeof(Detail) <= 8,
+                "Since we use SmallVector to minimize the amount of "
+                "allocations, we also need to consider the price we pay for "
+                "that in terms of stack usage. "
+                "Thus, it is good to minimize the size of the Detail struct.");
+  SmallVector<Detail, DefaultLimit> Details; // 25 elements is 200 bytes.
+  // Yes, 25 is a magic number. This is the seemingly-sane default for the
+  // upper limit for function cognitive complexity. Thus it would make sense
+  // to avoid allocations for any function that does not violate the limit.
+
+  // The grand total Cognitive Complexity of the function.
+  unsigned Total = 0;
+
+  // The function used to store new increment, calculate the total complexity.
+  void account(SourceLocation Loc, unsigned short Nesting, Criteria C);
+};
+
+// All the possible messages that can be output. The choice of the message
+// to use is based of the combination of the CognitiveComplexity::Criteria.
+// It would be nice to have it in CognitiveComplexity struct, but then it is
+// not static.
+static const std::array<const StringRef, 4> Msgs = {{
+    // B1 + B2 + B3
+    "+%0, including nesting penalty of %1, nesting level increased to %2",
+
+    // B1 + B2
+    "+%0, nesting level increased to %2",
+
+    // B1
+    "+%0",
+
+    // B2
+    "nesting level increased to %2",
+}};
+
+// Criteria is a bitset, thus a few helpers are needed.
+CognitiveComplexity::Criteria operator|(CognitiveComplexity::Criteria LHS,
+                                        CognitiveComplexity::Criteria RHS) {
+  return static_cast<CognitiveComplexity::Criteria>(
+      static_cast<std::underlying_type<CognitiveComplexity::Criteria>::type>(
+          LHS) |
+      static_cast<std::underlying_type<CognitiveComplexity::Criteria>::type>(
+          RHS));
+}
+CognitiveComplexity::Criteria operator&(CognitiveComplexity::Criteria LHS,
+                                        CognitiveComplexity::Criteria RHS) {
+  return static_cast<CognitiveComplexity::Criteria>(
+      static_cast<std::underlying_type<CognitiveComplexity::Criteria>::type>(
+          LHS) &
+      static_cast<std::underlying_type<CognitiveComplexity::Criteria>::type>(
+          RHS));
+}
+CognitiveComplexity::Criteria &operator|=(CognitiveComplexity::Criteria &LHS,
+                                          CognitiveComplexity::Criteria RHS) {
+  LHS = operator|(LHS, RHS);
+  return LHS;
+}
+CognitiveComplexity::Criteria &operator&=(CognitiveComplexity::Criteria &LHS,
+                                          CognitiveComplexity::Criteria RHS) {
+  LHS = operator&(LHS, RHS);
+  return LHS;
+}
+
+void CognitiveComplexity::account(SourceLocation Loc, unsigned short Nesting,
+                                  Criteria C) {
+  C &= Criteria::All;
+  assert(C != Criteria::None && "invalid criteria");
+
+  Details.emplace_back(Loc, Nesting, C);
+  const Detail &D = Details.back();
+
+  unsigned MsgId;
+  unsigned short Increase;
+  std::tie(MsgId, Increase) = D.process();
+
+  Total += Increase;
+}
+
+class FunctionASTVisitor final
+    : public RecursiveASTVisitor<FunctionASTVisitor> {
+  using Base = RecursiveASTVisitor<FunctionASTVisitor>;
+
+  // The current nesting level (increased by Criteria::IncrementNesting).
+  unsigned short CurrentNestingLevel = 0;
+
+  // Used to efficiently know the last type of the binary sequence operator
+  // that was encountered. It would make sense for the function call to start
+  // the new sequence, thus it is a stack.
+  using OBO = Optional<BinaryOperator::Opcode>;
+  std::stack<OBO, SmallVector<OBO, 4>> BinaryOperatorsStack;
+
+public:
+  bool TraverseStmtWithIncreasedNestingLevel(Stmt *Node) {
+    ++CurrentNestingLevel;
+    bool ShouldContinue = Base::TraverseStmt(Node);
+    --CurrentNestingLevel;
+    return ShouldContinue;
+  }
+
+  bool TraverseDeclWithIncreasedNestingLevel(Decl *Node) {
+    ++CurrentNestingLevel;
+    bool ShouldContinue = Base::TraverseDecl(Node);
+    --CurrentNestingLevel;
+    return ShouldContinue;
+  }
+
+  bool TraverseIfStmt(IfStmt *Node, bool InElseIf = false) {
+    if (!Node)
+      return Base::TraverseIfStmt(Node);
+
+    {
+      CognitiveComplexity::Criteria Reasons;
+
+      Reasons = CognitiveComplexity::Criteria::None;
+
+      // "If" increases cognitive complexity.
+      Reasons |= CognitiveComplexity::Criteria::Increment;
+      // "If" increases nesting level.
+      Reasons |= CognitiveComplexity::Criteria::IncrementNesting;
+
+      if (!InElseIf) {
+        // "If" receives a nesting increment commensurate with it's nested
+        // depth, if it is not part of "else if".
+        Reasons |= CognitiveComplexity::Criteria::PenalizeNesting;
+      }
+
+      CC.account(Node->getIfLoc(), CurrentNestingLevel, Reasons);
+    }
+
+    // If this IfStmt is *NOT* "else if", then only the body (i.e. "Then" and
+    // "Else") is traversed with increased Nesting level.
+    // However if this IfStmt *IS* "else if", then Nesting level is increased
+    // for the whole IfStmt (i.e. for "Init", "Cond", "Then" and "Else").
+
+    if (!InElseIf) {
+      if (!TraverseStmt(Node->getInit()))
+        return false;
+
+      if (!TraverseStmt(Node->getCond()))
+        return false;
+    } else {
+      if (!TraverseStmtWithIncreasedNestingLevel(Node->getInit()))
+        return false;
+
+      if (!TraverseStmtWithIncreasedNestingLevel(Node->getCond()))
+        return false;
+    }
+
+    // "Then" always increases nesting level.
+    if (!TraverseStmtWithIncreasedNestingLevel(Node->getThen()))
+      return false;
+
+    if (!Node->getElse())
+      return true;
+
+    if (auto *E = dyn_cast<IfStmt>(Node->getElse()))
+      return TraverseIfStmt(E, true);
+
+    {
+      CognitiveComplexity::Criteria Reasons;
+
+      Reasons = CognitiveComplexity::Criteria::None;
+
+      // "Else" increases cognitive complexity.
+      Reasons |= CognitiveComplexity::Criteria::Increment;
+      // "Else" increases nesting level.
+      Reasons |= CognitiveComplexity::Criteria::IncrementNesting;
+      // "Else" DOES NOT receive a nesting increment commensurate with it's
+      // nested depth.
+
+      CC.account(Node->getElseLoc(), CurrentNestingLevel, Reasons);
+    }
+
+    // "Else" always increases nesting level.
+    return TraverseStmtWithIncreasedNestingLevel(Node->getElse());
+  }
+
+// The currently-being-processed stack entry, which is always the top.
+#define CurrentBinaryOperator BinaryOperatorsStack.top()
+
+  // In a sequence of binary logical operators, if the new operator is different
+  // from the previous one, then the cognitive complexity is increased.
+  bool TraverseBinaryOperator(BinaryOperator *Op) {
+    if (!Op || !Op->isLogicalOp())
+      return Base::TraverseBinaryOperator(Op);
+
+    // Make sure that there is always at least one frame in the stack.
+    if (BinaryOperatorsStack.empty())
+      BinaryOperatorsStack.emplace();
+
+    // If this is the first binary operator that we are processing, or the
+    // previous binary operator was different, there is an increment.
+    if (!CurrentBinaryOperator || Op->getOpcode() != CurrentBinaryOperator)
+      CC.account(Op->getOperatorLoc(), CurrentNestingLevel,
+                 CognitiveComplexity::Criteria::Increment);
+
+    // We might encounter a function call, which starts a new sequence, thus
+    // we need to save the current previous binary operator.
+    const Optional<BinaryOperator::Opcode> BinOpCopy(CurrentBinaryOperator);
+
+    // Record the operator that we are currently processing and traverse it.
+    CurrentBinaryOperator = Op->getOpcode();
+    bool ShouldContinue = Base::TraverseBinaryOperator(Op);
+
+    // And restore the previous binary operator, which might be nonexistent.
+    CurrentBinaryOperator = BinOpCopy;
+
+    return ShouldContinue;
+  }
+
+  // It would make sense for the function call to start the new binary
+  // operator sequence, thus let's make sure that it creates a new stack frame.
+  bool TraverseCallExpr(CallExpr *Node) {
+    // If we are not currently processing any binary operator sequence, then
+    // no Node-handling is needed.
+    if (!Node || BinaryOperatorsStack.empty() || !CurrentBinaryOperator)
+      return Base::TraverseCallExpr(Node);
+
+    // Else, do add [uninitialized] frame to the stack, and traverse call.
+    BinaryOperatorsStack.emplace();
+    bool ShouldContinue = Base::TraverseCallExpr(Node);
+    // And remove the top frame.
+    BinaryOperatorsStack.pop();
+
+    return ShouldContinue;
+  }
+
+#undef CurrentBinaryOperator
+
+  bool TraverseStmt(Stmt *Node) {
+    if (!Node)
+      return Base::TraverseStmt(Node);
+
+    // Three following switch()'es have huge duplication, but it is better to
+    // keep them separate, to simplify comparing them with the Specification.
+
+    CognitiveComplexity::Criteria Reasons = CognitiveComplexity::Criteria::None;
+    SourceLocation Location = Node->getBeginLoc();
+
+    // B1. Increments
+    // There is an increment for each of the following:
+    switch (Node->getStmtClass()) {
+    // if, else if, else are handled in TraverseIfStmt(),
+    // FIXME: "each method in a recursion cycle" Increment is not implemented.
+    case Stmt::ConditionalOperatorClass:
+    case Stmt::SwitchStmtClass:
+    case Stmt::ForStmtClass:
+    case Stmt::CXXForRangeStmtClass:
+    case Stmt::WhileStmtClass:
+    case Stmt::DoStmtClass:
+    case Stmt::CXXCatchStmtClass:
+    case Stmt::GotoStmtClass:
+    case Stmt::IndirectGotoStmtClass:
+      Reasons |= CognitiveComplexity::Criteria::Increment;
+      break;
+    default:
+      // break LABEL, continue LABEL increase cognitive complexity,
+      // but they are not supported in C++ or C.
+      // Regular break/continue do not increase cognitive complexity.
+      break;
+    }
+
+    // B2. Nesting level
+    // The following structures increment the nesting level:
+    switch (Node->getStmtClass()) {
+    // if, else if, else are handled in TraverseIfStmt(),
+    // Nested methods and such are handled in TraverseDecl.
+    case Stmt::ConditionalOperatorClass:
+    case Stmt::SwitchStmtClass:
+    case Stmt::ForStmtClass:
+    case Stmt::CXXForRangeStmtClass:
+    case Stmt::WhileStmtClass:
+    case Stmt::DoStmtClass:
+    case Stmt::CXXCatchStmtClass:
+    case Stmt::LambdaExprClass:
+    case Stmt::StmtExprClass:
+      Reasons |= CognitiveComplexity::Criteria::IncrementNesting;
+      break;
+    default:
+      break;
+    }
+
+    // B3. Nesting increments
+    // The following structures receive a nesting increment
+    // commensurate with their nested depth inside B2 structures:
+    switch (Node->getStmtClass()) {
+    // if, else if, else are handled in TraverseIfStmt().
+    case Stmt::ConditionalOperatorClass:
+    case Stmt::SwitchStmtClass:
+    case Stmt::ForStmtClass:
+    case Stmt::CXXForRangeStmtClass:
+    case Stmt::WhileStmtClass:
+    case Stmt::DoStmtClass:
+    case Stmt::CXXCatchStmtClass:
+      Reasons |= CognitiveComplexity::Criteria::PenalizeNesting;
+      break;
+    default:
+      break;
+    }
+
+    if (Node->getStmtClass() == Stmt::ConditionalOperatorClass) {
+      // A little beautification.
+      // For conditional operator "cond ? true : false" point at the "?"
+      // symbol.
+      ConditionalOperator *COp = dyn_cast<ConditionalOperator>(Node);
+      Location = COp->getQuestionLoc();
+    }
+
+    // If we have found any reasons, let's account it.
+    if (Reasons & CognitiveComplexity::Criteria::All)
+      CC.account(Location, CurrentNestingLevel, Reasons);
+
+    // Did we decide that the nesting level should be increased?
+    if (!(Reasons & CognitiveComplexity::Criteria::IncrementNesting))
+      return Base::TraverseStmt(Node);
+
+    return TraverseStmtWithIncreasedNestingLevel(Node);
+  }
+
+  // The parameter MainAnalyzedFunction is needed to differentiate between the
+  // cases where TraverseDecl() is the entry point from
+  // FunctionCognitiveComplexityCheck::check() and the cases where it was called
+  // from the FunctionASTVisitor itself. Explanation: if we get a function
+  // definition (e.g. constructor, destructor, method), the Cognitive Complexity
+  // specification states that the Nesting level shall be increased. But if this
+  // function is the entry point, then the Nesting level should not be
+  // increased. Thus that parameter is there and is used to fall-through
+  // directly to traversing if this is the main function that is being analyzed.
+  bool TraverseDecl(Decl *Node, bool MainAnalyzedFunction = false) {
+    if (!Node || MainAnalyzedFunction)
+      return Base::TraverseDecl(Node);
+
+    // B2. Nesting level
+    // The following structures increment the nesting level:
+    switch (Node->getKind()) {
+    case Decl::Function:
+    case Decl::CXXMethod:
+    case Decl::CXXConstructor:
+    case Decl::CXXDestructor:
+    case Decl::Block:
+      break;
+    default:
+      // If this is something else, we use early return!
+      return Base::TraverseDecl(Node);
+      break;
+    }
+
+    CC.account(Node->getBeginLoc(), CurrentNestingLevel,
+               CognitiveComplexity::Criteria::IncrementNesting);
+
+    return TraverseDeclWithIncreasedNestingLevel(Node);
+  }
+
+  CognitiveComplexity CC;
+};
+
+} // namespace
+
+FunctionCognitiveComplexityCheck::FunctionCognitiveComplexityCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      Threshold(Options.get("Threshold", CognitiveComplexity::DefaultLimit)) {}
+
+void FunctionCognitiveComplexityCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "Threshold", Threshold);
+}
+
+void FunctionCognitiveComplexityCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      functionDecl(
+          allOf(isDefinition(), unless(anyOf(isDefaulted(), isDeleted(),
+                                             isImplicit(), isInstantiated()))))
+          .bind("func"),
+      this);
+}
+
+void FunctionCognitiveComplexityCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
+  assert(Func->hasBody() && "The matchers should only match the functions that "
+                            "have user-provided body.");
+
+  FunctionASTVisitor Visitor;
+  Visitor.TraverseDecl(const_cast<FunctionDecl *>(Func), true);
+
+  if (Visitor.CC.Total <= Threshold)
+    return;
+
+  diag(Func->getLocation(),
+       "function %0 has cognitive complexity of %1 (threshold %2)")
+      << Func << Visitor.CC.Total << Threshold;
+
+  // Output all the basic increments of complexity.
+  for (const auto &Detail : Visitor.CC.Details) {
+    unsigned MsgId;          // The id of the message to output.
+    unsigned short Increase; // How much of an increment?
+    std::tie(MsgId, Increase) = Detail.process();
+    assert(MsgId < Msgs.size() && "MsgId should always be valid");
+    // Increase, on the other hand, can be 0.
+
+    diag(Detail.Loc, Msgs[MsgId], DiagnosticIDs::Note)
+        << Increase << Detail.Nesting << 1 + Detail.Nesting;
+  }
+}
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang

clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp

 #include "AvoidConstParamsInDecls.h"
 #include "BracesAroundStatementsCheck.h"
 #include "ConstReturnTypeCheck.h"
 #include "ContainerSizeEmptyCheck.h"
 #include "ConvertMemberFunctionsToStatic.h"
 #include "DeleteNullPointerCheck.h"
 #include "DeletedDefaultCheck.h"
 #include "ElseAfterReturnCheck.h"
+#include "FunctionCognitiveComplexityCheck.h"
 #include "FunctionSizeCheck.h"
 #include "IdentifierNamingCheck.h"
 #include "ImplicitBoolConversionCheck.h"
 #include "InconsistentDeclarationParameterNameCheck.h"
 #include "IsolateDeclarationCheck.h"
 #include "MagicNumbersCheck.h"
 #include "MakeMemberFunctionConstCheck.h"
 #include "MisleadingIndentationCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<ConvertMemberFunctionsToStatic>(
         "readability-convert-member-functions-to-static");
     CheckFactories.registerCheck<DeleteNullPointerCheck>(
         "readability-delete-null-pointer");
     CheckFactories.registerCheck<DeletedDefaultCheck>(
         "readability-deleted-default");
     CheckFactories.registerCheck<ElseAfterReturnCheck>(
         "readability-else-after-return");
+    CheckFactories.registerCheck<FunctionCognitiveComplexityCheck>(
+        "readability-function-cognitive-complexity");
     CheckFactories.registerCheck<FunctionSizeCheck>(
         "readability-function-size");
     CheckFactories.registerCheck<IdentifierNamingCheck>(
         "readability-identifier-naming");
     CheckFactories.registerCheck<ImplicitBoolConversionCheck>(
         "readability-implicit-bool-conversion");
     CheckFactories.registerCheck<InconsistentDeclarationParameterNameCheck>(
         "readability-inconsistent-declaration-parameter-name");

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`bugprone-misplaced-pointer-arithmetic-in-alloc
   <clang-tidy/checks/bugprone-misplaced-pointer-arithmetic-in-alloc>` check.
 
 - New :doc:`bugprone-redundant-branch-condition
   <clang-tidy/checks/bugprone-redundant-branch-condition>` check.
 
   Finds condition variables in nested ``if`` statements that were also checked
   in the outer ``if`` statement and were not changed.
 
+- New :doc:`readability-function-cognitive-complexity
+  <clang-tidy/checks/readability-function-cognitive-complexity>` check.
+
+  Flags functions with Cognitive Complexity metric exceeding the configured limit.
+
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Improved :doc:`readability-identifier-naming
   <clang-tidy/checks/readability-identifier-naming>` check.
 
   Added an option `GetConfigPerFile` to support including files which use
   different naming styles.

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `readability-avoid-const-params-in-decls <readability-avoid-const-params-in-decls.html>`_,
    `readability-braces-around-statements <readability-braces-around-statements.html>`_, "Yes"
    `readability-const-return-type <readability-const-return-type.html>`_, "Yes"
    `readability-container-size-empty <readability-container-size-empty.html>`_, "Yes"
    `readability-convert-member-functions-to-static <readability-convert-member-functions-to-static.html>`_,
    `readability-delete-null-pointer <readability-delete-null-pointer.html>`_, "Yes"
    `readability-deleted-default <readability-deleted-default.html>`_,
    `readability-else-after-return <readability-else-after-return.html>`_, "Yes"
+   `readability-function-cognitive-complexity <readability-function-cognitive-complexity.html>`_,
    `readability-function-size <readability-function-size.html>`_,
    `readability-identifier-naming <readability-identifier-naming.html>`_, "Yes"
    `readability-implicit-bool-conversion <readability-implicit-bool-conversion.html>`_, "Yes"
    `readability-inconsistent-declaration-parameter-name <readability-inconsistent-declaration-parameter-name.html>`_, "Yes"
    `readability-isolate-declaration <readability-isolate-declaration.html>`_, "Yes"
    `readability-magic-numbers <readability-magic-numbers.html>`_,
    `readability-make-member-function-const <readability-make-member-function-const.html>`_, "Yes"
    `readability-misleading-indentation <readability-misleading-indentation.html>`_,

clang-tools-extra/docs/clang-tidy/checks/readability-function-cognitive-complexity.rst

+.. title:: clang-tidy - readability-function-cognitive-complexity
+
+readability-function-cognitive-complexity
+=========================================
+
+Checks function Cognitive Complexity metric.
+
+The metric is implemented as per the `COGNITIVE COMPLEXITY by SonarSource
+<https://www.sonarsource.com/docs/CognitiveComplexity.pdf>`_ specification
+version 1.2 (19 April 2017).
+
+Options
+-------
+
+.. option:: Threshold
+
+   Flag functions with Cognitive Complexity exceeding this number.
+   The default is `25`.
+
+Building blocks
+---------------
+
+There are three basic building blocks of a Cognitive Complexity metric:
+
+Increment
+^^^^^^^^^
+
+The following structures increase the function's Cognitive Complexity metric
+(by `1`):
+
+* Conditional operators:
+
+   - ``if()``
+   - ``else if()``
+   - ``else``
+   - ``cond ? true : false``
+
+* ``switch()``
+* Loops:
+
+   - ``for()``
+   - C++11 range-based ``for()``
+   - ``while()``
+   - ``do while()``
+
+* ``catch ()``
+* ``goto LABEL``, ``goto *(&&LABEL))``,
+* sequences of binary logical operators:
+
+   - ``boolean1 || boolean2``
+   - ``boolean1 && boolean2``
+
+Nesting level
+^^^^^^^^^^^^^
+
+While by itself the nesting level not change the function's Cognitive Complexity
+metric, it is tracked, and is used by the next, third building block.
+The following structures increase the nesting level (by `1`):
+
+* Conditional operators:
+
+   - ``if()``
+   - ``else if()``
+   - ``else``
+   - ``cond ? true : false``
+
+* ``switch()``
+* Loops:
+
+   - ``for()``
+   - C++11 range-based ``for()``
+   - ``while()``
+   - ``do while()``
+
+* ``catch ()``
+* Nested functions:
+
+   - C++11 Lambda
+   - Nested ``class``
+   - Nested ``struct``
+* GNU statement expression
+* Apple Block Declaration
+
+Nesting increment
+^^^^^^^^^^^^^^^^^
+
+This is where the previous basic building block, `Nesting level`_, matters.
+The following structures increase the function's Cognitive Complexity metric by
+the current `Nesting level`_:
+
+* Conditional operators:
+
+   - ``if()``
+   - ``cond ? true : false``
+
+* ``switch()``
+* Loops:
+
+   - ``for()``
+   - C++11 range-based ``for()``
+   - ``while()``
+   - ``do while()``
+
+* ``catch ()``
+
+Examples
+--------
+
+The simplest case. This function has Cognitive Complexity of `0`.
+
+.. code-block:: c++
+
+  void function0() {}
+
+Slightly better example. This function has Cognitive Complexity of `1`.
+
+.. code-block:: c++
+
+  int function1(bool var) {
+    if(var) // +1, nesting level +1
+      return 42;
+    return 0;
+  }
+
+Full example. This function has Cognitive Complexity of `3`.
+
+.. code-block:: c++
+
+  int function3(bool var1, bool var2) {
+    if(var1) { // +1, nesting level +1
+      if(var2)  // +2 (1 + current nesting level of 1), nesting level +1
+        return 42;
+    }
+
+    return 0;
+  }
+
+Limitations
+-----------
+
+The metric is implemented with two notable exceptions:
+   * `preprocessor conditionals` (``#ifdef``, ``#if``, ``#elif``, ``#else``,
+     ``#endif``) are not accounted for.
+   * `each method in a recursion cycle` is not accounted for. It can't be fully
+     implemented, because cross-translational-unit analysis would be needed,
+     which is currently not possible in clang-tidy.

clang-tools-extra/test/clang-tidy/checkers/readability-function-cognitive-complexity.cpp

+// RUN: %check_clang_tidy %s readability-function-cognitive-complexity %t -- -config='{CheckOptions: [{key: readability-function-cognitive-complexity.Threshold, value: 0}]}' -- -std=c++11 -fblocks -w
+
+// any function should be checked.
+
+extern int ext_func(int x = 0);
+
+int some_func(int x = 0);
+
+static int some_other_func(int x = 0) {}
+
+template<typename T> void some_templ_func(T x = 0) {}
+
+class SomeClass {
+public:
+  int *begin(int x = 0);
+  int *end(int x = 0);
+  static int func(int x = 0);
+  template<typename T> void some_templ_func(T x = 0) {}
+  SomeClass() = default;
+  SomeClass(SomeClass&) = delete;
+};
+
+// nothing ever decreases cognitive complexity, so we can check all the things
+// in one go. none of the following should increase cognitive complexity:
+void unittest_false() {
+  {};
+  ext_func();
+  some_func();
+  some_other_func();
+  some_templ_func<int>();
+  some_templ_func<bool>();
+  SomeClass::func();
+  SomeClass C;
+  C.some_templ_func<int>();
+  C.some_templ_func<bool>();
+  C.func();
+  C.end();
+  int i = some_func();
+  i = i;
+  i++;
+  --i;
+  i < 0;
+  int j = 0 ?: 1;
+  auto k = new int;
+  delete k;
+  throw i;
+  {
+    throw i;
+  }
+end:
+  return;
+}
+
+#if 1
+#define CC100
+#else
+// this macro has cognitive complexity of 100.
+// it is needed to be able to compare the testcases with the
+// reference Sonar implementation. please place it right after the first
+// CHECK-NOTES in each function
+#define CC100 if(1){if(1){if(1){if(1){if(1){if(1){if(1){if(1){if(1){if(1){if(1){if(1){if(1){}}}}}if(1){}}}}}}}}}
+#endif
+
+//----------------------------------------------------------------------------//
+//------------------------------ B1. Increments ------------------------------//
+//----------------------------------------------------------------------------//
+// Check that every thing listed in B1 of the specification does indeed       //
+// recieve the base increment, and that not-body does not increase nesting    //
+//----------------------------------------------------------------------------//
+
+// break does not increase cognitive complexity.
+// only  break LABEL  does, but it is unavaliable in C or C++
+
+// continue does not increase cognitive complexity.
+// only  continue LABEL  does, but it is unavaliable in C or C++
+
+void unittest_b1_00() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_00' has cognitive complexity of 33 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if (1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:9: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+
+    if (1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:11: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    } else if (1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:12: note: +1, nesting level increased to 2{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:18: note: +3, including nesting penalty of 2, nesting level increased to 3{{$}}
+    } else {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, nesting level increased to 2{{$}}
+    }
+  } else if (1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:10: note: +1, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:16: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+
+    if (1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:11: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    } else if (1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:12: note: +1, nesting level increased to 2{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:18: note: +3, including nesting penalty of 2, nesting level increased to 3{{$}}
+    } else {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, nesting level increased to 2{{$}}
+    }
+  } else {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +1, nesting level increased to 1{{$}}
+
+    if (1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:11: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    } else if (1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:12: note: +1, nesting level increased to 2{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:18: note: +3, including nesting penalty of 2, nesting level increased to 3{{$}}
+    } else {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+void unittest_b1_01() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_01' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  int i = (1 ? 1 : 0) ? 1 : 0;
+// CHECK-NOTES: :[[@LINE-1]]:23: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:14: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+}
+
+void unittest_b1_02(int x) {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_02' has cognitive complexity of 9 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  switch (1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:13: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+  case -1:
+    return;
+  case 1 ? 1 : 0:
+// CHECK-NOTES: :[[@LINE-1]]:10: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    return;
+  case (1 ? 2 : 0) ... (1 ? 3 : 0):
+// CHECK-NOTES: :[[@LINE-1]]:11: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:27: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    return;
+  default:
+    break;
+  }
+}
+
+void unittest_b1_03(int x) {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_03' has cognitive complexity of 7 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  for (x = 1 ? 1 : 0; x < (1 ? 1 : 0); x += 1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:14: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:30: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+// CHECK-NOTES: :[[@LINE-4]]:47: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    break;
+    continue;
+  }
+}
+
+void unittest_b1_04() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_04' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  SomeClass C;
+  for (int i : (1 ? C : C)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:19: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    break;
+    continue;
+  }
+}
+
+void unittest_b1_05() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_05' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  while (1 ? 1 : 0) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:12: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    break;
+    continue;
+  }
+}
+
+void unittest_b1_06() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_06' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  do {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    break;
+    continue;
+  } while (1 ? 1 : 0);
+// CHECK-NOTES: :[[@LINE-1]]:14: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+}
+
+void unittest_b1_07() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_07' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  try {
+  } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+  }
+}
+
+void unittest_b1_08_00() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_08_00' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  goto end;
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1{{$}}
+end:
+  return;
+}
+
+void unittest_b1_08_01() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_08_01' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  void *ptr = &&end;
+  goto *ptr;
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1{{$}}
+end:
+  return;
+}
+
+void unittest_b1_09_00() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_09_00' has cognitive complexity of 34 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if(1 && 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+  }
+  if(1 && 1 && 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:13: note: +1{{$}}
+  }
+  if((1 && 1) && 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:15: note: +1{{$}}
+  }
+  if(1 && (1 && 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+  }
+
+  if(1 && 1 || 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:13: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:8: note: +1{{$}}
+  }
+  if((1 && 1) || 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:15: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:9: note: +1{{$}}
+  }
+  if(1 && (1 || 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:14: note: +1{{$}}
+  }
+
+  if(1 || 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+  }
+  if(1 || 1 || 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:13: note: +1{{$}}
+  }
+  if((1 || 1) || 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:15: note: +1{{$}}
+  }
+  if(1 || (1 || 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+  }
+
+  if(1 || 1 && 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:13: note: +1{{$}}
+  }
+  if((1 || 1) && 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:15: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:9: note: +1{{$}}
+  }
+  if(1 || (1 && 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:14: note: +1{{$}}
+  }
+}
+
+void unittest_b1_09_01() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_09_01' has cognitive complexity of 40 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if(1 && some_func(1 && 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:23: note: +1{{$}}
+  }
+  if(1 && some_func(1 || 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:23: note: +1{{$}}
+  }
+  if(1 || some_func(1 || 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:23: note: +1{{$}}
+  }
+  if(1 || some_func(1 && 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:23: note: +1{{$}}
+  }
+
+  if(1 && some_func(1 && 1) && 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:29: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:23: note: +1{{$}}
+  }
+  if(1 && some_func(1 || 1) && 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:29: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:23: note: +1{{$}}
+  }
+  if(1 || some_func(1 || 1) && 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:29: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-4]]:23: note: +1{{$}}
+  }
+  if(1 || some_func(1 && 1) && 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:29: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-4]]:23: note: +1{{$}}
+  }
+
+  if(1 && some_func(1 && 1) || 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:29: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-4]]:23: note: +1{{$}}
+  }
+  if(1 && some_func(1 || 1) || 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:29: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-4]]:23: note: +1{{$}}
+  }
+  if(1 || some_func(1 || 1) || 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:29: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:23: note: +1{{$}}
+  }
+  if(1 || some_func(1 && 1) || 1) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:29: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:23: note: +1{{$}}
+  }
+}
+
+void unittest_b1_09_02() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b1_09_02' has cognitive complexity of 12 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if(1 && SomeClass::func(1 && 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:29: note: +1{{$}}
+  }
+  if(1 && SomeClass::func(1 || 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:29: note: +1{{$}}
+  }
+  if(1 || SomeClass::func(1 || 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:29: note: +1{{$}}
+  }
+  if(1 || SomeClass::func(1 && 1)) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:8: note: +1{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:29: note: +1{{$}}
+  }
+}
+
+// FIXME: each method in a recursion cycle
+
+//----------------------------------------------------------------------------//
+//---------------------------- B2. Nesting lebel -----------------------------//
+//----------------------------------------------------------------------------//
+// Check that every thing listed in B2 of the specification does indeed       //
+// increase the nesting level                                                 //
+//----------------------------------------------------------------------------//
+
+void unittest_b2_00() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_00' has cognitive complexity of 9 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    if(true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  } else if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:10: note: +1, nesting level increased to 1{{$}}
+    if(true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  } else {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +1, nesting level increased to 1{{$}}
+    if(true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+void unittest_b2_01() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_01' has cognitive complexity of 5 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  int i = 1 ? (1 ? 1 : 0) : (1 ? 1 : 0);
+// CHECK-NOTES: :[[@LINE-1]]:13: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+// CHECK-NOTES: :[[@LINE-2]]:18: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+// CHECK-NOTES: :[[@LINE-3]]:32: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+}
+
+void unittest_b2_02(int x) {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_02' has cognitive complexity of 5 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  switch (x) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+  case -1:
+    if(true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+    return;
+  default:
+    if(true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+    return;
+  }
+}
+
+void unittest_b2_03() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_03' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  for (;;) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    if(true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+void unittest_b2_04() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_04' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  SomeClass C;
+  for (int i : C) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    if(true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+void unittest_b2_05() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_05' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  while (true) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    if(true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+void unittest_b2_06() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_06' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  do {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    if(true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  } while (true);
+}
+
+void unittest_b2_07() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_07' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  try {
+  } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    if(true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+void unittest_b2_08_00() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_08_00' has cognitive complexity of 10 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  class X {
+    X() {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: nesting level increased to 1{{$}}
+      CC100;
+
+      if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+      }
+    }
+
+    X &operator=(const X &other) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: nesting level increased to 1{{$}}
+      CC100;
+
+      if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+      }
+    }
+
+    ~X() {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: nesting level increased to 1{{$}}
+      CC100;
+
+      if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+      }
+    }
+
+    void Y() {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: nesting level increased to 1{{$}}
+      CC100;
+
+      if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+      }
+    }
+
+    static void Z() {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: nesting level increased to 1{{$}}
+      CC100;
+
+      if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+      }
+    }
+
+// CHECK-NOTES: :[[@LINE-45]]:5: warning: function 'X' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-42]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+
+// CHECK-NOTES: :[[@LINE-39]]:8: warning: function 'operator=' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-36]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+
+// CHECK-NOTES: :[[@LINE-33]]:5: warning: function '~X' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-30]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+
+// CHECK-NOTES: :[[@LINE-27]]:10: warning: function 'Y' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-24]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+
+// CHECK-NOTES: :[[@LINE-21]]:17: warning: function 'Z' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-18]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+  };
+}
+
+void unittest_b2_08_01() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_08_01' has cognitive complexity of 10 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  struct X {
+    X() {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: nesting level increased to 1{{$}}
+      CC100;
+
+      if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+      }
+    }
+
+    X &operator=(const X &other) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: nesting level increased to 1{{$}}
+      CC100;
+
+      if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+      }
+    }
+
+    ~X() {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: nesting level increased to 1{{$}}
+      CC100;
+
+      if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+      }
+    }
+
+    void Y() {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: nesting level increased to 1{{$}}
+      CC100;
+
+      if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+      }
+    }
+
+    static void Z() {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: nesting level increased to 1{{$}}
+      CC100;
+
+      if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+      }
+    }
+
+// CHECK-NOTES: :[[@LINE-45]]:5: warning: function 'X' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-42]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+
+// CHECK-NOTES: :[[@LINE-39]]:8: warning: function 'operator=' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-36]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+
+// CHECK-NOTES: :[[@LINE-33]]:5: warning: function '~X' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-30]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+
+// CHECK-NOTES: :[[@LINE-27]]:10: warning: function 'Y' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-24]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+
+// CHECK-NOTES: :[[@LINE-21]]:17: warning: function 'Z' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-18]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+  };
+}
+
+void unittest_b2_08_02() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_08_02' has cognitive complexity of 2 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  auto fun = []() {
+// CHECK-NOTES: :[[@LINE-1]]:14: note: nesting level increased to 1{{$}}
+    if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  };
+// CHECK-NOTES: :[[@LINE-6]]:14: warning: function 'operator()' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-5]]:5: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+}
+
+void unittest_b2_09() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_09' has cognitive complexity of 2 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  ({
+// CHECK-NOTES: :[[@LINE-1]]:3: note: nesting level increased to 1{{$}}
+    if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  });
+}
+
+void unittest_b2_10() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b2_10' has cognitive complexity of 2 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  void (^foo)(void) = ^(void) {
+// CHECK-NOTES: :[[@LINE-1]]:23: note: nesting level increased to 1{{$}}
+    if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  };
+}
+
+//----------------------------------------------------------------------------//
+//-------------------------- B3. Nesting increments --------------------------//
+//----------------------------------------------------------------------------//
+// Check that every thing listed in B3 of the specification does indeed       //
+// recieve the penalty of the current nesting level                           //
+//----------------------------------------------------------------------------//
+
+void unittest_b3_00() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b3_00' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+void unittest_b3_01() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b3_01' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    int i = 1 ? 1 : 0;
+// CHECK-NOTES: :[[@LINE-1]]:15: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+  }
+}
+
+void unittest_b3_02(int x) {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b3_02' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    switch (x) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    case -1:
+      return;
+    default:
+      return;
+    }
+  }
+}
+
+void unittest_b3_03() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b3_03' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    for (;;) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+void unittest_b3_04() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b3_04' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    SomeClass C;
+    for (int i : C) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+void unittest_b3_05() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b3_05' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    while (true) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+void unittest_b3_06() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b3_06' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    do {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    } while (true);
+  }
+}
+
+void unittest_b3_07() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'unittest_b3_07' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  if (true) {
+// CHECK-NOTES: :[[@LINE-1]]:3: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +2, including nesting penalty of 1, nesting level increased to 2{{$}}
+    }
+  }
+}
+
+//----------------------------------------------------------------------------//
+// Check that functions are being checked                                     //
+//----------------------------------------------------------------------------//
+
+class CheckClass {
+  CheckClass(int x) {
+// CHECK-NOTES: :[[@LINE-1]]:3: warning: function 'CheckClass' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  void PrivateMemberFunction() {
+// CHECK-NOTES: :[[@LINE-1]]:8: warning: function 'PrivateMemberFunction' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  void PrivateConstMemberFunction() const {
+// CHECK-NOTES: :[[@LINE-1]]:8: warning: function 'PrivateConstMemberFunction' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  static void PrivateStaticMemberFunction() {
+// CHECK-NOTES: :[[@LINE-1]]:15: warning: function 'PrivateStaticMemberFunction' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+public:
+  CheckClass() {
+// CHECK-NOTES: :[[@LINE-1]]:3: warning: function 'CheckClass' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  operator bool() const {
+// CHECK-NOTES: :[[@LINE-1]]:3: warning: function 'operator bool' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  ~CheckClass() {
+// CHECK-NOTES: :[[@LINE-1]]:3: warning: function '~CheckClass' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  void PublicMemberFunction() {
+// CHECK-NOTES: :[[@LINE-1]]:8: warning: function 'PublicMemberFunction' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  void PublicConstMemberFunction() const {
+// CHECK-NOTES: :[[@LINE-1]]:8: warning: function 'PublicConstMemberFunction' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  static void PublicStaticMemberFunction() {
+// CHECK-NOTES: :[[@LINE-1]]:15: warning: function 'PublicStaticMemberFunction' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  void PublicFunctionDefinition();
+
+protected:
+  CheckClass(bool b) {
+// CHECK-NOTES: :[[@LINE-1]]:3: warning: function 'CheckClass' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  void ProtectedMemberFunction() {
+// CHECK-NOTES: :[[@LINE-1]]:8: warning: function 'ProtectedMemberFunction' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  void ProtectedConstMemberFunction() const {
+// CHECK-NOTES: :[[@LINE-1]]:8: warning: function 'ProtectedConstMemberFunction' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+
+  static void ProtectedStaticMemberFunction() {
+// CHECK-NOTES: :[[@LINE-1]]:15: warning: function 'ProtectedStaticMemberFunction' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+    CC100;
+
+    try {
+    } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:7: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+    }
+  }
+};
+
+void CheckClass::PublicFunctionDefinition() {
+// CHECK-NOTES: :[[@LINE-1]]:18: warning: function 'PublicFunctionDefinition' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  try {
+  } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+  }
+}
+
+#define uglyfunctionmacro(name)                                                \
+  void name() {                                                                \
+    CC100;                                                                     \
+                                                                               \
+    if (true) {                                                                \
+      try {                                                                    \
+      } catch (...) {                                                          \
+      }                                                                        \
+    }                                                                          \
+  }
+
+uglyfunctionmacro(MacroFunction)
+// CHECK-NOTES: :[[@LINE-1]]:19: warning: function 'MacroFunction' has cognitive complexity of 3 (threshold 0) [readability-function-cognitive-complexity]
+// CHECK-NOTES: :[[@LINE-2]]:1: note: +1, including nesting penalty of 0, nesting level increased to 1
+// CHECK-NOTES: :[[@LINE-10]]:5: note: expanded from macro 'uglyfunctionmacro'
+// CHECK-NOTES: :[[@LINE-4]]:1: note: +2, including nesting penalty of 1, nesting level increased to 2
+// CHECK-NOTES: :[[@LINE-10]]:9: note: expanded from macro 'uglyfunctionmacro'
+
+template<typename T>
+void templatedFunction() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'templatedFunction' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  try {
+  } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+  }
+}
+
+template<>
+void templatedFunction<bool>() {
+// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'templatedFunction<bool>' has cognitive complexity of 1 (threshold 0) [readability-function-cognitive-complexity]
+  CC100;
+
+  try {
+  } catch (...) {
+// CHECK-NOTES: :[[@LINE-1]]:5: note: +1, including nesting penalty of 0, nesting level increased to 1{{$}}
+  }
+}
+
+template void templatedFunction<int>();
+
+void functionThatCallsTemplatedFunctions() {
+  templatedFunction<int>();
+
+  templatedFunction<bool>();
+
+  templatedFunction<char>();
+
+  templatedFunction<void*>();
+}