[clang-format] Support function and overloaded operator SpacesInParensOption

[gedare]

Summary

This change separates function calls, declarations, definitions, and
overloaded operators from SpacesInParensOptions.Other to allow control
over each independently.

Fixes Github Issue #55428. https://github.com/llvm/llvm-project/issues/55428

Depends on D155529

[HazardyKnusperkeks]

You need some tests to show that the new options really apply like intended.

[gedare]

Add tests and correct function call detection.

[HazardyKnusperkeks]

clang/unittests/Format/FormatTest.cpp

16714–16715

Why change this?

16833

Should here be a space?

[gedare]

clang/unittests/Format/FormatTest.cpp

16714–16715

The original test is incomplete/ambiguous. It's either a declaration missing a semicolon, or it's the start of a definition. I made it a definition.

16833

That's controlled by space in empty parens.

[gedare]

Rebase to D155529.

[gedare]

ping

[owenpan]

clang/lib/Format/TokenAnnotator.cpp

3969–4010

Consider wrapping this in a function or lambda. Not sure if it would simply the logic with the parens being handled separately:

if (Left.is(tok::l_paren)) {
  ...
} else if (Right.is(tok::r_paren)) {
  ...
}

3988

No else after return.

clang/unittests/Format/FormatTest.cpp

16714–16715

Then can you also add a declaration?

[gedare]

Fix for review comments, refactor logic to lambdas

[gedare]

add missing test case for function prototype

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: c++
        true:                                false:
        void f( ) {                    vs.   void f() {
          int x[] = {foo( ), bar( )};          int x[] = {foo(), bar()};
          if (true) {                          if (true) {
            f( );                                f();
          }                                    }
        }                                    }
 
-  * ``bool Other`` Put a space in parentheses not covered by preceding options.
+  * ``bool InFunctionCalls`` Put a space in parentheses of function calls.
 
     .. code-block:: c++
 
        true:                                  false:
        t f( Deleted & ) & = delete;   vs.     t f(Deleted &) & = delete;
 
+  * ``bool InFunctionDeclarations`` Put a space in parentheses of function declarations.
+
+    .. code-block:: c++
+
+       true:                                  false:
+       void foo( int bar );           vs.     void foo(int bar);
+
+  * ``bool InFunctionDefinitions`` Put a space in parentheses of function definitions.
+
+    .. code-block:: c++
+
+       true:                                  false:
+       void foo( int bar ) { }        vs.     void foo(int bar) { }
+
+  * ``bool InOverloadedOperators`` Put a space in parentheses of overloaded operators.
+
+    .. code-block:: c++
+
+       true:                                  false:
+       void operator++( int a )       vs.     void operator++(int a)
+       object.operator++( 10 )        vs.     object.operator++(10)
+
+  * ``bool Other`` Put a space in parentheses not covered by preceding options.
+
+    .. code-block:: c++
+
+       true:                                  false:
+       x = ( y + z );                 vs.     x = (y+z);
+
 
 .. _SpacesInParentheses:
 
 **SpacesInParentheses** (``Boolean``) :versionbadge:`clang-format 3.7` :ref:`¶ <SpacesInParentheses>`
   If ``true``, spaces will be inserted after ``(`` and before ``)``.
   This option is **deprecated**. The previous behavior is preserved by using
   ``SpacesInParens`` with ``Custom`` and by setting all
   ``SpacesInParensOptions`` to ``true`` except for ``InCStyleCasts`` and

clang/docs/ReleaseNotes.rst

 
 clang-format
 ------------
 - Add ``AllowBreakBeforeNoexceptSpecifier`` option.
 - Add ``AllowShortCompoundRequirementOnASingleLine`` option.
 - Change ``BreakAfterAttributes`` from ``Never`` to ``Leave`` in LLVM style.
 - Add ``InAttributeSpecifiers`` style option to ``SpacesInParensOptions``
   to control addition of spaces after the ``__attribute__`` keyword.
+- Add ``InFunctionCalls``, ``InFunctionDeclarations``,
+  ``InFunctionDefinitions``, and ``InOverloadedOperators`` style options to
+  ``SpacesInParensOptions`` to control addition of spaces.
 
 libclang
 --------
 
 - Exposed arguments of ``clang::annotate``.
 
 Static Analyzer
 ---------------

