clang-format: Allow space after 'if' but not '@synchronized'.

[strager]

Summary

Add an option to SpaceBeforeParens,
ControlStatementsExceptObjC, which behaves as
ControlStatements in all cases except after '@synchronized'
(where it behaves as Never).

Depends on D10371.

[djasper]

Makes sense to me. Nico, what do you think?

[thakis]

As said on http://reviews.llvm.org/D10371#195408 : Does anyone ever want a space after @synchronized? Do we need an option for this? As far as I understand strager, he doesn't want a space there either and the current behavior is to not add a space between ObjC @words.

[djasper]

I don't know as I don't use ObjC and am not familiar with the style guides. However, if no one currently desires the space, I am strongly against introducing the option. Options have costs for a variety of reasons.

[strager]

I will remove the option (this diff) and change D10371.

docs/ClangFormatStyleOptions.rst

**SpaceBeforeParens** (``SpaceBeforeParensOptions``)
 
   Possible values:
 
   * ``SBPO_Never`` (in configuration: ``Never``)
     Never put a space before opening parentheses.
   * ``SBPO_ControlStatements`` (in configuration: ``ControlStatements``)
     Put a space before opening parentheses only after control statement
     keywords (``for/if/while...``).
+  * ``SBPO_ControlStatementsExceptObjC`` (in configuration: ``ControlStatementsExceptObjC``)
+    Put a space before opening parentheses only after control statement
+    keywords and excluding Objective-C control statement
+    keywords (``@synchronized``).
   * ``SBPO_Always`` (in configuration: ``Always``)
     Always put a space before opening parentheses, except when it's
     prohibited by the syntax rules (in function-like macro definitions) or
     when determined by other style rules (after unary operators, opening
     parentheses, etc.)
 
 
 **SpaceInEmptyParentheses** (``bool``)

include/clang/Format/Format.h

struct FormatStyle {
 
   /// \brief Different ways to put a space before opening parentheses.
   enum SpaceBeforeParensOptions {
     /// Never put a space before opening parentheses.
     SBPO_Never,
     /// Put a space before opening parentheses only after control statement
     /// keywords (<tt>for/if/while...</tt>).
     SBPO_ControlStatements,
+    /// Put a space before opening parentheses only after control statement
+    /// keywords and excluding Objective-C control statement
+    /// keywords (<tt>@synchronized</tt>).
+    SBPO_ControlStatementsExceptObjC,
     /// Always put a space before opening parentheses, except when it's
     /// prohibited by the syntax rules (in function-like macro definitions) or
     /// when determined by other style rules (after unary operators, opening
     /// parentheses, etc.)
     SBPO_Always
   };
 
