[clang-format] [PR52595] clang-format does not recognize rvalue references to array

[MyDeveloperDay]

Summary

https://bugs.llvm.org/show_bug.cgi?id=52595

missing space between T(&&) but not between T (& due to && being incorrectly thought of as UnaryOperator rather than PointerOrReference

int operator()(T (&)[N]) { return 0; }
int operator()(T(&&)[N]) { return 1; }

Existing Unit tests are changed because actually I think they are originally incorrect, and are inconsistent with the (&) cases that are 4 or 5 lines above them.

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

21891

this test should be consistent with

verifyFormat("operator&(int (&)(), class Foo);", Style);

[curdeius]

clang/unittests/Format/FormatTest.cpp

9678

Nit: these are not &/&& operators but references so the test name seems incorrect.

21891

Should we test

verifyFormat("operator&&(int (&)(), class Foo);", Style);

here, and

verifyFormat("operator&(int (&&)(), class Foo);", Style);

above as well?

21954

Ditto for combinations of &+(&&) and &&+(&).

21995

Ditto.

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

9678

oh yes sorry that was my bad so I could just run this one test through the debugger, I just needed a unique name, I should change that.

21891

yes I'll add those, nice suggestion

[MyDeveloperDay]

Add more test combinations

[curdeius]

LGTM.

[lichray]

clang/lib/Format/TokenAnnotator.cpp

317

Code does not match comment.

clang/lib/Format/TokenAnnotator.cpp

bool parseParens(bool LookForDecls = false) {
     }
 
     // MightBeFunctionType and ProbablyFunctionType are used for
     // function pointer and reference types as well as Objective-C
     // block types:
     //
     // void (*FunctionPointer)(void);
     // void (&FunctionReference)(void);
     // void (^ObjCBlock)(void);
     bool MightBeFunctionType = !Contexts[Contexts.size() - 2].IsExpression;
     bool ProbablyFunctionType =
-        CurrentToken->isOneOf(tok::star, tok::amp, tok::caret);
+        CurrentToken->isOneOf(tok::star, tok::amp, tok::ampamp, tok::caret);
     bool HasMultipleLines = false;
     bool HasMultipleParametersOnALine = false;
     bool MightBeObjCForRangeLoop =
         Left->Previous && Left->Previous->is(tok::kw_for);
     FormatToken *PossibleObjCForInToken = nullptr;
     while (CurrentToken) {
       // LookForDecls is set when "if (" has been seen. Check for
       // 'identifier' '*' 'identifier' followed by not '=' -- this

clang/unittests/Format/FormatTest.cpp

verifyGoogleFormat("template <typename T>\n"
                      "auto x() & -> int {}");
 
   // Should be binary operators when used as an argument expression (overloaded
   // operator invoked as a member function).
   verifyFormat("void f() { a.operator()(a * a); }");
   verifyFormat("void f() { a->operator()(a & a); }");
   verifyFormat("void f() { a.operator()(*a & *a); }");
   verifyFormat("void f() { a->operator()(*a * *a); }");
+
+  verifyFormat("int operator()(T (&&)[N]) { return 1; }");
+  verifyFormat("int operator()(T (&)[N]) { return 0; }");
 }
 
 TEST_F(FormatTest, UnderstandsAttributes) {
   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
   FormatStyle AfterType = getLLVMStyle();
   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
   verifyFormat("__attribute__((nodebug)) void\n"
                "foo() {}\n",
                AfterType);
TEST_F(FormatTest, OperatorSpacing) {
 
   verifyFormat("Foo::operator&();", Style);
   verifyFormat("Foo::operator void &();", Style);
   verifyFormat("Foo::operator void const &();", Style);
   verifyFormat("Foo::operator()(void &);", Style);
   verifyFormat("Foo::operator&(void &);", Style);
   verifyFormat("Foo::operator&();", Style);
   verifyFormat("operator&(int (&)(), class Foo);", Style);
+  verifyFormat("operator&&(int (&)(), class Foo);", Style);
 
   verifyFormat("Foo::operator&&();", Style);
   verifyFormat("Foo::operator**();", Style);
   verifyFormat("Foo::operator void &&();", Style);
   verifyFormat("Foo::operator void const &&();", Style);
   verifyFormat("Foo::operator()(void &&);", Style);
   verifyFormat("Foo::operator&&(void &&);", Style);
   verifyFormat("Foo::operator&&();", Style);
-  verifyFormat("operator&&(int(&&)(), class Foo);", Style);
+  verifyFormat("operator&&(int (&&)(), class Foo);", Style);
   verifyFormat("operator const nsTArrayRight<E> &()", Style);
   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
                Style);
   verifyFormat("operator void **()", Style);
   verifyFormat("operator const FooRight<Object> &()", Style);
   verifyFormat("operator const FooRight<Object> *()", Style);
   verifyFormat("operator const FooRight<Object> **()", Style);
   verifyFormat("operator const FooRight<Object> *&()", Style);
TEST_F(FormatTest, OperatorSpacing) {
   verifyFormat("Foo::operator void const&();", Style);
   verifyFormat("Foo::operator/*comment*/ void&();", Style);
   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
   verifyFormat("Foo::operator()(void&);", Style);
   verifyFormat("Foo::operator&(void&);", Style);
   verifyFormat("Foo::operator&();", Style);
   verifyFormat("operator&(int (&)(), class Foo);", Style);
+  verifyFormat("operator&(int (&&)(), class Foo);", Style);
+  verifyFormat("operator&&(int (&&)(), class Foo);", Style);
 
   verifyFormat("Foo::operator&&();", Style);
   verifyFormat("Foo::operator void&&();", Style);
   verifyFormat("Foo::operator void const&&();", Style);
   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
   verifyFormat("Foo::operator()(void&&);", Style);
   verifyFormat("Foo::operator&&(void&&);", Style);
   verifyFormat("Foo::operator&&();", Style);
-  verifyFormat("operator&&(int(&&)(), class Foo);", Style);
+  verifyFormat("operator&&(int (&&)(), class Foo);", Style);
   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
                Style);
   verifyFormat("operator void**()", Style);
   verifyFormat("operator const FooLeft<Object>&()", Style);
   verifyFormat("operator const FooLeft<Object>*()", Style);
   verifyFormat("operator const FooLeft<Object>**()", Style);
   verifyFormat("operator const FooLeft<Object>*&()", Style);
TEST_F(FormatTest, OperatorSpacing) {
   verifyFormat("operator&(int (&)(), class Foo);", Style);
 
   verifyFormat("Foo::operator&&();", Style);
   verifyFormat("Foo::operator void &&();", Style);
   verifyFormat("Foo::operator void const &&();", Style);
   verifyFormat("Foo::operator()(void &&);", Style);
   verifyFormat("Foo::operator&&(void &&);", Style);
   verifyFormat("Foo::operator&&();", Style);
-  verifyFormat("operator&&(int(&&)(), class Foo);", Style);
+  verifyFormat("operator&&(int (&&)(), class Foo);", Style);
 }
 
 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
   FormatStyle Style = getLLVMStyle();
   // PR46157
   verifyFormat("foo(operator+, -42);", Style);
   verifyFormat("foo(operator++, -42);", Style);
   verifyFormat("foo(operator--, -42);", Style);