[clang-format] Add an option to format integer and float literal case

clang/docs/ClangFormatStyleOptions.rst

@@ -5076,6 +5076,113 @@ the configuration (without a prefix: ``Auto``).
 
   For example: TESTSUITE
 
+.. _NumericLiteralCase:
+
+**NumericLiteralCase** (``NumericLiteralCaseStyle``) :versionbadge:`clang-format 22` :ref:`¶ <NumericLiteralCase>`
+  Capitalization style for numeric literal constants.
+
+  Nested configuration flags:
+
+  Separate control for each numeric literal component.
+
+  * ``NumericLiteralComponentStyle ExponentLetter``
+    Format floating point exponent separator letter case.
+
+    .. code-block:: c++
+
+      /* ExponentLetter = Leave */
+      float a = 6.02e23 + 1.0E10;
+      /* ExponentLetter = Upper */
+      float a = 6.02E23 + 1.0E10;
+      /* ExponentLetter = Lower */
+      float a = 6.02e23 + 1.0e10;
+
+    Possible values:
+
+    * ``NLCS_Leave`` (in configuration: ``Leave``)
+      Leave this component of the literal as is.
+
+    * ``NLCS_Upper`` (in configuration: ``Upper``)
+      Format this component with upper case characters.
+
+    * ``NLCS_Lower`` (in configuration: ``Lower``)
+      Format this component with lower case characters.
+
+
+  * ``NumericLiteralComponentStyle HexDigit``
+    Format hexadecimal digit case.
+
+    .. code-block:: c++
+
+      /* HexDigit = Leave */
+      a = 0xaBcDeF;
+      /* HexDigit = Upper */
+      a = 0xABCDEF;
+      /* HexDigit = Lower */
+      a = 0xabcdef;
+
+    Possible values:
+
+    * ``NLCS_Leave`` (in configuration: ``Leave``)
+      Leave this component of the literal as is.
+
+    * ``NLCS_Upper`` (in configuration: ``Upper``)
+      Format this component with upper case characters.
+
+    * ``NLCS_Lower`` (in configuration: ``Lower``)
+      Format this component with lower case characters.
+
+
+  * ``NumericLiteralComponentStyle Prefix``
+    Format integer prefix case.
+
+    .. code-block:: c++
+
+       /* Prefix = Leave */
+       a = 0XF0 | 0b1;
+       /* Prefix = Upper */
+       a = 0XF0 | 0B1;
+       /* Prefix = Lower */
+       a = 0xF0 | 0b1;
+
+    Possible values:
+
+    * ``NLCS_Leave`` (in configuration: ``Leave``)
+      Leave this component of the literal as is.
+
+    * ``NLCS_Upper`` (in configuration: ``Upper``)
+      Format this component with upper case characters.
+
+    * ``NLCS_Lower`` (in configuration: ``Lower``)
+      Format this component with lower case characters.
+
+
+  * ``NumericLiteralComponentStyle Suffix``
+    Format suffix case. This option excludes case-sensitive reserved
+    suffixes, such as ``min`` in C++.
+
+    .. code-block:: c++
+
+      /* Suffix = Leave */
+      a = 1uLL;
+      /* Suffix = Upper */
+      a = 1ULL;
+      /* Suffix = Lower */
+      a = 1ull;
+
+    Possible values:
+
+    * ``NLCS_Leave`` (in configuration: ``Leave``)
+      Leave this component of the literal as is.
+
+    * ``NLCS_Upper`` (in configuration: ``Upper``)
+      Format this component with upper case characters.
+
+    * ``NLCS_Lower`` (in configuration: ``Lower``)
+      Format this component with lower case characters.
+
+
+
 .. _ObjCBinPackProtocolList:
 
 **ObjCBinPackProtocolList** (``BinPackStyle``) :versionbadge:`clang-format 7` :ref:`¶ <ObjCBinPackProtocolList>`

clang/docs/ReleaseNotes.rst

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

clang/include/clang/Format/Format.h

