[clang-format] Remove special case for kw_operator when aligning decls

[rymiel]

Summary

This change breaks no existing tests but does fix the linked issue.
Declarations of operator overloads are annotated with
TT_FunctionDeclarationName on the operator keyword, which is already
being checked for when aligning, so the extra kw_operator doesn't seem
to be necessary. (just for reference, it was added in
rG92b397fb9d55ccdf4632c2b1b15b4a0ee417cf74 / 92b397fb9d55ccdf4632c2b1b15b4a0ee417cf74)

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

[owenpan]

clang/unittests/Format/FormatTest.cpp

17939

Add a full stop.

17939–17946

Consider using a test case similar to the examples in https://github.com/llvm/llvm-project/issues/55733 or not adding a test case at all as the added annotator tests will cover it.

17945

Remove the newline.

clang/unittests/Format/TokenAnnotatorTest.cpp

441–456

Instead of adding new tests, you can add checks for kw_operator and TT_FunctionDeclarationName to the existing ones.

[HazardyKnusperkeks]

What Owen says.
Apart from that looks good.

[rymiel]

clang/unittests/Format/TokenAnnotatorTest.cpp

441–456

I wanted to have tests that are declaring operator functions, not just calling them

[rymiel]

Remove format test, relying only on annotator tests

[owenpan]

LGTM

clang/lib/Format/WhitespaceManager.cpp

 
 void WhitespaceManager::alignConsecutiveDeclarations() {
   if (!Style.AlignConsecutiveDeclarations.Enabled)
     return;
 
   AlignTokens(
       Style,
       [](Change const &C) {
-        // tok::kw_operator is necessary for aligning operator overload
-        // definitions.
-        if (C.Tok->isOneOf(TT_FunctionDeclarationName, tok::kw_operator))
+        if (C.Tok->is(TT_FunctionDeclarationName))
           return true;
         if (C.Tok->isNot(TT_StartOfName))
           return false;
         if (C.Tok->Previous &&
             C.Tok->Previous->is(TT_StatementAttributeLikeMacro))
           return false;
         // Check if there is a subsequent name that starts the same declaration.
         for (FormatToken *Next = C.Tok->Next; Next; Next = Next->Next) {

clang/unittests/Format/FormatTest.cpp

verifyFormat("struct test {\n"
                "};\n",
                Alignment);
   verifyFormat("struct test {\n"
                "  long long int foo();\n"
                "  int           operator()(int a);\n"
                "  double        bar();\n"
                "};\n",
                Alignment);
+  // Ensure operators are not aligned if they're being called, not declared
+  verifyFormat("int main() {\n"
+               "  int    operator()(int a);\n"
+               "  double operator+(double a);\n"
+               "  operator()(1);\n"
+               "  operator+(1.0);\n"
+               "};\n",
+               Alignment);
   // http://llvm.org/PR52914
   verifyFormat("char *a[]     = {\"a\", // comment\n"
                "                 \"bb\"};\n"
                "int   bbbbbbb = 0;",
                Alignment);
 
   // PAS_Right
   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"

clang/unittests/Format/TokenAnnotatorTest.cpp

TEST_F(TokenAnnotatorTest, UnderstandsOverloadedOperators) {
   Tokens = annotate("x.operator\"\"s()");
   ASSERT_EQ(Tokens.size(), 7u) << Tokens;
   EXPECT_TOKEN(Tokens[3], tok::string_literal, TT_OverloadedOperator);
   EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen);
   Tokens = annotate("x.operator\"\" s()");
   ASSERT_EQ(Tokens.size(), 8u) << Tokens;
   EXPECT_TOKEN(Tokens[3], tok::string_literal, TT_OverloadedOperator);
   EXPECT_TOKEN(Tokens[5], tok::l_paren, TT_OverloadedOperatorLParen);
+
+  Tokens = annotate("int operator+(int);");
+  ASSERT_EQ(Tokens.size(), 8u) << Tokens;
+  EXPECT_TOKEN(Tokens[1], tok::kw_operator, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[2], tok::plus, TT_OverloadedOperator);
+  EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_OverloadedOperatorLParen);
+  Tokens = annotate("auto operator=(T&) {}");
+  ASSERT_EQ(Tokens.size(), 10u) << Tokens;
+  EXPECT_TOKEN(Tokens[1], tok::kw_operator, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[2], tok::equal, TT_OverloadedOperator);
+  EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_OverloadedOperatorLParen);
+  Tokens = annotate("auto operator()() {}");
+  ASSERT_EQ(Tokens.size(), 9u) << Tokens;
+  EXPECT_TOKEN(Tokens[1], tok::kw_operator, TT_FunctionDeclarationName);
+  EXPECT_TOKEN(Tokens[2], tok::l_paren, TT_OverloadedOperator);
+  EXPECT_TOKEN(Tokens[3], tok::r_paren, TT_OverloadedOperator);
+  EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen);
 }
 
 TEST_F(TokenAnnotatorTest, UnderstandsRequiresClausesAndConcepts) {
   auto Tokens = annotate("template <typename T>\n"
                          "concept C = (Foo && Bar) && (Bar && Baz);");
 
   ASSERT_EQ(Tokens.size(), 21u) << Tokens;
   EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator);