Only filter doubled parens situationally like RemoveParentheses

Author: gedare

clang/docs/ClangFormatStyleOptions.rst

@@ -5688,8 +5688,8 @@ the configuration (without a prefix: ``Auto``).
     # Example of usage:
     SpacesInParens: Custom
     SpacesInParensOptions:
-      InAttributeSpecifiers: NonConsecutive
-      InConditionalStatements: Always
+      InAttributeSpecifiers: false
+      InConditionalStatements: true
       InEmptyParentheses: true
 
   Nested configuration flags:
@@ -5704,103 +5704,60 @@ the configuration (without a prefix: ``Auto``).
       InConditionalStatements: true
       Other: true
 
-  * ``SpacesInParensCustomStyle InAttributeSpecifiers``
-    Put a space in parentheses of attribute specifiers.
+  * ``bool ExceptDoubleParentheses`` Override any of the following options to prevent addition of space
+    between the first two parentheses in situations where a pair of
+    parentheses have been used.
 
     .. code-block:: c++
 
-       Always:
-       __attribute__( ( noreturn ) )
+      true:
+      __attribute__(( noreturn ))
+      __decltype__(( x ))
+      if (( a = b ))
+     false:
+       Uses the applicable option.
+
+  * ``bool InAttributeSpecifiers`` Put a space in parentheses of attribute specifiers.
 
     .. code-block:: c++
 
-       NonConsecutive:
-       _attribute__(( noreturn ))
+       true:
+       __attribute__( ( noreturn ) )
 
     .. code-block:: c++
 
-       Never:
+       false:
        _attribute__((noreturn))
 
-    Possible values:
-
-    * ``SIPCS_Never`` (in configuration: ``Never``)
-      Never put spaces in parens.
-
-    * ``SIPCS_NonConsecutive`` (in configuration: ``NonConsecutive``)
-      Only put spaces in parens not followed by the same consecutive parens.
-
-    * ``SIPCS_Always`` (in configuration: ``Always``)
-      Always put spaces in parens.
-
-
-  * ``SpacesInParensCustomStyle InConditionalStatements``
-    Put a space in parentheses only inside conditional statements
+  * ``bool InConditionalStatements`` Put a space in parentheses only inside conditional statements
     (``for/if/while/switch...``).
 
     .. code-block:: c++
 
-       Always:
+       true:
        if ( ( a ) )  { ... }
        while ( i < 5 )  { ... }
 
     .. code-block:: c++
 
-      NonConsecutive:
-      if (( a )) { ... }
-      while ( i < 5 ) { ... }
-
-    .. code-block:: c++
-
-      Never:
+      false:
       if ((a)) { ... }
       while (i < 5) { ... }
 
-    Possible values:
-
-    * ``SIPCS_Never`` (in configuration: ``Never``)
-      Never put spaces in parens.
-
-    * ``SIPCS_NonConsecutive`` (in configuration: ``NonConsecutive``)
-      Only put spaces in parens not followed by the same consecutive parens.
-
-    * ``SIPCS_Always`` (in configuration: ``Always``)
-      Always put spaces in parens.
-
-
-  * ``SpacesInParensCustomStyle InCStyleCasts``
-    Put a space in C style casts.
+  * ``bool InCStyleCasts`` Put a space in C style casts.
 
     .. code-block:: c++
 
-      Always:
+      true:
       x = ( int32 )y
       y = (( int (*)(int) )foo)(x);
 
     .. code-block:: c++
 
-      NonConsecutive:
-      x = ( int32 )y
-      y = ((int (*)(int))foo)(x);
-
-    .. code-block:: c++
-
-      Never:
+      false:
       x = (int32)y
       y = ((int (*)(int))foo)(x);
 
-    Possible values:
-
-    * ``SIPCS_Never`` (in configuration: ``Never``)
-      Never put spaces in parens.
-
-    * ``SIPCS_NonConsecutive`` (in configuration: ``NonConsecutive``)
-      Only put spaces in parens not followed by the same consecutive parens.
-
-    * ``SIPCS_Always`` (in configuration: ``Always``)
-      Always put spaces in parens.
-
-
   * ``bool InEmptyParentheses`` Put a space in parentheses only if the parentheses are empty i.e. '()'
 
     .. code-block:: c++
@@ -5813,45 +5770,24 @@ the configuration (without a prefix: ``Auto``).
          }                                    }
        }                                    }
 