clang/include/clang/Format/Format.h

struct SpacesInParensCustom {
     ///    void f( ) {                    vs.   void f() {
     ///      int x[] = {foo( ), bar( )};          int x[] = {foo(), bar()};
     ///      if (true) {                          if (true) {
     ///        f( );                                f();
     ///      }                                    }
     ///    }                                    }
     /// \endcode
     bool InEmptyParentheses;
-    /// Put a space in parentheses not covered by preceding options.
+    /// Put a space in parentheses of function calls.
     /// \code
     ///    true:                                  false:
     ///    t f( Deleted & ) & = delete;   vs.     t f(Deleted &) & = delete;
     /// \endcode
+    bool InFunctionCalls;
+    /// Put a space in parentheses of function declarations.
+    /// \code
+    ///    true:                                  false:
+    ///    void foo( int bar );           vs.     void foo(int bar);
+    /// \endcode
+    bool InFunctionDeclarations;
+    /// Put a space in parentheses of function definitions.
+    /// \code
+    ///    true:                                  false:
+    ///    void foo( int bar ) { }        vs.     void foo(int bar) { }
+    /// \endcode
+    bool InFunctionDefinitions;
+    /// Put a space in parentheses of overloaded operators.
+    /// \code
+    ///    true:                                  false:
+    ///    void operator++( int a )       vs.     void operator++(int a)
+    ///    object.operator++( 10 )        vs.     object.operator++(10)
+    /// \endcode
+    bool InOverloadedOperators;
+    /// Put a space in parentheses not covered by preceding options.
+    /// \code
+    ///    true:                                  false:
+    ///    x = ( y + z );                 vs.     x = (y+z);
+    /// \endcode
     bool Other;
 
     SpacesInParensCustom()
         : InAttributeSpecifiers(false), InConditionalStatements(false),
-          InCStyleCasts(false), InEmptyParentheses(false), Other(false) {}
+          InCStyleCasts(false), InEmptyParentheses(false),
+          InFunctionCalls(false), InFunctionDeclarations(false),
+          InFunctionDefinitions(false), InOverloadedOperators(false),
+          Other(false) {}
 
     SpacesInParensCustom(bool InAttributeSpecifiers,
                          bool InConditionalStatements, bool InCStyleCasts,
-                         bool InEmptyParentheses, bool Other)
+                         bool InEmptyParentheses, bool InFunctionCalls,
+                         bool InFunctionDeclarations,
+                         bool InFunctionDefinitions, bool InOverloadedOperators,
+                         bool Other)
         : InAttributeSpecifiers(InAttributeSpecifiers),
           InConditionalStatements(InConditionalStatements),
           InCStyleCasts(InCStyleCasts), InEmptyParentheses(InEmptyParentheses),
-          Other(Other) {}
+          InFunctionCalls(InFunctionCalls),
+          InFunctionDeclarations(InFunctionDeclarations),
+          InFunctionDefinitions(InFunctionDefinitions),
+          InOverloadedOperators(InOverloadedOperators), Other(Other) {}
 
     bool operator==(const SpacesInParensCustom &R) const {
       return InAttributeSpecifiers == R.InAttributeSpecifiers &&
              InConditionalStatements == R.InConditionalStatements &&
              InCStyleCasts == R.InCStyleCasts &&
-             InEmptyParentheses == R.InEmptyParentheses && Other == R.Other;
+             InEmptyParentheses == R.InEmptyParentheses &&
+             InFunctionCalls == R.InFunctionCalls &&
+             InFunctionDeclarations == R.InFunctionDeclarations &&
+             InFunctionDefinitions == R.InFunctionDefinitions &&
+             InOverloadedOperators == R.InOverloadedOperators &&
+             Other == R.Other;
     }
     bool operator!=(const SpacesInParensCustom &R) const {
       return !(*this == R);
     }
   };
 
   /// Control of individual spaces in parentheses.
   ///

