[clang-format] Treat &/&& as reference when followed by requires clause

[rymiel]

Summary

Previously, the token annotator would get confused and annotate a member
function's ref qualifier as a binary operator, if said function also had
a requires clause after it.

This patch accounts for that, treating requires clauses more similarly
to noexcept, which also comes after the ref qualifier.

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

clang/lib/Format/TokenAnnotator.cpp

TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
 
     const FormatToken *NextToken = Tok.getNextNonComment();
 
     if (InTemplateArgument && NextToken && NextToken->is(tok::kw_noexcept))
       return TT_BinaryOperator;
 
     if (!NextToken ||
         NextToken->isOneOf(tok::arrow, tok::equal, tok::kw_noexcept, tok::comma,
-                           tok::r_paren) ||
+                           tok::r_paren, TT_RequiresClause) ||
         NextToken->canBePointerOrReferenceQualifier() ||
         (NextToken->is(tok::l_brace) && !NextToken->getNextNonComment())) {
       return TT_PointerOrReference;
     }
 
     if (PrevToken->is(tok::coloncolon))
       return TT_PointerOrReference;
 
if (Left.is(TT_PointerOrReference)) {
     }
     // & 1
     if (Right.Tok.isLiteral())
       return true;
     // & /* comment
     if (Right.is(TT_BlockComment))
       return true;
     // foo() -> const Bar * override/final
