Support function and overloaded operator SpacesInParensOption

gedare · gedare · commit c06e8ba20dd9 · 2024-01-09T14:12:20.000-07:00
This change separates function calls, declarations, definitions, and overloaded operators from `SpacesInParensOptions.Other` to allow control over each independently. Fixes llvm#55428.
diff --git a/clang/docs/ClangFormatStyleOptions.rst b/clang/docs/ClangFormatStyleOptions.rst
@@ -5660,13 +5660,42 @@ the configuration (without a prefix: ``Auto``).
          }                                    }
        }                                    }
 
-  * ``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:
 
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
@@ -1081,6 +1081,9 @@ clang-format
 - Add ``.clang-format-ignore`` files.
 - 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
 --------
diff --git a/clang/include/clang/Format/Format.h b/clang/include/clang/Format/Format.h
@@ -4546,30 +4546,69 @@ struct FormatStyle {
     ///    }                                    }
     /// \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);
diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp
@@ -757,6 +757,10 @@ template <> struct MappingTraits<FormatStyle::SpacesInParensCustom> {
     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);
   }
 };
@@ -1198,6 +1202,10 @@ template <> struct MappingTraits<FormatStyle> {
             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 = {};
diff --git a/clang/lib/Format/TokenAnnotator.cpp b/clang/lib/Format/TokenAnnotator.cpp
@@ -4010,6 +4010,34 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
         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))
diff --git a/clang/unittests/Format/ConfigParseTest.cpp b/clang/unittests/Format/ConfigParseTest.cpp
@@ -235,6 +235,10 @@ TEST(ConfigParseTest, ParsesConfigurationBools) {
   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);
 }
 
@@ -627,23 +631,23 @@ TEST(ConfigParseTest, ParsesConfiguration) {
   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 = {};
 
diff --git a/clang/unittests/Format/FormatTest.cpp b/clang/unittests/Format/FormatTest.cpp