clang/lib/Format/Format.cpp

 };
 
 template <> struct MappingTraits<FormatStyle::SpacesInParensCustom> {
   static void mapping(IO &IO, FormatStyle::SpacesInParensCustom &Spaces) {
     IO.mapOptional("InAttributeSpecifiers", Spaces.InAttributeSpecifiers);
     IO.mapOptional("InCStyleCasts", Spaces.InCStyleCasts);
     IO.mapOptional("InConditionalStatements", Spaces.InConditionalStatements);
     IO.mapOptional("InEmptyParentheses", Spaces.InEmptyParentheses);
+    IO.mapOptional("InFunctionCalls", Spaces.InFunctionCalls);
+    IO.mapOptional("InFunctionDeclarations", Spaces.InFunctionDeclarations);
+    IO.mapOptional("InFunctionDefinitions", Spaces.InFunctionDefinitions);
+    IO.mapOptional("InOverloadedOperators", Spaces.InOverloadedOperators);
     IO.mapOptional("Other", Spaces.Other);
   }
 };
 
 template <> struct ScalarEnumerationTraits<FormatStyle::SpacesInParensStyle> {
   static void enumeration(IO &IO, FormatStyle::SpacesInParensStyle &Value) {
     IO.enumCase(Value, "Never", FormatStyle::SIPO_Never);
     IO.enumCase(Value, "Custom", FormatStyle::SIPO_Custom);
if (Style.SpacesInParens != FormatStyle::SIPO_Custom &&
         // set all options except InCStyleCasts and InEmptyParentheses
         // to true for backward compatibility.
         Style.SpacesInParensOptions.InAttributeSpecifiers = true;
         Style.SpacesInParensOptions.InConditionalStatements = true;
         Style.SpacesInParensOptions.InCStyleCasts =
             SpacesInCStyleCastParentheses;
         Style.SpacesInParensOptions.InEmptyParentheses =
             SpaceInEmptyParentheses;
+        Style.SpacesInParensOptions.InFunctionCalls = true;
+        Style.SpacesInParensOptions.InFunctionDeclarations = true;
+        Style.SpacesInParensOptions.InFunctionDefinitions = true;
+        Style.SpacesInParensOptions.InOverloadedOperators = true;
         Style.SpacesInParensOptions.Other = true;
       } else {
         Style.SpacesInParensOptions = {};
         Style.SpacesInParensOptions.InConditionalStatements =
             SpacesInConditionalStatement;
         Style.SpacesInParensOptions.InCStyleCasts =
             SpacesInCStyleCastParentheses;
         Style.SpacesInParensOptions.InEmptyParentheses =

clang/lib/Format/TokenAnnotator.cpp

if (Right.is(tok::l_paren) && Left.is(tok::kw_co_await) && Left.Previous &&
     return false;
   }
   // co_await (x), co_yield (x), co_return (x)
   if (Left.isOneOf(tok::kw_co_await, tok::kw_co_yield, tok::kw_co_return) &&
       !Right.isOneOf(tok::semi, tok::r_paren)) {
     return true;
   }
 
   if (Left.is(tok::l_paren) || Right.is(tok::r_paren)) {
     if (Right.is(TT_CastRParen) ||
         (Left.MatchingParen && Left.MatchingParen->is(TT_CastRParen))) {
       return Style.SpacesInParensOptions.InCStyleCasts;
     }
     const auto isAttributeParen = [](const FormatToken *Paren) {
       return Paren && Paren->isOneOf(TT_AttributeLParen, TT_AttributeRParen);
     };
     if (isAttributeParen(&Left) || isAttributeParen(&Right) ||
         isAttributeParen(Left.Previous) || isAttributeParen(Right.Next)) {
       return Style.SpacesInParensOptions.InAttributeSpecifiers;
     }
+    // Function declaration or definition
+    const auto isFunctionDeclParen = [](const FormatToken *Paren) {
+      return Paren && Paren->is(TT_FunctionDeclarationName);
+    };
+    if (isFunctionDeclParen(Left.Previous) ||
+        (Right.MatchingParen &&
+         isFunctionDeclParen(Right.MatchingParen->Previous))) {
+      if (Line.MightBeFunctionDecl) {
+        if (Line.mightBeFunctionDefinition())
+          return Style.SpacesInParensOptions.InFunctionDefinitions;
+        return Style.SpacesInParensOptions.InFunctionDeclarations;
+      }
+      return Style.SpacesInParensOptions.Other;
+    }
+    if (Left.is(TT_OverloadedOperatorLParen) ||
+        (Right.MatchingParen &&
+         Right.MatchingParen->is(TT_OverloadedOperatorLParen))) {
+      return Style.SpacesInParensOptions.InOverloadedOperators;
+    }
+    const auto isFunctionCallParen = [](const FormatToken *Paren) {
+      return Paren && Paren->ParameterCount > 0 && Paren->Previous &&
+             Paren->Previous->is(tok::identifier);
+    };
+    if ((isFunctionCallParen(&Left) ||
+         isFunctionCallParen(Right.MatchingParen)) &&
+        (Line.Type != LT_PreprocessorDirective)) {
+      return Style.SpacesInParensOptions.InFunctionCalls;
+    }
     return Style.SpacesInParensOptions.Other;
   }
   if (Right.isOneOf(tok::semi, tok::comma))
     return false;
   if (Right.is(tok::less) && Line.Type == LT_ObjCDecl) {
     bool IsLightweightGeneric = Right.MatchingParen &&
                                 Right.MatchingParen->Next &&
                                 Right.MatchingParen->Next->is(tok::colon);
     return !IsLightweightGeneric && Style.ObjCSpaceBeforeProtocolList;
   }

clang/unittests/Format/ConfigParseTest.cpp

CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions,
                           AfterFunctionDefinitionName);
   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterIfMacros);
   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterOverloadedOperator);
   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, BeforeNonEmptyParentheses);
   CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InAttributeSpecifiers);
   CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InCStyleCasts);
   CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InConditionalStatements);
   CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InEmptyParentheses);