@@ -3558,6 +3558,74 @@ 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,
+    /// Format this component with upper case characters.
+    NLCS_Upper,
+    /// Format this component with lower case characters.
+    NLCS_Lower,
+  };
+
+  /// Separate control for each numeric literal component.
+  struct NumericLiteralCaseStyle {
+    /// Format floating point exponent separator letter case.
+    /// \code
+    ///   /* ExponentLetter = Leave */
+    ///   float a = 6.02e23 + 1.0E10;
+    ///   /* ExponentLetter = Upper */
+    ///   float a = 6.02E23 + 1.0E10;
+    ///   /* ExponentLetter = Lower */
+    ///   float a = 6.02e23 + 1.0e10;
+    /// \endcode
+    NumericLiteralComponentStyle ExponentLetter;
+    /// Format hexadecimal digit case.
+    /// \code
+    ///   /* HexDigit = Leave */
+    ///   a = 0xaBcDeF;
+    ///   /* HexDigit = Upper */
+    ///   a = 0xABCDEF;
+    ///   /* HexDigit = Lower */
+    ///   a = 0xabcdef;
+    /// \endcode
+    NumericLiteralComponentStyle HexDigit;
+    /// Format integer prefix case.
+    /// \code
+    ///    /* Prefix = Leave */
+    ///    a = 0XF0 | 0b1;
+    ///    /* Prefix = Upper */
+    ///    a = 0XF0 | 0B1;
+    ///    /* Prefix = Lower */
+    ///    a = 0xF0 | 0b1;
+    /// \endcode
+    NumericLiteralComponentStyle Prefix;
+    /// Format suffix case. This option excludes case-sensitive reserved
+    /// suffixes, such as ``min`` in C++.
+    /// \code
+    ///   /* Suffix = Leave */
+    ///   a = 1uLL;
+    ///   /* Suffix = Upper */
+    ///   a = 1ULL;
+    ///   /* Suffix = Lower */
+    ///   a = 1ull;
+    /// \endcode
+    NumericLiteralComponentStyle Suffix;
+
+    bool operator==(const NumericLiteralCaseStyle &R) const {
+      return ExponentLetter == R.ExponentLetter && HexDigit == R.HexDigit &&
+             Prefix == R.Prefix && Suffix == R.Suffix;
+    }
+
+    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``.
   ///
@@ -5438,6 +5506,7 @@ struct FormatStyle {
            MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep &&
            NamespaceIndentation == R.NamespaceIndentation &&
            NamespaceMacros == R.NamespaceMacros &&
+           NumericLiteralCase == R.NumericLiteralCase &&
            ObjCBinPackProtocolList == R.ObjCBinPackProtocolList &&
            ObjCBlockIndentWidth == R.ObjCBlockIndentWidth &&
            ObjCBreakBeforeNestedBlockParam ==

clang/lib/Format/CMakeLists.txt

@@ -14,6 +14,7 @@ add_clang_library(clangFormat
   MatchFilePath.cpp
   NamespaceEndCommentsFixer.cpp
   NumericLiteralInfo.cpp
+  NumericLiteralCaseFixer.cpp
   ObjCPropertyAttributeOrderFixer.cpp
   QualifierAlignmentFixer.cpp
   SortJavaScriptImports.cpp

clang/lib/Format/Format.cpp

@@ -16,6 +16,7 @@
 #include "DefinitionBlockSeparator.h"
 #include "IntegerLiteralSeparatorFixer.h"
 #include "NamespaceEndCommentsFixer.h"
+#include "NumericLiteralCaseFixer.h"
 #include "ObjCPropertyAttributeOrderFixer.h"
 #include "QualifierAlignmentFixer.h"
 #include "SortJavaScriptImports.h"
@@ -472,6 +473,25 @@ struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> {
   }
 };
 
+template <>
+struct ScalarEnumerationTraits<FormatStyle::NumericLiteralComponentStyle> {
+  static void enumeration(IO &IO,
+                          FormatStyle::NumericLiteralComponentStyle &Value) {
+    IO.enumCase(Value, "Leave", FormatStyle::NLCS_Leave);
+    IO.enumCase(Value, "Upper", FormatStyle::NLCS_Upper);
+    IO.enumCase(Value, "Lower", FormatStyle::NLCS_Lower);
+  }
+};
+
+template <> struct MappingTraits<FormatStyle::NumericLiteralCaseStyle> {
+  static void mapping(IO &IO, FormatStyle::NumericLiteralCaseStyle &Base) {
+    IO.mapOptional("ExponentLetter", Base.ExponentLetter);
+    IO.mapOptional("HexDigit", Base.HexDigit);
+    IO.mapOptional("Prefix", Base.Prefix);
+    IO.mapOptional("Suffix", Base.Suffix);
+  }
+};
+
 template <> struct ScalarEnumerationTraits<FormatStyle::OperandAlignmentStyle> {
   static void enumeration(IO &IO, FormatStyle::OperandAlignmentStyle &Value) {
     IO.enumCase(Value, "DontAlign", FormatStyle::OAS_DontAlign);
@@ -1110,6 +1130,7 @@ template <> struct MappingTraits<FormatStyle> {
     IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
     IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
     IO.mapOptional("NamespaceMacros", Style.NamespaceMacros);
+    IO.mapOptional("NumericLiteralCase", Style.NumericLiteralCase);
     IO.mapOptional("ObjCBinPackProtocolList", Style.ObjCBinPackProtocolList);
     IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
     IO.mapOptional("ObjCBreakBeforeNestedBlockParam",
@@ -1635,6 +1656,10 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.LineEnding = FormatStyle::LE_DeriveLF;
   LLVMStyle.MaxEmptyLinesToKeep = 1;
   LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
+  LLVMStyle.NumericLiteralCase = {/*ExponentLetter=*/FormatStyle::NLCS_Leave,
+                                  /*HexDigit=*/FormatStyle::NLCS_Leave,
+                                  /*Prefix=*/FormatStyle::NLCS_Leave,
+                                  /*Suffix=*/FormatStyle::NLCS_Leave};
   LLVMStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Auto;
   LLVMStyle.ObjCBlockIndentWidth = 2;
   LLVMStyle.ObjCBreakBeforeNestedBlockParam = true;
@@ -3872,6 +3897,12 @@ reformat(const FormatStyle &Style, StringRef Code,
     return IntegerLiteralSeparatorFixer().process(Env, Expanded);
   });
 
+  if (NumericLiteralCaseFixer::isActive(Style)) {
+    Passes.emplace_back([&](const Environment &Env) {
+      return NumericLiteralCaseFixer().process(Env, Expanded);
+    });
+  }
+
   if (Style.isCpp()) {
     if (Style.QualifierAlignment != FormatStyle::QAS_Leave)
       addQualifierAlignmentFixerPasses(Expanded, Passes);
@@ -3983,8 +4014,8 @@ reformat(const FormatStyle &Style, StringRef Code,
 
   if (Style.QualifierAlignment != FormatStyle::QAS_Leave) {
     // Don't make replacements that replace nothing. QualifierAlignment can
-    // produce them if one of its early passes changes e.g. `const volatile` to
-    // `volatile const` and then a later pass changes it back again.
+    // produce them if one of its early passes changes e.g. `const volatile`
+    // to `volatile const` and then a later pass changes it back again.
     tooling::Replacements NonNoOpFixes;
     for (const tooling::Replacement &Fix : Fixes) {
       StringRef OriginalCode = Code.substr(Fix.getOffset(), Fix.getLength());