fixup! [clang-format] Add an option to format integer literal case

Author: 30Wedge

clang/docs/ClangFormatStyleOptions.rst

@@ -4555,6 +4555,7 @@ the configuration (without a prefix: ``Auto``).
     So inserting a trailing comma counteracts bin-packing.
 
 
+
 .. _IntegerLiteralSeparator:
 
 **IntegerLiteralSeparator** (``IntegerLiteralSeparatorStyle``) :versionbadge:`clang-format 16` :ref:`¶ <IntegerLiteralSeparator>`
@@ -5077,74 +5078,109 @@ the configuration (without a prefix: ``Auto``).
 
 .. _NumericLiteralCase:
 
-**NumericLiteralCase** (``NumericLiteralCaseStyle``) :versionbadge:`clang-format 21` :ref:`¶ <NumericLiteralCase>`
-  Controls character case in numeric literals.
+**NumericLiteralCase** (``NumericLiteralCaseStyle``) :versionbadge:`clang-format 22` :ref:`¶ <NumericLiteralCase>`
+  Capitalization style for numeric literal constants.
 
-  Possible values for each nexted configuration flag:
+  Nested configuration flags:
 
-  * ``0`` (Default) Do not modify characters.
+  Character case format for different components of a numeric literal.
 
-  * ``-1`` Convert characters to lower case.
+  * ``NumericLiteralComponentStyle UpperCaseFloatExponentSeparator``
+    Format floating point exponent separator character case.
 
-  * ``1`` Convert characters to upper case.
+    .. code-block:: text
 
-  .. code-block:: yaml
+      /* UpperCaseFloatExponentSeparator = Leave */
+      float a = 6.02e23 + 1.0E10;
+      /* UpperCaseFloatExponentSeparator = Always */
+      float a = 6.02E23 + 1.0E10;
+      /* UpperCaseFloatExponentSeparator = Never */
+      float a = 6.02e23 + 1.0e10;
 
-    # Example of usage:
-    NumericLiteralCaseStyle:
-      PrefixCase: -1
-      HexDigitCase: 1
-      FloatExponentSeparatorCase: 0
-      SuffixCase: -1
+    Possible values:
 
-  .. code-block:: c++
+    * ``NLCS_Leave`` (in configuration: ``Leave``)
+      Leave this component of the literal as is.
 
-    // Lower case prefix, upper case hexadecimal digits, lower case suffix
-    unsigned int 0xDEAFBEEFull;
+    * ``NLCS_Always`` (in configuration: ``Always``)
+      Always format this component with upper case characters.
 
-  Nested configuration flags:
+    * ``NLCS_Never`` (in configuration: ``Never``)
+      Never format this component with upper case characters.
 
-  * ``int PrefixCase`` Control numeric constant prefix case.
 
-   .. code-block:: c++
+  * ``NumericLiteralComponentStyle UpperCaseHexDigit``
+    Format hexadecimal digit case.
 
-      // PrefixCase: 1
-      int a = 0B101 | 0XF0;
-      // PrefixCase: -1
-      int a = 0b101 | 0xF0;
-      // PrefixCase: 0
-      int c = 0b101 | 0XF0;
+    .. code-block:: text
 
-  * ``int HexDigitCase`` Control hexadecimal digit case.
+      /* UpperCaseHexDigit = Leave */
+      a = 0xaBcDeF;
+      /* UpperCaseHexDigit = Always */
+      a = 0xABCDEF;
+      /* UpperCaseHexDigit = Never */
+      a = 0xabcdef;
 
-    .. code-block:: c++
+    Possible values:
 
-      // HexDigitCase: 1
-      int a = 0xBEAD;
-      // PrefixCase: -1
-      int b = 0xbead;
-      // PrefixCase: 0
-      int c = 0xBeAd;
+    * ``NLCS_Leave`` (in configuration: ``Leave``)
+      Leave this component of the literal as is.
 
-  * ``int FloatExponentSeparatorCase`` Control exponent separator case.
+    * ``NLCS_Always`` (in configuration: ``Always``)
+      Always format this component with upper case characters.
 
-    .. code-block:: c++
+    * ``NLCS_Never`` (in configuration: ``Never``)
+      Never format this component with upper case characters.
 
-      // FloatExponentSeparatorCase: 1
-      float a = 6.02E+23;
-      // FloatExponentSeparatorCase: -1
-      float b = 6.02e+23;
 
-  * ``int SuffixCase`` Control suffix case.
+  * ``NumericLiteralComponentStyle UpperCasePrefix``
+    Format integer prefix case.
 