+  CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InFunctionCalls);
+  CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InFunctionDeclarations);
+  CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InFunctionDefinitions);
+  CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InOverloadedOperators);
   CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, Other);
 }
 
 #undef CHECK_PARSE_BOOL
 
 TEST(ConfigParseTest, ParsesConfiguration) {
   FormatStyle Style = {};
   Style.Language = FormatStyle::LK_Cpp;
#undef CHECK_ALIGN_CONSECUTIVE
   // For backward compatibility:
   Style.SpacesInParens = FormatStyle::SIPO_Never;
   Style.SpacesInParensOptions = {};
   CHECK_PARSE("SpacesInParentheses: true", SpacesInParens,
               FormatStyle::SIPO_Custom);
   Style.SpacesInParens = FormatStyle::SIPO_Never;
   Style.SpacesInParensOptions = {};
   CHECK_PARSE("SpacesInParentheses: true", SpacesInParensOptions,
-              FormatStyle::SpacesInParensCustom(true, true, false, false,
-                  true));
+              FormatStyle::SpacesInParensCustom(true, true, false, false, true,
+                true, true, true, true));
   Style.SpacesInParens = FormatStyle::SIPO_Never;
   Style.SpacesInParensOptions = {};
   CHECK_PARSE("SpacesInConditionalStatement: true", SpacesInParensOptions,
               FormatStyle::SpacesInParensCustom(false, true, false, false,
-                  false));
+                false, false, false, false, false));
   Style.SpacesInParens = FormatStyle::SIPO_Never;
   Style.SpacesInParensOptions = {};
   CHECK_PARSE("SpacesInCStyleCastParentheses: true", SpacesInParensOptions,
               FormatStyle::SpacesInParensCustom(false, false, true, false,
-                  false));
+                false, false, false, false, false));
   Style.SpacesInParens = FormatStyle::SIPO_Never;
   Style.SpacesInParensOptions = {};
   CHECK_PARSE("SpaceInEmptyParentheses: true", SpacesInParensOptions,
               FormatStyle::SpacesInParensCustom(false, false, false, true,
-                  false));
+                false, false, false, false, false));
   Style.SpacesInParens = FormatStyle::SIPO_Never;
   Style.SpacesInParensOptions = {};
 
   Style.ColumnLimit = 123;
   FormatStyle BaseStyle = getLLVMStyle();
   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
 

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
   Spaces.SpacesInParensOptions = {};
   Spaces.SpacesInParensOptions.InCStyleCasts = true;
   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
 
   Spaces.SpacesInParensOptions.InCStyleCasts = false;
