[clang-format] Look ahead before consuming `bool` in requires clause.

[rymiel]

Summary

The comment handling the bool case says:
"bool is only allowed if it is directly followed by a paren for a cast"

This change more closely follows this directive by looking ahead for
the paren before consuming the bool keyword itself. Without a following
paren, the bool would be part of something else, such as a return type
for a function declaration

Fixes https://github.com/llvm/llvm-project/issues/57538

[zzyyyl]

What if concept c = (bool)(...) ?

or concept c = static_cast<bool>(...)

[MyDeveloperDay]

In D134325#3804817, @zzyyyl wrote:

What if concept c = (bool)(...) ?

or concept c = static_cast<bool>(...)

Aren't these handled elsewhere in the case (by the static_cast and l_paren rules)? but possibly worth a test either an annotation test or an actual formatting example.

[MyDeveloperDay]

given that #57538 manifested itself as a incorrect format (no doubt because of incorrect token annotation), should we add a verifyFormat tests somewhere for the example from the github issue, (it just protects the formatting for being broken by some other change)

[HazardyKnusperkeks]

Thanks for the fix.

In D134325#3804969, @MyDeveloperDay wrote:

given that #57538 manifested itself as a incorrect format (no doubt because of incorrect token annotation), should we add a verifyFormat tests somewhere for the example from the github issue, (it just protects the formatting for being broken by some other change)

Yeah we disagree here, but I have to redisagree.
It's the wrong annotation, it's not related to any formatting. And the format tests cpp is a monster.

[owenpan]

clang/lib/Format/UnwrappedLineParser.cpp

3534

Redundant as it's asserted at the start of parseParens() below?

[rymiel]

Remove redundant assert

thank you for pointing that out

clang/lib/Format/UnwrappedLineParser.cpp

case tok::kw_dynamic_cast:
                       /*ClosingBraceKind=*/tok::greater);
       break;
 
     case tok::kw_bool:
       // bool is only allowed if it is directly followed by a paren for a cast:
       // concept C = bool(...);
       // and bool is the only type, all other types as cast must be inside a
       // cast to bool an thus are handled by the other cases.
-      nextToken();
-      if (FormatTok->isNot(tok::l_paren))
+      if (Tokens->peekNextToken()->isNot(tok::l_paren))
         return;
+      nextToken();
+      assert(FormatTok->is(tok::l_paren));
       parseParens();
       break;
 
     default:
       if (!FormatTok->Tok.getIdentifierInfo()) {
         // Identifiers are part of the default case, we check for more then
         // tok::identifier to handle builtin type traits.
         return;

clang/unittests/Format/TokenAnnotatorTest.cpp

Tokens = annotate("template <typename T>\n"
                     "auto foo(T) -> int;");
   ASSERT_EQ(Tokens.size(), 24u) << Tokens;
   EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause);
   EXPECT_EQ(Tokens[11]->FakeLParens.size(), 0u);
   EXPECT_TRUE(Tokens[14]->ClosesRequiresClause);
   EXPECT_TOKEN(Tokens[20], tok::arrow, TT_TrailingReturnArrow);
 
   Tokens = annotate("template <typename T>\n"
+                    "requires Bar<T>\n"
+                    "bool foo(T) { return false; }");
+  ASSERT_EQ(Tokens.size(), 21u) << Tokens;
+  EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause);
+  EXPECT_TRUE(Tokens[9]->ClosesRequiresClause);
+  EXPECT_TOKEN(Tokens[11], tok::identifier, TT_FunctionDeclarationName);
+
+  Tokens = annotate("template <typename T>\n"
                     "struct S {\n"
                     "  void foo() const requires Bar<T>;\n"
                     "  void bar() const & requires Baz<T>;\n"
                     "  void bar() && requires Baz2<T>;\n"
                     "  void baz() const & noexcept requires Baz<T>;\n"
                     "  void baz() && noexcept requires Baz2<T>;\n"
                     "};\n"
                     "\n"