-    .. code-block:: c++
+    .. code-block:: text
+
+       /* UpperCasePrefix = Leave */
+       a = 0XF0 | 0b1;
+       /* UpperCasePrefix = Always */
+       a = 0XF0 | 0B1;
+       /* UpperCasePrefix = Never */
+       a = 0xF0 | 0b1;
+
+    Possible values:
+
+    * ``NLCS_Leave`` (in configuration: ``Leave``)
+      Leave this component of the literal as is.
+
+    * ``NLCS_Always`` (in configuration: ``Always``)
+      Always format this component with upper case characters.
+
+    * ``NLCS_Never`` (in configuration: ``Never``)
+      Never format this component with upper case characters.
+
+
+  * ``NumericLiteralComponentStyle UpperCaseSuffix``
+    Format suffix case. This option excludes case-specific reserved
+    suffixes, such as ``min`` in C++.
+
+    .. code-block:: text
+
+      /* UpperCaseSuffix = Leave */
+      a = 1uLL;
+      /* UpperCaseSuffix = Always */
+      a = 1ULL;
+      /* UpperCaseSuffix = Never */
+      a = 1ull;
+
+    Possible values:
+
+    * ``NLCS_Leave`` (in configuration: ``Leave``)
+      Leave this component of the literal as is.
+
+    * ``NLCS_Always`` (in configuration: ``Always``)
+      Always format this component with upper case characters.
+
+    * ``NLCS_Never`` (in configuration: ``Never``)
+      Never format this component with upper case characters.
 
-      // SuffixCase: 1
-      unsigned long long a = 1ULL;
-      // SuffixCase: -1
-      unsigned long long a = 1ull;
-      // SuffixCase: 0
-      unsigned long long c = 1uLL;
 
 
 .. _ObjCBinPackProtocolList:

clang/docs/ReleaseNotes.rst

@@ -230,8 +230,8 @@ AST Matchers
 
 clang-format
 ------------
-- Add ``NumericLiteralCase`` option for for enforcing character case in
-  numeric literals.
+- Add ``NumericLiteralCase`` option for enforcing character case in numeric
+  literals.
 
 libclang
 --------

clang/include/clang/Format/Format.h