   /// \brief Defines in which cases to put a space before opening parentheses.

lib/Format/Format.cpp

 
 template <>
 struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> {
   static void enumeration(IO &IO,
                           FormatStyle::SpaceBeforeParensOptions &Value) {
     IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
     IO.enumCase(Value, "ControlStatements",
                 FormatStyle::SBPO_ControlStatements);
+    IO.enumCase(Value, "ControlStatementsExceptObjC",
+                FormatStyle::SBPO_ControlStatementsExceptObjC);
     IO.enumCase(Value, "Always", FormatStyle::SBPO_Always);
 
     // For backward compatibility.
     IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
     IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
   }
 };
 

lib/Format/TokenAnnotator.cpp

if ((Left.is(tok::l_brace) && Left.BlockKind != BK_Block) ||
     return !Style.Cpp11BracedListStyle;
   if (Left.is(TT_BlockComment))
     return !Left.TokenText.endswith("=*/");
   if (Right.is(tok::l_paren)) {
     if (Left.is(tok::r_paren) && Left.is(TT_AttributeParen))
       return true;
     return Line.Type == LT_ObjCDecl || Left.is(tok::semi) ||
            (Style.SpaceBeforeParens != FormatStyle::SBPO_Never &&
+            !(Style.SpaceBeforeParens ==
+                  FormatStyle::SBPO_ControlStatementsExceptObjC &&
+              Left.is(tok::objc_synchronized)) &&
             (Left.isOneOf(tok::kw_if, tok::kw_for, tok::kw_while,
                           tok::kw_switch, tok::kw_case, tok::objc_synchronized,
                           TT_ForEachMacro) ||
              (Left.isOneOf(tok::kw_try, Keywords.kw___except, tok::kw_catch,
                            tok::kw_new, tok::kw_delete) &&
               (!Left.Previous || Left.Previous->isNot(tok::period))))) ||
            (Style.SpaceBeforeParens == FormatStyle::SBPO_Always &&
             (Left.is(tok::identifier) || Left.isFunctionLikeKeyword() ||

unittests/Format/FormatTest.cpp

verifyFormat("@synchronized (foo)\n"
                "{\n"
                "  f();\n"
                "}\n"
                "@synchronized (foo)\n"
                "{\n"
                "  f();\n"
                "}\n",
                Style);
+  Style.SpaceBeforeParens = FormatStyle::SBPO_ControlStatementsExceptObjC;
+  verifyFormat("@synchronized(foo)\n"
+               "{\n"
+               "}\n",
+               Style);
 }
 
 TEST_F(FormatTest, StaticInitializers) {
   verifyFormat("static SomeClass SC = {1, 'a'};");
 
   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
                "    100000000, "
                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
   verifyFormat("size_t x = sizeof(x);", NoSpace);
   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
   verifyFormat("alignas(128) char a[128];", NoSpace);
   verifyFormat("size_t x = alignof(MyType);", NoSpace);
   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
   verifyFormat("int f() throw(Deprecated);", NoSpace);
   verifyFormat("typedef void (*cb)(int);", NoSpace);
+  verifyFormat("@synchronized(mutex) {\n"
+               "}",
+               NoSpace);
 
   FormatStyle Space = getLLVMStyle();
   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
 
   verifyFormat("int f ();", Space);
   verifyFormat("void f (int a, T b) {\n"
                "  while (true)\n"
                "    continue;\n"
TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
   verifyFormat("size_t x = sizeof (x);", Space);
   verifyFormat("auto f (int x) -> decltype (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);
+  verifyFormat("@synchronized (mutex) {\n"
+               "}",
+               Space);
+
+  FormatStyle ControlSpace = getLLVMStyle();
+  ControlSpace.SpaceBeforeParens =
+      FormatStyle::SBPO_ControlStatementsExceptObjC;
+
+  verifyFormat("int f();", ControlSpace);
+  verifyFormat("void f(int a, T b) {\n"
+               "  while (true)\n"
+               "    continue;\n"
+               "}",
+               ControlSpace);
+  verifyFormat("if (true)\n"
+               "  f();\n"
+               "else if (true)\n"
+               "  f();",
+               ControlSpace);
+  verifyFormat("do {\n"
+               "  do_something();\n"
+               "} while (something());",
+               ControlSpace);
+  verifyFormat("switch (x) {\n"
+               "default:\n"
+               "  break;\n"
+               "}",
+               ControlSpace);
+  verifyFormat("A::A() : a(1) {}", ControlSpace);
+  verifyFormat("void f() __attribute__((asdf));", ControlSpace);
+  verifyFormat("*(&a + 1);\n"
+               "&((&a)[1]);\n"
+               "a[(b + c) * d];\n"
+               "(((a + 1) * 2) + 3) * 4;",
+               ControlSpace);
+  verifyFormat("#define A(x) x", ControlSpace);
+  verifyFormat("#define A (x) x", ControlSpace);
+  verifyFormat("#if defined(x)\n"
+               "#endif",
+               ControlSpace);
+  verifyFormat("auto i = std::make_unique<int>(5);", ControlSpace);
+  verifyFormat("size_t x = sizeof(x);", ControlSpace);
+  verifyFormat("auto f(int x) -> decltype(x);", ControlSpace);
+  verifyFormat("int f(T x) noexcept(x.create());", ControlSpace);
+  verifyFormat("alignas(128) char a[128];", ControlSpace);
+  verifyFormat("size_t x = alignof(MyType);", ControlSpace);
+  verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");",
+               ControlSpace);
+  verifyFormat("int f() throw(Deprecated);", ControlSpace);
+  verifyFormat("typedef void (*cb)(int);", ControlSpace);
+  verifyFormat("@synchronized(mutex) {\n"
+               "}",
+               ControlSpace);
 }
 
 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
   FormatStyle Spaces = getLLVMStyle();
 
   Spaces.SpacesInParentheses = true;
   verifyFormat("call( x, y, z );", Spaces);
   verifyFormat("call();", Spaces);
TEST_F(FormatTest, ParsesConfiguration) {
 
   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
               FormatStyle::SBPO_Never);
   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
               FormatStyle::SBPO_Always);
   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
               FormatStyle::SBPO_ControlStatements);
+  CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptObjC",
+              SpaceBeforeParens, FormatStyle::SBPO_ControlStatementsExceptObjC);
   // For backward compatibility:
   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
               FormatStyle::SBPO_Never);
   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
               FormatStyle::SBPO_ControlStatements);
 
   Style.ColumnLimit = 123;
   FormatStyle BaseStyle = getLLVMStyle();