-  * ``SpacesInParensCustomStyle Other``
-    Put a space in parentheses not covered by preceding options.
+  * ``bool Other`` Put a space in parentheses not covered by preceding options.
 
     .. code-block:: c++
 
-      Always:
+      true:
       t f( Deleted & ) & = delete;
       decltype( ( x ) )
       x = ( (int32)y )
       y = ( (int ( * )( int ))foo )( x );
 
     .. code-block:: c++
 
-      NonConsecutive:
-      t f( Deleted & ) & = delete;
-      decltype(( x ))
-      x = ((int32))y
-      y = ((int ( * )( int ))foo)( x );
-
-    .. code-block:: c++
-
-      Never:
+      false:
       t f(Deleted &) & = delete;
       decltype((x))
       x = ((int32))y
       y = ((int (*)(int))foo)(x);
 
-    Possible values:
-
-    * ``SIPCS_Never`` (in configuration: ``Never``)
-      Never put spaces in parens.
-
-    * ``SIPCS_NonConsecutive`` (in configuration: ``NonConsecutive``)
-      Only put spaces in parens not followed by the same consecutive parens.
-
-    * ``SIPCS_Always`` (in configuration: ``Always``)
-      Always put spaces in parens.
-
-
 
 .. _SpacesInParentheses:
 

clang/docs/ReleaseNotes.rst

@@ -1284,10 +1284,9 @@ clang-format
 - Add ``SkipMacroDefinitionBody`` option.
 - Add ``InAttributeSpecifiers`` style option to ``SpacesInParensOptions``
   to control addition of spaces after the ``__attribute__`` keyword.
-- Add ``NonConsecutive`` sub-option for ``InAttributeSpecifiers``,
-  ``InConditionalStatements``, ``InCStyleCasts``, and ``Other`` options of
-  ``SpacesInParensOptions`` to control addition of spaces between consecutive
-  parentheses.
+- Add ``ExceptDoubleParentheses`` sub-option for ``SpacesInParensOptions``
+  to override addition of spaces between multiple, non-redundant parentheses
+  similar to the rules used for ``RemoveParentheses``.
 
 libclang
 --------

clang/include/clang/Format/Format.h