@@ -3100,54 +3100,6 @@ struct FormatStyle {
   /// \version 11
   TrailingCommaStyle InsertTrailingCommas;
 
-  /// Character case format for different components of a numeric literal.
-  ///
-  /// For all options, ``0`` leave the case unchanged, ``-1``
-  /// uses lower case and, ``1`` uses upper case.
-  ///
-  struct NumericLiteralCaseStyle {
-    /// Format numeric constant prefixes.
-    /// \code{.text}
-    ///   /* -1: lower case */ b = 0x01;
-    ///   /*  0: don't care */
-    ///   /*  1: upper case */ b = 0X01;
-    /// \endcode
-    int8_t PrefixCase;
-    /// Format hexadecimal digit case.
-    /// \code{.text}
-    ///   /* -1: lower case */ b = 0xabcdef;
-    ///   /*  0: don't care */
-    ///   /*  1: upper case */ b = 0xABCDEF;
-    /// \endcode
-    int8_t HexDigitCase;
-    /// Format exponent separator character case in floating point literals.
-    /// \code{.text}
-    ///   /* -1: lower case */ b = 6.02e23;
-    ///   /*  0: don't care */
-    ///   /*  1: upper case */ b = 6.02E23;
-    /// \endcode
-    int8_t FloatExponentSeparatorCase;
-    /// Format suffix case. This option excludes case-specific reserved
-    /// suffixes, such as ``min`` in C++.
-    /// \code{.text}
-    ///   /* -1: lower case */ b = 10u;
-    ///   /*  0: don't care */
-    ///   /*  1: upper case */ b = 10U;
-    /// \endcode
-    int8_t SuffixCase;
-
-    bool operator==(const NumericLiteralCaseStyle &R) const {
-      return PrefixCase == R.PrefixCase && HexDigitCase == R.HexDigitCase &&
-             FloatExponentSeparatorCase == R.FloatExponentSeparatorCase &&
-             SuffixCase == R.SuffixCase;
-    }
-  };
-
-  /// Format numeric literals for languages that support flexible character case
-  /// in numeric literal constants.
-  /// \version 22
-  NumericLiteralCaseStyle NumericLiteralCase;
-
   /// Separator format of integer literals of different bases.
   ///
   /// If negative, remove separators. If  ``0``, leave the literal as is. If
@@ -3606,6 +3558,76 @@ struct FormatStyle {
   /// \version 9
   std::vector<std::string> NamespaceMacros;
 
+  /// Control over each component in a numeric literal.
+  enum NumericLiteralComponentStyle : int8_t {
+    /// Leave this component of the literal as is.
+    NLCS_Leave,
+    /// Always format this component with upper case characters.
+    NLCS_Always,
+    /// Never format this component with upper case characters.
+    NLCS_Never,
+  };
+
+  /// Character case format for different components of a numeric literal.
+  struct NumericLiteralCaseStyle {
+    /// Format floating point exponent separator character case.
+    /// \code{.text}
+    ///   /* UpperCaseFloatExponentSeparator = Leave */
+    ///   float a = 6.02e23 + 1.0E10;
+    ///   /* UpperCaseFloatExponentSeparator = Always */
+    ///   float a = 6.02E23 + 1.0E10;
+    ///   /* UpperCaseFloatExponentSeparator = Never */
+    ///   float a = 6.02e23 + 1.0e10;
+    /// \endcode
+    NumericLiteralComponentStyle UpperCaseFloatExponentSeparator;
+    /// Format hexadecimal digit case.
+    /// \code{.text}
+    ///   /* UpperCaseHexDigit = Leave */
+    ///   a = 0xaBcDeF;
+    ///   /* UpperCaseHexDigit = Always */
+    ///   a = 0xABCDEF;
+    ///   /* UpperCaseHexDigit = Never */
+    ///   a = 0xabcdef;
+    /// \endcode
+    NumericLiteralComponentStyle UpperCaseHexDigit;
+    /// Format integer prefix case.
+    /// \code{.text}
+    ///    /* UpperCasePrefix = Leave */
+    ///    a = 0XF0 | 0b1;
+    ///    /* UpperCasePrefix = Always */
+    ///    a = 0XF0 | 0B1;
+    ///    /* UpperCasePrefix = Never */
+    ///    a = 0xF0 | 0b1;
+    /// \endcode
+    NumericLiteralComponentStyle UpperCasePrefix;
+    /// Format suffix case. This option excludes case-specific reserved
+    /// suffixes, such as ``min`` in C++.
+    /// \code{.text}
+    ///   /* UpperCaseSuffix = Leave */
+    ///   a = 1uLL;
+    ///   /* UpperCaseSuffix = Always */
+    ///   a = 1ULL;
+    ///   /* UpperCaseSuffix = Never */
+    ///   a = 1ull;
+    /// \endcode
+    NumericLiteralComponentStyle UpperCaseSuffix;
+
+    bool operator==(const NumericLiteralCaseStyle &R) const {
+      return UpperCaseFloatExponentSeparator ==
+                 R.UpperCaseFloatExponentSeparator &&
+             UpperCaseHexDigit == R.UpperCaseHexDigit &&
+             UpperCasePrefix == R.UpperCasePrefix &&
+             UpperCaseSuffix == R.UpperCaseSuffix;
+    }
+    bool operator!=(const NumericLiteralCaseStyle &R) const {
+      return !(*this == R);
+    }
+  };
+
+  /// Capitalization style for numeric literal constants.
+  /// \version 22
+  NumericLiteralCaseStyle NumericLiteralCase;
+
   /// Controls bin-packing Objective-C protocol conformance list
   /// items into as few lines as possible when they go over ``ColumnLimit``.
   ///
@@ -5472,7 +5494,6 @@ struct FormatStyle {
            IndentWrappedFunctionNames == R.IndentWrappedFunctionNames &&
            InsertBraces == R.InsertBraces &&
            InsertNewlineAtEOF == R.InsertNewlineAtEOF &&
-           NumericLiteralCase == R.NumericLiteralCase &&
            IntegerLiteralSeparator == R.IntegerLiteralSeparator &&
            JavaImportGroups == R.JavaImportGroups &&
            JavaScriptQuotes == R.JavaScriptQuotes &&
@@ -5487,6 +5508,7 @@ struct FormatStyle {
            MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep &&
            NamespaceIndentation == R.NamespaceIndentation &&
            NamespaceMacros == R.NamespaceMacros &&
+           NumericLiteralCase == R.NumericLiteralCase &&
            ObjCBinPackProtocolList == R.ObjCBinPackProtocolList &&
            ObjCBlockIndentWidth == R.ObjCBlockIndentWidth &&
            ObjCBreakBeforeNestedBlockParam ==