[clang-format] add back tests which didn't cause a regression

[MyDeveloperDay]

Summary

bring back the valid tests removed as part of D114696: [clang-format] regressed default behavior for operator parentheses

[MyDeveloperDay]

bring back another 2 verifyFormats

[crayroud]

clang/unittests/Format/FormatTest.cpp

14124–14125

Remove the comment too.

14276

What do you think of enabling this test and to remove the space before the opening parenthesis ? As it is now the expected behaviour to have no space.

14351

As the the condition is to add a space before non empty parentheses, the test is valid.

[MyDeveloperDay]

Address review comments

[MyDeveloperDay]

Remove unrelated file

[crayroud]

clang/unittests/Format/FormatTest.cpp

14276

In https://reviews.llvm.org/D114696, you proposed to add an operator overloading option to SpaceBeforeParensOptions. This example: "T A::operator() () {}" should be configured from AfterFunctionDefinitionName or operator overloading ?

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

14276

in this circumstance can you explain why you want to treat differently? I can't tell what you intended here was it by design or as a consequence?

verifyFormat("T A::operator()();", SpaceFuncDef);
verifyFormat("T A::operator() () {}", SpaceFuncDef);

[MyDeveloperDay]

Its really this case that caused me issues, the behaviour for the foo {} cases was different from the ::operator cases. My feeling is that one is being detected as a function the other not.

verifyFormat("::operator delete(foo);");
verifyFormat("::operator new(n * sizeof(foo));");
verifyFormat("foo() { ::operator delete(foo); }");
verifyFormat("foo() { ::operator new(n * sizeof(foo)); }");

[crayroud]

clang/unittests/Format/FormatTest.cpp

14276

During the refactoring I treated operator overloading as a function definition. Is it correct or not ?

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
   verifyFormat("auto f (int x) -> typeof (x);", Space);
   verifyFormat("auto f (int x) -> _Atomic (x);", Space);
   verifyFormat("auto f (int x) -> __underlying_type (x);", Space);
   verifyFormat("int f (T x) noexcept (x.create ());", Space);
   verifyFormat("alignas (128) char a[128];", Space);
   verifyFormat("size_t x = alignof (MyType);", Space);
   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
   verifyFormat("int f () throw (Deprecated);", Space);
   verifyFormat("typedef void (*cb) (int);", Space);
-  // FIXME these tests regressed behaviour.
-  // verifyFormat("T A::operator() ();", Space);
-  // verifyFormat("X A::operator++ (T);", Space);
+  verifyFormat("T A::operator() ();", Space);
+  verifyFormat("X A::operator++ (T);", Space);
   verifyFormat("auto lambda = [] () { return 0; };", Space);
   verifyFormat("int x = int (y);", Space);
 
   FormatStyle SomeSpace = getLLVMStyle();
   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
 
   verifyFormat("[]() -> float {}", SomeSpace);
   verifyFormat("[] (auto foo) {}", SomeSpace);
TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
   verifyFormat("alignas (128) char a[128];", SomeSpace);
   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
                SomeSpace);
   verifyFormat("int f() throw (Deprecated);", SomeSpace);
   verifyFormat("typedef void (*cb) (int);", SomeSpace);
   verifyFormat("T A::operator()();", SomeSpace);
-  // FIXME these tests regressed behaviour.
-  // verifyFormat("X A::operator++ (T);", SomeSpace);
+  verifyFormat("X A::operator++ (T);", SomeSpace);
   verifyFormat("int x = int (y);", SomeSpace);
   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
 
   FormatStyle SpaceControlStatements = getLLVMStyle();
   SpaceControlStatements.SpaceBeforeParens = FormatStyle::SBPO_Custom;
   SpaceControlStatements.SpaceBeforeParensOptions.AfterControlStatements = true;
 
   verifyFormat("while (true)\n"
TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
   verifyFormat("alignas(128) char a[128];", SpaceFuncDef);
   verifyFormat("size_t x = alignof(MyType);", SpaceFuncDef);
   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");",
                SpaceFuncDef);
   verifyFormat("int f() throw(Deprecated);", SpaceFuncDef);
   verifyFormat("typedef void (*cb)(int);", SpaceFuncDef);
   verifyFormat("T A::operator()();", SpaceFuncDef);
   verifyFormat("X A::operator++(T);", SpaceFuncDef);
+  // FIXME these tests regressed behaviour.
   // verifyFormat("T A::operator() () {}", SpaceFuncDef);
   verifyFormat("auto lambda = [] () { return 0; };", SpaceFuncDef);
   verifyFormat("int x = int(y);", SpaceFuncDef);
   verifyFormat("M(std::size_t R, std::size_t C) : C(C), data(R) {}",
                SpaceFuncDef);
 
   FormatStyle SpaceIfMacros = getLLVMStyle();
   SpaceIfMacros.IfMacros.clear();
   SpaceIfMacros.IfMacros.push_back("MYIF");
TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace2);
   verifyFormat("alignas (128) char a[128];", SomeSpace2);
   verifyFormat("size_t x = alignof (MyType);", SomeSpace2);
   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
                SomeSpace2);
   verifyFormat("int f() throw (Deprecated);", SomeSpace2);
   verifyFormat("typedef void (*cb) (int);", SomeSpace2);
   verifyFormat("T A::operator()();", SomeSpace2);
-  // verifyFormat("X A::operator++ (T);", SomeSpace2);
+  verifyFormat("X A::operator++ (T);", SomeSpace2);
   verifyFormat("int x = int (y);", SomeSpace2);
   verifyFormat("auto lambda = []() { return 0; };", SomeSpace2);
 }
 
 TEST_F(FormatTest, SpaceAfterLogicalNot) {
   FormatStyle Spaces = getLLVMStyle();
   Spaces.SpaceAfterLogicalNot = true;