[clang-tidy] Add check to flag use of early `return` or `continue` (readability-guard-clause)

[vbvictor]

Code like this:

void foo() {
  // some processing

  if (cond) {
    // a lot of code
  }
}

can be transformed to:

void foo() {
  // some processing

  if (!cond) 
    return

  // a lot of code
}

And code like this:

while (...) {
  if (cond) {
    // a lot of code
  }
}

can be transformed to:

while (...) { // could be 'for' too
  if (!cond)
    continue
  // a lot of code
}

[llvmbot]

@llvm/issue-subscribers-clang-tidy

Author: Baranov Victor (vbvictor)

Code like this: ```cpp void foo() { // some processing

if (cond) {
// a lot of code
}
}

can be transformed to:
```cpp
void foo() {
  // some processing

  if (cond) 
    return

  // a lot of code
}

And code like this:

while (...) {
  if (cond) {
    // a lot of code
  }
}

can be transformed to:

while (...) { // could be 'for' too
  if (!cond)
    continue
  // a lot of code
}

[firewave]

I also recall a "place smaller scope first" rule for if (x) {} else {}. But I do not know if it was some guideline or a linter tool. It was probably the latter since I also remember a "flip" action in the IDE.

[LegalizeAdulthood]

Generally this is known as introducing a guard clause.

[vbvictor]

I also recall a "place smaller scope first" rule for if (x) {} else {}. But I do not know if it was some guideline or a linter tool. It was probably the latter since I also remember a "flip" action in the IDE.

Yes, I've heard about this rule, but I'm not sure if it would be a good clang-tidy check. One day first scope is smaller, then it becomes bigger, and we need to flip conditions...
It seems very non-deterministic.

[vbvictor]

Generally this is known as introducing a guard clause.

Thanks for telling the name of this construct, never thought of that! We can name the check readability-guard-clause.

[firewave]

The first suggested transformation lacks the "not".q

Yes, I've heard about this rule, but I'm not sure if it would be a good clang-tidy check. One day first scope is smaller, then it becomes bigger, and we need to flip conditions...
It seems very non-deterministic.

That applies to other checks as well e.g. readability-simplify-boolean-expr for the last entry in a logic chain. You could also argue it with the proposed check because there might be an else introduced in the future.

If you flip the scopes and the else contains a control-flow like continue that would trigger readability-else-after-return and you could drop a whole scope i.e. indentation. And that could in turn trigger the check suggested in this ticket.

But I mainly mentioned it because I thought they might be related and existing resources might provide some more inspiration/context.