[clang-format] Disallow decltype in the middle of constraints

[rymiel]

Summary

If a function with a requires clause as a constraint has a decltype
return type, such as decltype(auto), the decltype was seen to be part
of the constraint clause, rather than as part of the function
declaration, causing it to be placed on the wrong line.

This patch disallows decltype to be a part of these clauses

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

Depends on D140339

[HazardyKnusperkeks]

You have to do better: https://gcc.godbolt.org/z/7hEKx1dhv

[rymiel]

What if I make this depend on D140339? Then this change would no longer impact concept definitions.

[HazardyKnusperkeks]

In D140312#4006106, @rymiel wrote:

What if I make this depend on D140339? Then this change would no longer impact concept definitions.

Yep, that would be right. It seems I can't put decltype directly in a requires clause.

[HazardyKnusperkeks]

clang/lib/Format/UnwrappedLineParser.cpp

3477–3478

The comment needs to be adapted.

But I think it could just be merged into the parsing of the requires clause, or not?

3477–3478

Actually this needs to be done on D140339.

[rymiel]

clang/lib/Format/UnwrappedLineParser.cpp

3477–3478

You are right, thank you. D140339 will make it so parseConstraintExpression will only ever be called from parseRequiresClause. Should I do that refactor in D140339 or leave it for a future patch?

[HazardyKnusperkeks]

clang/lib/Format/UnwrappedLineParser.cpp

3477–3478

Either way.

clang/lib/Format/UnwrappedLineParser.cpp

void UnwrappedLineParser::parseRequiresExpression(FormatToken *RequiresToken) {
   if (FormatTok->is(tok::l_brace)) {
     FormatTok->setFinalizedType(TT_RequiresExpressionLBrace);
     parseChildBlock(/*CanContainBracedList=*/false,
                     /*NextLBracesType=*/TT_CompoundRequirementLBrace);
   }
 }
 
 /// \brief Parses a constraint expression.
 ///
 /// This is the body of a requires clause. It returns, when the parsing is
 /// complete, or the expression is incorrect.
 void UnwrappedLineParser::parseConstraintExpression() {
   // The special handling for lambdas is needed since tryToParseLambda() eats a
   // token and if a requires expression is the last part of a requires clause
   // and followed by an attribute like [[nodiscard]] the ClosesRequiresClause is
   // not set on the correct token. Thus we need to be aware if we even expect a
   // lambda to be possible.
   // template <typename T> requires requires { ... } [[nodiscard]] ...;
do {
     case tok::lessless:
     case tok::equalequal:
     case tok::exclaim:
     case tok::exclaimequal:
     case tok::plus:
     case tok::minus:
     case tok::star:
     case tok::slash:
-    case tok::kw_decltype:
       LambdaNextTimeAllowed = true;
       // Just eat them.
       nextToken();
       break;
 
     case tok::numeric_constant:
     case tok::coloncolon:
     case tok::kw_true:

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, RequiresClauses) {
   verifyFormat("struct [[nodiscard]] zero_t {\n"
                "  template <class T>\n"
                "    requires requires { number_zero_v<T>; }\n"
                "  [[nodiscard]] constexpr operator T() const {\n"
                "    return number_zero_v<T>;\n"
                "  }\n"
                "};");
 
+  verifyFormat("template <class T>\n"
+               "  requires(std::same_as<int, T>)\n"
+               "decltype(auto) fun() {}");
+
   auto Style = getLLVMStyle();
 
   verifyFormat(
       "template <typename T>\n"
       "  requires is_default_constructible_v<hash<T>> and\n"
       "           is_copy_constructible_v<hash<T>> and\n"
       "           is_move_constructible_v<hash<T>> and\n"
       "           is_copy_assignable_v<hash<T>> and "

clang/unittests/Format/TokenAnnotatorTest.cpp

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"
+                    "requires Bar<T>\n"
+                    "decltype(auto) foo(T) { return false; }");
+  ASSERT_EQ(Tokens.size(), 24u) << Tokens;
+  EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause);
+  EXPECT_TRUE(Tokens[9]->ClosesRequiresClause);
+  EXPECT_TOKEN(Tokens[14], 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"