-  Spaces.SpacesInParensOptions.Other = true;
+  Spaces.SpacesInParensOptions.InFunctionDeclarations = true;
+  Spaces.SpacesInParensOptions.InOverloadedOperators = true;
   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
                Spaces);
   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
 
   FormatStyle BreakTemplate = getLLVMStyle();
   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
 
   FormatStyle SpaceBetweenBraces = getLLVMStyle();
   SpaceBetweenBraces.SpacesInAngles = FormatStyle::SIAS_Always;
   SpaceBetweenBraces.SpacesInParens = FormatStyle::SIPO_Custom;
   SpaceBetweenBraces.SpacesInParensOptions.Other = true;
+  SpaceBetweenBraces.SpacesInParensOptions.InFunctionCalls = true;
   SpaceBetweenBraces.SpacesInSquareBrackets = true;
   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
   verifyFormat("vector< int > x{ // comment 1\n"
                "                 1, 2, 3, 4 };",
                SpaceBetweenBraces);
   SpaceBetweenBraces.ColumnLimit = 20;
   verifyFormat("vector< int > x{\n"
TEST_F(FormatTest, ConfigurableSpacesInParens) {
   verifyFormat("void __attribute__((naked)) foo(int bar)", Spaces);
   verifyFormat("void f() __attribute__((asdf));", Spaces);
 
   Spaces.SpacesInParens = FormatStyle::SIPO_Custom;
   Spaces.SpacesInParensOptions = {};
   Spaces.SpacesInParensOptions.Other = true;
   Spaces.SpacesInParensOptions.InConditionalStatements = true;
   Spaces.SpacesInParensOptions.InAttributeSpecifiers = true;
+  Spaces.SpacesInParensOptions.InFunctionCalls = true;
   verifyFormat("do_something( ::globalVar );", Spaces);
   verifyFormat("call( x, y, z );", Spaces);
   verifyFormat("call();", Spaces);
   verifyFormat("std::function<void( int, int )> callback;", Spaces);
   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
                Spaces);
   verifyFormat("while ( (bool)1 )\n"
                "  continue;",
verifyFormat("do {\n"
                "} while ( something() );",
                Spaces);
   verifyFormat("switch ( x ) {\n"
                "default:\n"
                "  break;\n"
                "}",
                Spaces);
   verifyFormat("SomeType *__attribute__( ( attr ) ) *a = NULL;", Spaces);
-  verifyFormat("void __attribute__( ( naked ) ) foo( int bar )", Spaces);
+  verifyFormat("void __attribute__( ( naked ) ) foo(int bar);", Spaces);
+  verifyFormat("void __attribute__( ( x ) ) foo(int y) { return; }", Spaces);
   verifyFormat("void f() __attribute__( ( asdf ) );", Spaces);
 
   Spaces.SpacesInParens = FormatStyle::SIPO_Custom;
   Spaces.SpacesInParensOptions = {};
   Spaces.SpacesInParensOptions.InCStyleCasts = true;
   verifyFormat("Type *A = ( Type * )P;", Spaces);
   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
   verifyFormat("x = ( int32 )y;", Spaces);
   verifyFormat("throw ( int32 )x;", Spaces);
   verifyFormat("int a = ( int )(2.0f);", Spaces);
   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
   verifyFormat("#define x (( int )-1)", Spaces);
 
   // Run the first set of tests again with:
   Spaces.SpacesInParens = FormatStyle::SIPO_Custom;
   Spaces.SpacesInParensOptions = {};
+  Spaces.SpacesInParensOptions.InFunctionDeclarations = true;
+  verifyFormat("do_something(::globalVar);", Spaces);
+  verifyFormat("call(x, y, z);", Spaces);
+  verifyFormat("call();", Spaces);
+  verifyFormat("std::function<void(int, int)> callback;", Spaces);
+  verifyFormat("void inFunction() { std::function<void(int, int)> fct; }",
+               Spaces);
+  verifyFormat("while ((bool)1)\n"
+               "  continue;",
+               Spaces);
+  verifyFormat("for (;;)\n"
+               "  continue;",
+               Spaces);
+  verifyFormat("if (true)\n"
+               "  f();\n"
+               "else if (true)\n"
+               "  f();",
+               Spaces);
+  verifyFormat("do {\n"
+               "  do_something((int)i);\n"
+               "} while (something());",
+               Spaces);
+  verifyFormat("switch (x) {\n"
+               "default:\n"
+               "  break;\n"
+               "}",
+               Spaces);
+  verifyFormat("SomeType *__attribute__((attr)) *a = NULL;", Spaces);
+  verifyFormat("void __attribute__((naked)) foo( int bar );", Spaces);
+  verifyFormat("void f( int g ) __attribute__((asdf));", Spaces);
+  verifyFormat("int f();", Spaces);
+  verifyFormat("void f(int a, T b) {}", Spaces);
+  verifyFormat("void __attribute__((asdf)) f(int a, T b) {}", Spaces);
+  verifyFormat("A::A() : a(1) {}", Spaces);
+  verifyFormat("void f( int bar ) __attribute__((asdf));", Spaces);
+  verifyFormat("void __attribute__((asdf)) f( int bar );", Spaces);
+  verifyFormat("#define A(x) x", Spaces);
+  verifyFormat("#define A (x) x", Spaces);
+  verifyFormat("#if defined(x)\n"
+               "#endif",
+               Spaces);
+  verifyFormat("auto i = std::make_unique<int>(5);", Spaces);
+  verifyFormat("size_t x = sizeof(x);", Spaces);
+  verifyFormat("auto f( int x ) -> decltype(x);", Spaces);
+  verifyFormat("auto f( int x ) -> typeof(x);", Spaces);
+  verifyFormat("auto f( int x ) -> _Atomic(x);", Spaces);
+  verifyFormat("auto f( int x ) -> __underlying_type(x);", Spaces);
+  verifyFormat("int f( T x ) noexcept(x.create());", Spaces);
+  verifyFormat("alignas(128) char a[128];", Spaces);
+  verifyFormat("size_t x = alignof(MyType);", Spaces);
+  verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");",
+               Spaces);
+  verifyFormat("int f( int g ) throw(Deprecated);", Spaces);
+  verifyFormat("typedef void (*cb)(int);", Spaces);
+  verifyFormat("int x = int(y);", Spaces);
+
+  // Run a subset with:
+  Spaces.SpacesInParensOptions.InFunctionDeclarations = false;
+  Spaces.SpacesInParensOptions.InFunctionDefinitions = true;
+  verifyFormat("do_something(::globalVar);", Spaces);
+  verifyFormat("call(x, y, z);", Spaces);
+  verifyFormat("call();", Spaces);
+  verifyFormat("std::function<void(int, int)> callback;", Spaces);
+  verifyFormat("void inFunction( int x ) { std::function<void(int, int)> f; }",
+               Spaces);
+  verifyFormat("SomeType *__attribute__((attr)) *a = NULL;", Spaces);
+  verifyFormat("void __attribute__((naked)) foo(int bar);", Spaces);
+  verifyFormat("void f(int g) __attribute__((asdf));", Spaces);
+  verifyFormat("int f();", Spaces);
+  verifyFormat("void f( int a, T b ) {}", Spaces);
+  verifyFormat("void __attribute__((asdf)) f( int a, T b ) {}", Spaces);
+  verifyFormat("A::A() : a(1) {}", Spaces);
+  verifyFormat("void f(int bar) __attribute__((asdf));", Spaces);
+  verifyFormat("void __attribute__((asdf)) f(int bar);", Spaces);
+  verifyFormat("#define A(x) x", Spaces);
+  verifyFormat("#define A (x) x", Spaces);
+  verifyFormat("#if defined(x)\n"
+               "#endif",
+               Spaces);
+  verifyFormat("auto i = std::make_unique<int>(5);", Spaces);
+  verifyFormat("size_t x = sizeof(x);", Spaces);
+  verifyFormat("auto f(int x) -> decltype(x);", Spaces);
+  verifyFormat("auto f(int x) -> typeof(x);", Spaces);
+  verifyFormat("auto f(int x) -> _Atomic(x);", Spaces);
+  verifyFormat("auto f(int x) -> __underlying_type(x);", Spaces);
+  verifyFormat("int f(T x) noexcept(x.create());", Spaces);
+  verifyFormat("alignas(128) char a[128];", Spaces);
+  verifyFormat("size_t x = alignof(MyType);", Spaces);
+  verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");",
+               Spaces);
+  verifyFormat("int f(int g) throw(Deprecated);", Spaces);
+  verifyFormat("typedef void (*cb)(int);", Spaces);
+  verifyFormat("int x = int(y);", Spaces);
+
+  // Run a subset with:
+  Spaces.SpacesInParensOptions.InFunctionDeclarations = false;
+  Spaces.SpacesInParensOptions.InFunctionDefinitions = false;
+  Spaces.SpacesInParensOptions.InFunctionCalls = true;
+  verifyFormat("do_something( ::globalVar );", Spaces);
+  verifyFormat("call( x, y, z );", Spaces);
+  verifyFormat("call();", Spaces);
+  verifyFormat("std::function<void(int, int)> callback;", Spaces);
+  verifyFormat("void inFunction(int x) { std::function<void(int, int)> f; }",
+               Spaces);
+  verifyFormat("SomeType *__attribute__((attr)) *a = NULL;", Spaces);
+  verifyFormat("void __attribute__((naked)) foo(int bar);", Spaces);
+  verifyFormat("void f(int g) __attribute__((asdf));", Spaces);
+  verifyFormat("int f();", Spaces);
+  verifyFormat("void f(int a, T b) {}", Spaces);
+  verifyFormat("void __attribute__((asdf)) f(int a, T b) {}", Spaces);
+  verifyFormat("A::A() : a( 1 ) {}", Spaces);
+  verifyFormat("void f(int bar) __attribute__((asdf));", Spaces);
+  verifyFormat("void __attribute__((asdf)) f(int bar);", Spaces);
+  verifyFormat("#define A (x) x", Spaces);
+  verifyFormat("#define A(x) x", Spaces);
+  verifyFormat("#if defined(x)\n"
+               "#endif",
+               Spaces);
+  verifyFormat("auto i = std::make_unique<int>(5);", Spaces);
+  verifyFormat("size_t x = sizeof(x);", Spaces);
+  verifyFormat("auto f(int x) -> decltype(x);", Spaces);
+  verifyFormat("auto f(int x) -> typeof(x);", Spaces);
+  verifyFormat("auto f(int x) -> _Atomic(x);", Spaces);
+  verifyFormat("auto f(int x) -> __underlying_type(x);", Spaces);
+  verifyFormat("int f(T x) noexcept(x.create());", Spaces);
+  verifyFormat("alignas(128) char a[128];", Spaces);
+  verifyFormat("size_t x = alignof(MyType);", Spaces);
+  verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");",
+               Spaces);
+  verifyFormat("int f(int g) throw(Deprecated);", Spaces);
+  verifyFormat("typedef void (*cb)(int);", Spaces);
+  verifyFormat("int x = int(y);", Spaces);
+
+  // Run the first set of tests again with:
+  Spaces.SpacesInParens = FormatStyle::SIPO_Custom;
+  Spaces.SpacesInParensOptions = {};
   Spaces.SpacesInParensOptions.InEmptyParentheses = true;
   Spaces.SpacesInParensOptions.InCStyleCasts = true;
   verifyFormat("call(x, y, z);", Spaces);
   verifyFormat("call( );", Spaces);
   verifyFormat("std::function<void(int, int)> callback;", Spaces);
   verifyFormat("while (( bool )1)\n"
                "  continue;",
                Spaces);
TEST_F(FormatTest, AtomicQualifier) {
   verifyFormat("_Atomic(int)* a;", Style);
   verifyFormat("_Atomic(int*)* a;", Style);
   verifyFormat("vector<_Atomic(uint64_t)* attr> x;", Style);
 
   Style.SpacesInParens = FormatStyle::SIPO_Custom;
   Style.SpacesInParensOptions.InCStyleCasts = true;
   verifyFormat("x = ( _Atomic(uint64_t) )*a;", Style);
   Style.SpacesInParensOptions.InCStyleCasts = false;
+  Style.SpacesInParensOptions.InFunctionCalls = true;
   Style.SpacesInParensOptions.Other = true;
   verifyFormat("x = (_Atomic( uint64_t ))*a;", Style);
   verifyFormat("x = (_Atomic( uint64_t ))&a;", Style);
 }
 
 TEST_F(FormatTest, C11Generic) {
   verifyFormat("_Generic(x, int: 1, default: 0)");
   verifyFormat("#define cbrt(X) _Generic((X), float: cbrtf, default: cbrt)(X)");