-    if (Right.isOneOf(Keywords.kw_override, Keywords.kw_final,
-                      tok::kw_noexcept) &&
+    // S::foo() & noexcept/requires
+    if (Right.isOneOf(Keywords.kw_override, Keywords.kw_final, tok::kw_noexcept,
+                      TT_RequiresClause) &&
         !Right.is(TT_StartOfName)) {
       return true;
     }
     // & {
     if (Right.is(tok::l_brace) && Right.is(BK_Block))
       return true;
     // for (auto a = 0, b = 0; const auto& c : {1, 2, 3})
     if (Left.Previous && Left.Previous->isTypeOrIdentifier() && Right.Next &&

clang/unittests/Format/FormatTest.cpp

verifyFormat("template <typename T>\n"
                "int bar(T t)\n"
                "  requires F<T>\n"
                "{\n"
                "  return 5;\n"
                "}",
                Style);
 
   verifyFormat("template <typename T>\n"
+               "int S::bar(T t) &&\n"
+               "  requires F<T>\n"
+               "{\n"
+               "  return 5;\n"
+               "}",
+               Style);
+
+  verifyFormat("template <typename T>\n"
                "int bar(T t)\n"
                "  requires F<T>;",
                Style);
 
   Style.IndentRequiresClause = false;
   verifyFormat("template <typename T>\n"
                "requires F<T>\n"
                "int bar(T t) {\n"
                "  return 5;\n"
                "}",
                Style);
 
   verifyFormat("template <typename T>\n"
+               "int S::bar(T t) &&\n"
+               "requires F<T>\n"
+               "{\n"
+               "  return 5;\n"
+               "}",
+               Style);
+
+  verifyFormat("template <typename T>\n"
                "int bar(T t)\n"
                "requires F<T>\n"
                "{\n"
                "  return 5;\n"
                "}",
                Style);
 
   Style.RequiresClausePosition = FormatStyle::RCPS_SingleLine;
   verifyFormat("template <typename T> requires Foo<T> struct Bar {};\n"
                "template <typename T> requires Foo<T> void bar() {}\n"
                "template <typename T> void bar() requires Foo<T> {}\n"
                "template <typename T> void bar() requires Foo<T>;\n"
+               "template <typename T> void S::bar() && requires Foo<T> {}\n"
                "template <typename T> requires Foo<T> Bar(T) -> Bar<T>;",
                Style);
 
   auto ColumnStyle = Style;
   ColumnStyle.ColumnLimit = 40;
   verifyFormat("template <typename AAAAAAA>\n"
                "requires Foo<T> struct Bar {};\n"
                "template <typename AAAAAAA>\n"
                "requires Foo<T> void bar() {}\n"
                "template <typename AAAAAAA>\n"
                "void bar() requires Foo<T> {}\n"
+               "template <typename T>\n"
+               "void S::bar() && requires Foo<T> {}\n"
                "template <typename AAAAAAA>\n"
                "requires Foo<T> Baz(T) -> Baz<T>;",
                ColumnStyle);
 
   verifyFormat("template <typename T>\n"
                "requires Foo<AAAAAAA> struct Bar {};\n"
                "template <typename T>\n"
                "requires Foo<AAAAAAA> void bar() {}\n"
verifyFormat("template <typename T>\n"
                "requires Foo<T> void bar() {}\n"
                "template <typename T>\n"
                "void bar()\n"
                "requires Foo<T> {}\n"
                "template <typename T>\n"
                "void bar()\n"
                "requires Foo<T>;\n"
                "template <typename T>\n"
+               "void S::bar() &&\n"
+               "requires Foo<T> {}\n"
+               "template <typename T>\n"
                "requires Foo<T> Bar(T) -> Bar<T>;",
                Style);
 
   verifyFormat("template <typename AAAAAAA>\n"
                "requires Foo<AAAAAAAAAAAAAAAA>\n"
                "struct Bar {};\n"
                "template <typename AAAAAAA>\n"
                "requires Foo<AAAAAAAAAAAAAAAA>\n"
TEST_F(FormatTest, RequiresClausesPositions) {
   verifyFormat("template <typename T>\n"
                "  requires Foo<T> struct Bar {};\n"
                "template <typename T>\n"
                "  requires Foo<T> void bar() {}\n"
                "template <typename T>\n"
                "void bar()\n"
                "  requires Foo<T> {}\n"
                "template <typename T>\n"
+               "void S::bar() &&\n"
+               "  requires Foo<T> {}\n"
+               "template <typename T>\n"
                "  requires Foo<T> Bar(T) -> Bar<T>;",
                Style);
 
   verifyFormat("template <typename AAAAAAA>\n"
                "  requires Foo<AAAAAAAAAAAAAAAA>\n"
                "struct Bar {};\n"
                "template <typename AAAAAAA>\n"
                "  requires Foo<AAAAAAAAAAAAAAAA>\n"
TEST_F(FormatTest, RequiresClausesPositions) {
   verifyFormat("template <typename T> requires Foo<T>\n"
                "struct Bar {};\n"
                "template <typename T> requires Foo<T>\n"
                "void bar() {}\n"
                "template <typename T>\n"
                "void bar() requires Foo<T>\n"
                "{}\n"
                "template <typename T> void bar() requires Foo<T>;\n"
+               "template <typename T>\n"
+               "void S::bar() && requires Foo<T>\n"
+               "{}\n"
                "template <typename T> requires Foo<T>\n"
                "Bar(T) -> Bar<T>;",
                Style);
 
   verifyFormat("template <typename AAAAAAA>\n"
                "requires Foo<AAAAAAAAAAAAAAAA>\n"
                "struct Bar {};\n"
                "template <typename AAAAAAA>\n"

clang/unittests/Format/TokenAnnotatorTest.cpp

Tokens = annotate("template <typename 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"
                     "void S::bar() const & requires Baz<T> { }");
   ASSERT_EQ(Tokens.size(), 85u) << Tokens;
   EXPECT_TOKEN(Tokens[13], tok::kw_requires, TT_RequiresClause);
+  EXPECT_TOKEN(Tokens[24], tok::amp, TT_PointerOrReference);
   EXPECT_TOKEN(Tokens[25], tok::kw_requires, TT_RequiresClause);
+  EXPECT_TOKEN(Tokens[35], tok::ampamp, TT_PointerOrReference);
   EXPECT_TOKEN(Tokens[36], tok::kw_requires, TT_RequiresClause);
+  EXPECT_TOKEN(Tokens[47], tok::amp, TT_PointerOrReference);
   EXPECT_TOKEN(Tokens[49], tok::kw_requires, TT_RequiresClause);
+  EXPECT_TOKEN(Tokens[59], tok::ampamp, TT_PointerOrReference);
   EXPECT_TOKEN(Tokens[61], tok::kw_requires, TT_RequiresClause);
+  EXPECT_TOKEN(Tokens[76], tok::amp, TT_PointerOrReference);
   EXPECT_TOKEN(Tokens[77], tok::kw_requires, TT_RequiresClause);
 
   Tokens = annotate("void Class::member() && requires(Constant) {}");
   ASSERT_EQ(Tokens.size(), 14u) << Tokens;
   EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause);
 
   Tokens = annotate("void Class::member() && requires(Constant<T>) {}");
   ASSERT_EQ(Tokens.size(), 17u) << Tokens;