fix(braces): exempt C++20 templated lambdas from trailing-semicolon check - #458

Reviewed at c6a64d4 against current develop.

The same-line / simple multi-line-body cases are fixed, including the exact #385 example, and a templated function still warns. Full suite: 206 passed.

The \\s*<.*>\\s*$ check only looks at the text before ( on that line, so these valid forms still emit readability/braces here (clean on #454):

auto identity = []<
    typename T
>(T&& t) { return t; };

auto identity = []
<typename T>
(T&& t) { return t; };

auto identity = []<typename T>
(T&& t) { return t; };

auto identity = []<typename T>
    requires std::integral<T>
(T&& t) { return t; };

Each compiles under g++ -std=c++20 -pedantic-errors -fsyntax-only. Given the overlap/conflict with #454, I’d lean toward closing this in favor of that PR unless you extend coverage to the multiline/requires cases.

I independently rechecked c6a64d4 and confirmed that the multiline template and requires-clause cases already reported in the existing review still emit readability/braces on this head, while #454 handles the same inputs and preserves diagnostics for multiline operator[] declarations and constrained functions. Since the two PRs overlap and conflict, I don't think this narrower implementation should merge as-is. Unless this branch is broadened beyond #454, I recommend closing it in favor of #454.

Rechecked current head c6a64d4.

This fixes the simple same-line #385 form but still misses equivalent valid multiline template-parameter and requires-clause forms, while #454 covers those cases and preserves the real trailing-semicolon diagnostics.

Since the two PRs overlap and conflict, I would not merge this narrower implementation as-is. I recommend closing it in favor of #454 unless this branch is broadened beyond that coverage.

Reviewed current head c6a64d4.

The same-line #385 case is fixed, but the current \]\s*<.*>\s*$ exemption still depends on the lambda capture/template list being visible in the text immediately before (. I reproduced the existing multiline failures and also found a nested requires-expression case that remains a false positive:

auto identity = []<typename T>
    requires requires(T t) {
      t.foo();
    }
(T t) {
  return t;
};

This still reports readability/braces on the final };.

I think the robust fix is to avoid extending the regex and instead locate the lambda introducer with the existing balanced-expression machinery: use ReverseCloseExpression() to walk from the parameter list back through an optional <...> template list and requires-clause, skipping balanced nested regions such as the {...} inside a requires-expression, then confirm the preceding ] capture while preserving the operator[] guard.

I tested that direction locally against multiline template lists, split capture/template lines, requires-clauses, multiline constraints, and the nested requires-expression above, plus negative controls for ordinary functions, templated/constrained functions, and multiline operator[].

Local validation on the candidate: full suite 231 passed; pylint, mypy, pre-commit, and git diff --check all passed.

I couldn't independently compile the C++ examples because this environment has no working C++ compiler (cc1plus is unavailable).