@@ -4533,16 +4533,6 @@ struct FormatStyle {
   /// \version 17
   SpacesInParensStyle SpacesInParens;
 
-  /// Selective control over spaces in parens.
-  enum SpacesInParensCustomStyle : int8_t {
-    /// Never put spaces in parens.
-    SIPCS_Never,
-    /// Only put spaces in parens not followed by the same consecutive parens.
-    SIPCS_NonConsecutive,
-    /// Always put spaces in parens.
-    SIPCS_Always
-  };
-
   /// Precise control over the spacing in parentheses.
   /// \code
   ///   # Should be declared this way:
@@ -4552,55 +4542,53 @@ struct FormatStyle {
   ///     Other: true
   /// \endcode
   struct SpacesInParensCustom {
-    /// Put a space in parentheses of attribute specifiers.
+    /// Override any of the following options to prevent addition of space
+    /// between the first two parentheses in situations where a pair of
+    /// parentheses have been used.
     /// \code
-    ///    Always:
-    ///    __attribute__( ( noreturn ) )
+    ///   true:
+    ///   __attribute__(( noreturn ))
+    ///   __decltype__(( x ))
+    ///   if (( a = b ))
     /// \endcode
+    ///  false:
+    ///    Uses the applicable option.
+    bool ExceptDoubleParentheses;
+    /// Put a space in parentheses of attribute specifiers.
     /// \code
-    ///    NonConsecutive:
-    ///    _attribute__(( noreturn ))
+    ///    true:
+    ///    __attribute__( ( noreturn ) )
     /// \endcode
     /// \code
-    ///    Never:
+    ///    false:
     ///    _attribute__((noreturn))
     /// \endcode
-    SpacesInParensCustomStyle InAttributeSpecifiers;
+    bool InAttributeSpecifiers;
     /// Put a space in parentheses only inside conditional statements
     /// (``for/if/while/switch...``).
     /// \code
-    ///    Always:
+    ///    true:
     ///    if ( ( a ) )  { ... }
     ///    while ( i < 5 )  { ... }
     /// \endcode
     /// \code
-    ///   NonConsecutive:
-    ///   if (( a )) { ... }
-    ///   while ( i < 5 ) { ... }
-    /// \endcode
-    /// \code
-    ///   Never:
+    ///   false:
     ///   if ((a)) { ... }
     ///   while (i < 5) { ... }
     /// \endcode
-    SpacesInParensCustomStyle InConditionalStatements;
+    bool InConditionalStatements;
     /// Put a space in C style casts.
     /// \code
-    ///   Always:
+    ///   true:
     ///   x = ( int32 )y
     ///   y = (( int (*)(int) )foo)(x);
     /// \endcode
     /// \code
-    ///   NonConsecutive:
-    ///   x = ( int32 )y
-    ///   y = ((int (*)(int))foo)(x);
-    /// \endcode
-    /// \code
-    ///   Never:
+    ///   false:
     ///   x = (int32)y
     ///   y = ((int (*)(int))foo)(x);
     /// \endcode
-    SpacesInParensCustomStyle InCStyleCasts;
+    bool InCStyleCasts;
     /// Put a space in parentheses only if the parentheses are empty i.e. '()'
     /// \code
     ///    true:                                false:
@@ -4614,45 +4602,39 @@ struct FormatStyle {
     bool InEmptyParentheses;
     /// Put a space in parentheses not covered by preceding options.
     /// \code
-    ///   Always:
+    ///   true:
     ///   t f( Deleted & ) & = delete;
     ///   decltype( ( x ) )
     ///   x = ( (int32)y )
     ///   y = ( (int ( * )( int ))foo )( x );
     /// \endcode
     /// \code
-    ///   NonConsecutive:
-    ///   t f( Deleted & ) & = delete;
-    ///   decltype(( x ))
-    ///   x = ((int32))y
-    ///   y = ((int ( * )( int ))foo)( x );
-    /// \endcode
-    /// \code
-    ///   Never:
+    ///   false:
     ///   t f(Deleted &) & = delete;
     ///   decltype((x))
     ///   x = ((int32))y
     ///   y = ((int (*)(int))foo)(x);
     /// \endcode
-    SpacesInParensCustomStyle Other;
+    bool Other;
 
     SpacesInParensCustom()
-        : InAttributeSpecifiers(SIPCS_Never),
-          InConditionalStatements(SIPCS_Never), InCStyleCasts(SIPCS_Never),
-          InEmptyParentheses(false), Other(SIPCS_Never) {}
-
-    SpacesInParensCustom(SpacesInParensCustomStyle InAttributeSpecifiers,
-                         SpacesInParensCustomStyle InConditionalStatements,
-                         SpacesInParensCustomStyle InCStyleCasts,
-                         bool InEmptyParentheses,
-                         SpacesInParensCustomStyle Other)
-        : InAttributeSpecifiers(InAttributeSpecifiers),
+        : ExceptDoubleParentheses(false), InAttributeSpecifiers(false),
+          InConditionalStatements(false), InCStyleCasts(false),
+          InEmptyParentheses(false), Other(false) {}
+
+    SpacesInParensCustom(bool ExceptDoubleParentheses,
+                         bool InAttributeSpecifiers,
+                         bool InConditionalStatements, bool InCStyleCasts,
+                         bool InEmptyParentheses, bool Other)
+        : ExceptDoubleParentheses(ExceptDoubleParentheses),
+          InAttributeSpecifiers(InAttributeSpecifiers),
           InConditionalStatements(InConditionalStatements),
           InCStyleCasts(InCStyleCasts), InEmptyParentheses(InEmptyParentheses),
           Other(Other) {}
 
     bool operator==(const SpacesInParensCustom &R) const {
-      return InAttributeSpecifiers == R.InAttributeSpecifiers &&
+      return ExceptDoubleParentheses == R.ExceptDoubleParentheses &&
+             InAttributeSpecifiers == R.InAttributeSpecifiers &&
              InConditionalStatements == R.InConditionalStatements &&
              InCStyleCasts == R.InCStyleCasts &&
              InEmptyParentheses == R.InEmptyParentheses && Other == R.Other;
@@ -4671,8 +4653,8 @@ struct FormatStyle {
   ///   # Example of usage:
   ///   SpacesInParens: Custom
   ///   SpacesInParensOptions:
-  ///     InAttributeSpecifiers: NonConsecutive
-  ///     InConditionalStatements: Always
+  ///     InAttributeSpecifiers: false
+  ///     InConditionalStatements: true
   ///     InEmptyParentheses: true
   /// \endcode
   /// \version 17