diff --git a/clang/docs/ClangFormatStyleOptions.rst b/clang/docs/ClangFormatStyleOptions.rst index 02986a94a656c..5dc2e5ca2618b 100644 --- a/clang/docs/ClangFormatStyleOptions.rst +++ b/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:`¶ ` + 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:`¶ ` diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index af576f817700a..e634f32615000 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -279,6 +279,8 @@ AST Matchers clang-format ------------ +- Add ``NumericLiteralCase`` option for enforcing character case in numeric + literals. libclang -------- diff --git a/clang/include/clang/Format/Format.h b/clang/include/clang/Format/Format.h index 31582a40de866..3a84ef4af4afd 100644 --- a/clang/include/clang/Format/Format.h +++ b/clang/include/clang/Format/Format.h @@ -3558,6 +3558,74 @@ struct FormatStyle { /// \version 9 std::vector 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 == diff --git a/clang/lib/Format/CMakeLists.txt b/clang/lib/Format/CMakeLists.txt index 24f435d2caee1..c4891ec3916ec 100644 --- a/clang/lib/Format/CMakeLists.txt +++ b/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 diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp index 063780721423f..14deec8d492e8 100644 --- a/clang/lib/Format/Format.cpp +++ b/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 { } }; +template <> +struct ScalarEnumerationTraits { + 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 { + 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 { static void enumeration(IO &IO, FormatStyle::OperandAlignmentStyle &Value) { IO.enumCase(Value, "DontAlign", FormatStyle::OAS_DontAlign); @@ -1110,6 +1130,7 @@ template <> struct MappingTraits { 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()); diff --git a/clang/lib/Format/NumericLiteralCaseFixer.cpp b/clang/lib/Format/NumericLiteralCaseFixer.cpp new file mode 100644 index 0000000000000..dfbf0b26fbcd3 --- /dev/null +++ b/clang/lib/Format/NumericLiteralCaseFixer.cpp @@ -0,0 +1,190 @@ +//===--- NumericLiteralCaseFixer.cpp -----------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file implements NumericLiteralCaseFixer that standardizes character +/// case within numeric literal constants. +/// +//===----------------------------------------------------------------------===// + +#include "NumericLiteralCaseFixer.h" +#include "NumericLiteralInfo.h" + +#include "llvm/ADT/StringExtras.h" + +#include + +namespace clang { +namespace format { + +static std::string +transformComponent(StringRef Component, + FormatStyle::NumericLiteralComponentStyle ConfigValue) { + switch (ConfigValue) { + case FormatStyle::NLCS_Upper: + return Component.upper(); + case FormatStyle::NLCS_Lower: + return Component.lower(); + case FormatStyle::NLCS_Leave: + default: + return Component.str(); + } +} + +/// @brief Test if Suffix matches a C++ literal reserved by the library. +/// Matches against all suffixes reserved in the C++23 standard +static bool matchesReservedSuffix(StringRef Suffix) { + static constexpr std::array SortedReservedSuffixes = { + "d", "h", "i", "if", "il", "min", "ms", "ns", "s", "us", "y"}; + + // This can be static_assert when we have access to constexpr is_sorted in + // C++ 20. + assert(llvm::is_sorted(SortedReservedSuffixes) && + "Must be sorted as precondition for lower_bound()."); + + auto entry = llvm::lower_bound(SortedReservedSuffixes, Suffix); + if (entry == SortedReservedSuffixes.cend()) + return false; + return *entry == Suffix; +} + +static std::optional formatIfNeeded(StringRef IntegerLiteral, + const FormatStyle &Style) { + char Separator; + switch (Style.Language) { + case FormatStyle::LK_CSharp: + case FormatStyle::LK_Java: + case FormatStyle::LK_JavaScript: + Separator = '_'; + break; + case FormatStyle::LK_C: + case FormatStyle::LK_Cpp: + case FormatStyle::LK_ObjC: + default: + Separator = '\''; + } + const NumericLiteralInfo N{IntegerLiteral, Separator}; + + std::string Formatted{""}; + + if (N.BaseLetterPos != llvm::StringRef::npos) { + Formatted += + transformComponent(IntegerLiteral.take_front(1 + N.BaseLetterPos), + Style.NumericLiteralCase.Prefix); + } + // reformat this slice as HexDigit whether or not the digit has hexadecimal + // characters because binary/decimal/octal digits are unchanged + Formatted += transformComponent( + IntegerLiteral.slice( + N.BaseLetterPos == llvm::StringRef::npos ? 0 : 1 + N.BaseLetterPos, + N.ExponentLetterPos == llvm::StringRef::npos + ? N.SuffixPos == llvm::StringRef::npos ? IntegerLiteral.size() + : N.SuffixPos + : N.ExponentLetterPos), + Style.NumericLiteralCase.HexDigit); + + if (N.ExponentLetterPos != llvm::StringRef::npos) { + Formatted += transformComponent( + IntegerLiteral.slice(N.ExponentLetterPos, + N.SuffixPos == llvm::StringRef::npos + ? IntegerLiteral.size() + : N.SuffixPos), + Style.NumericLiteralCase.ExponentLetter); + } + + if (N.SuffixPos != llvm::StringRef::npos) { + StringRef Suffix = IntegerLiteral.drop_front(N.SuffixPos); + if (matchesReservedSuffix(Suffix) || Suffix.front() == '_') { + // In C++, it is idiomatic, but NOT standardized to define user-defined + // literals with a leading '_'. Omit user defined literals and standard + // reserved suffixes from transformation. + Formatted += Suffix.str(); + } else { + Formatted += transformComponent(Suffix, Style.NumericLiteralCase.Suffix); + } + } + + if (Formatted == IntegerLiteral) + return std::nullopt; + else + return Formatted; +} + +std::pair +NumericLiteralCaseFixer::process(const Environment &Env, + const FormatStyle &Style) { + + const auto &SourceMgr = Env.getSourceManager(); + AffectedRangeManager AffectedRangeMgr(SourceMgr, Env.getCharRanges()); + + const auto ID = Env.getFileID(); + const auto LangOpts = getFormattingLangOpts(Style); + Lexer Lex(ID, SourceMgr.getBufferOrFake(ID), SourceMgr, LangOpts); + Lex.SetCommentRetentionState(true); + + Token Tok; + tooling::Replacements Result; + bool Skip = false; + + while (!Lex.LexFromRawLexer(Tok)) { + // Skip tokens that are too small to contain a formattable literal. + // Size=2 is the smallest possible literal that could contain formattable + // components, for example "1u". + auto Length = Tok.getLength(); + if (Length < 2) + continue; + + // Service clang-format off/on comments. + auto Location = Tok.getLocation(); + auto Text = StringRef(SourceMgr.getCharacterData(Location), Length); + if (Tok.is(tok::comment)) { + if (isClangFormatOff(Text)) + Skip = true; + else if (isClangFormatOn(Text)) + Skip = false; + continue; + } + + if (Skip || Tok.isNot(tok::numeric_constant) || + !AffectedRangeMgr.affectsCharSourceRange( + CharSourceRange::getCharRange(Location, Tok.getEndLoc()))) { + continue; + } + + const auto Formatted = formatIfNeeded(Text, Style); + if (Formatted) { + assert(*Formatted != Text && "QuickNumericalConstantParser returned an " + "unchanged value instead of nullopt"); + cantFail(Result.add( + tooling::Replacement(SourceMgr, Location, Length, *Formatted))); + } + } + + return {Result, 0}; +} + +bool NumericLiteralCaseFixer::isActive(const FormatStyle &Style) { + + switch (Style.Language) { + case FormatStyle::LK_C: + case FormatStyle::LK_Cpp: + case FormatStyle::LK_ObjC: + case FormatStyle::LK_CSharp: + case FormatStyle::LK_Java: + case FormatStyle::LK_JavaScript: + break; + default: + return false; + } + + const FormatStyle::NumericLiteralCaseStyle LeaveAllCasesUntouched{}; + + return Style.NumericLiteralCase != LeaveAllCasesUntouched; +} +} // namespace format +} // namespace clang diff --git a/clang/lib/Format/NumericLiteralCaseFixer.h b/clang/lib/Format/NumericLiteralCaseFixer.h new file mode 100644 index 0000000000000..d836e8d064b44 --- /dev/null +++ b/clang/lib/Format/NumericLiteralCaseFixer.h @@ -0,0 +1,35 @@ +//===--- NumericLiteralCaseFixer.h -------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file declares NumericLiteralCaseFixer that standardizes character case +/// within numeric literal constants. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_LIB_FORMAT_NUMERICLITERALCASEFIXER_H +#define LLVM_CLANG_LIB_FORMAT_NUMERICLITERALCASEFIXER_H + +#include "TokenAnalyzer.h" + +namespace clang { +namespace format { + +class NumericLiteralCaseFixer { +public: + std::pair process(const Environment &Env, + const FormatStyle &Style); + + /// Return true if this pass should be added to the formatting run. + static bool isActive(const FormatStyle &Style); +}; + +} // end namespace format +} // end namespace clang + +#endif diff --git a/clang/unittests/Format/CMakeLists.txt b/clang/unittests/Format/CMakeLists.txt index c4c7b483ba68e..5ea7e965465d9 100644 --- a/clang/unittests/Format/CMakeLists.txt +++ b/clang/unittests/Format/CMakeLists.txt @@ -28,6 +28,7 @@ add_distinct_clang_unittest(FormatTests MatchFilePathTest.cpp NamespaceEndCommentsFixerTest.cpp NumericLiteralInfoTest.cpp + NumericLiteralCaseTest.cpp ObjCPropertyAttributeOrderFixerTest.cpp QualifierFixerTest.cpp SortImportsTestJS.cpp diff --git a/clang/unittests/Format/NumericLiteralCaseTest.cpp b/clang/unittests/Format/NumericLiteralCaseTest.cpp new file mode 100644 index 0000000000000..518b71333dd5d --- /dev/null +++ b/clang/unittests/Format/NumericLiteralCaseTest.cpp @@ -0,0 +1,354 @@ +//===- unittest/Format/NumericLiteralCaseTest.cpp --------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FormatTestBase.h" + +#define DEBUG_TYPE "numeric-literal-case-test" + +namespace clang { +namespace format { +namespace test { +namespace { + +class NumericLiteralCaseTest : public FormatTestBase {}; + +TEST_F(NumericLiteralCaseTest, Prefix) { + FormatStyle Style = getLLVMStyle(); + EXPECT_EQ(Style.Language, FormatStyle::LK_Cpp); + EXPECT_EQ(Style.NumericLiteralCase.Prefix, FormatStyle::NLCS_Leave); + EXPECT_EQ(Style.NumericLiteralCase.HexDigit, FormatStyle::NLCS_Leave); + EXPECT_EQ(Style.NumericLiteralCase.ExponentLetter, FormatStyle::NLCS_Leave); + EXPECT_EQ(Style.NumericLiteralCase.Suffix, FormatStyle::NLCS_Leave); + + constexpr StringRef Bin0{"b = 0b0'10'010uL;"}; + constexpr StringRef Bin1{"b = 0B010'010Ul;"}; + constexpr StringRef Hex0{"b = 0xdead'BEEFuL;"}; + constexpr StringRef Hex1{"b = 0Xdead'BEEFUl;"}; + verifyFormat(Bin0, Style); + verifyFormat(Bin1, Style); + verifyFormat(Hex0, Style); + verifyFormat(Hex1, Style); + + Style.NumericLiteralCase.Prefix = FormatStyle::NLCS_Upper; + verifyFormat("b = 0B0'10'010uL;", Bin0, Style); + verifyFormat(Bin1, Style); + verifyFormat("b = 0Xdead'BEEFuL;", Hex0, Style); + verifyFormat(Hex1, Style); + verifyFormat("i = 0XaBcD.a0Ebp123F;", Style); + verifyFormat("j = 0XaBcD.a0EbP123f;", Style); + + Style.NumericLiteralCase.Prefix = FormatStyle::NLCS_Lower; + verifyFormat(Bin0, Style); + verifyFormat("b = 0b010'010Ul;", Bin1, Style); + verifyFormat(Hex0, Style); + verifyFormat("b = 0xdead'BEEFUl;", Hex1, Style); +} + +TEST_F(NumericLiteralCaseTest, HexDigit) { + FormatStyle Style = getLLVMStyle(); + + constexpr StringRef A{"a = 0xaBc0'123fuL;"}; + constexpr StringRef B{"b = 0XaBc0'123FUl;"}; + constexpr StringRef C{"c = 0xa'Bc.0p12'3f32;"}; + constexpr StringRef D{"d = 0xa'Bc.0P12'3F128;"}; + constexpr StringRef E{"e = 0b0011'00Ull;"}; + constexpr StringRef F{"f = 0B0100'000zu;"}; + constexpr StringRef G{"g = 0.123e-19f;"}; + constexpr StringRef H{"h = 0.12'3E-19F16;"}; + constexpr StringRef I{"i = 0x.0000aBcp12'3F128;"}; + constexpr StringRef J{"j = 0xaa1'fP12'3F128;"}; + constexpr StringRef K{"k = 0x0;"}; + constexpr StringRef L{"l = 0xA;"}; + + verifyFormat(A, Style); + verifyFormat(B, Style); + verifyFormat(C, Style); + verifyFormat(D, Style); + verifyFormat(E, Style); + verifyFormat(F, Style); + verifyFormat(G, Style); + verifyFormat(H, Style); + verifyFormat(I, Style); + verifyFormat(J, Style); + + Style.NumericLiteralCase.HexDigit = FormatStyle::NLCS_Upper; + verifyFormat("a = 0xABC0'123FuL;", A, Style); + verifyFormat("b = 0XABC0'123FUl;", B, Style); + verifyFormat("c = 0xA'BC.0p12'3f32;", C, Style); + verifyFormat("d = 0xA'BC.0P12'3F128;", D, Style); + verifyFormat("e = 0b0011'00Ull;", E, Style); + verifyFormat("f = 0B0100'000zu;", F, Style); + verifyFormat("g = 0.123e-19f;", G, Style); + verifyFormat("h = 0.12'3E-19F16;", H, Style); + verifyFormat("i = 0x.0000ABCp12'3F128;", I, Style); + verifyFormat("j = 0xAA1'FP12'3F128;", J, Style); + + Style.NumericLiteralCase.HexDigit = FormatStyle::NLCS_Lower; + verifyFormat("a = 0xabc0'123fuL;", A, Style); + verifyFormat("b = 0Xabc0'123fUl;", B, Style); + verifyFormat("c = 0xa'bc.0p12'3f32;", C, Style); + verifyFormat("d = 0xa'bc.0P12'3F128;", D, Style); + verifyFormat("e = 0b0011'00Ull;", E, Style); + verifyFormat("f = 0B0100'000zu;", F, Style); + verifyFormat("g = 0.123e-19f;", G, Style); + verifyFormat("h = 0.12'3E-19F16;", H, Style); + verifyFormat("i = 0x.0000abcp12'3F128;", I, Style); + verifyFormat("j = 0xaa1'fP12'3F128;", J, Style); +} + +TEST_F(NumericLiteralCaseTest, ExponentLetter) { + FormatStyle Style = getLLVMStyle(); + + constexpr StringRef A{"a = .0'01e-19f;"}; + constexpr StringRef B{"b = .00'1E2F;"}; + constexpr StringRef C{"c = 10'2.e99;"}; + constexpr StringRef D{"d = 123.456E-1;"}; + constexpr StringRef E{"e = 0x12abEe3.456p-10'0;"}; + constexpr StringRef F{"f = 0x.deEfP23;"}; + constexpr StringRef G{"g = 0xe0E1.p-1;"}; + + verifyFormat(A, Style); + verifyFormat(B, Style); + verifyFormat(C, Style); + verifyFormat(D, Style); + verifyFormat(E, Style); + verifyFormat(F, Style); + verifyFormat(G, Style); + + Style.NumericLiteralCase.ExponentLetter = FormatStyle::NLCS_Lower; + verifyFormat(A, Style); + verifyFormat("b = .00'1e2F;", B, Style); + verifyFormat(C, Style); + verifyFormat("d = 123.456e-1;", D, Style); + verifyFormat(E, Style); + verifyFormat("f = 0x.deEfp23;", F, Style); + verifyFormat(G, Style); + + Style.NumericLiteralCase.ExponentLetter = FormatStyle::NLCS_Upper; + verifyFormat("a = .0'01E-19f;", A, Style); + verifyFormat(B, Style); + verifyFormat("c = 10'2.E99;", C, Style); + verifyFormat(D, Style); + verifyFormat("e = 0x12abEe3.456P-10'0;", E, Style); + verifyFormat(F, Style); + verifyFormat("g = 0xe0E1.P-1;", G, Style); +} + +TEST_F(NumericLiteralCaseTest, IntegerSuffix) { + FormatStyle Style = getLLVMStyle(); + + constexpr StringRef A{"a = 102u;"}; + constexpr StringRef B{"b = 0177U;"}; + constexpr StringRef C{"c = 0b101'111llU;"}; + constexpr StringRef D{"d = 0xdead'BeefuZ;"}; + constexpr StringRef E{"e = 3lU;"}; + constexpr StringRef F{"f = 1zu;"}; + constexpr StringRef G{"g = 0uLL;"}; + constexpr StringRef H{"h = 10'233'213'0101uLL;"}; + + verifyFormat(A, Style); + verifyFormat(B, Style); + verifyFormat(C, Style); + verifyFormat(D, Style); + verifyFormat(E, Style); + verifyFormat(F, Style); + verifyFormat(G, Style); + verifyFormat(H, Style); + + Style.NumericLiteralCase.Suffix = FormatStyle::NLCS_Lower; + verifyFormat(A, Style); + verifyFormat("b = 0177u;", B, Style); + verifyFormat("c = 0b101'111llu;", C, Style); + verifyFormat("d = 0xdead'Beefuz;", D, Style); + verifyFormat("e = 3lu;", E, Style); + verifyFormat(F, Style); + verifyFormat("g = 0ull;", G, Style); + verifyFormat("h = 10'233'213'0101ull;", H, Style); + + Style.NumericLiteralCase.Suffix = FormatStyle::NLCS_Upper; + verifyFormat("a = 102U;", A, Style); + verifyFormat(B, Style); + verifyFormat("c = 0b101'111LLU;", C, Style); + verifyFormat("d = 0xdead'BeefUZ;", D, Style); + verifyFormat("e = 3LU;", E, Style); + verifyFormat("f = 1ZU;", F, Style); + verifyFormat("g = 0ULL;", G, Style); + verifyFormat("h = 10'233'213'0101ULL;", H, Style); +} + +TEST_F(NumericLiteralCaseTest, FloatingPointSuffix) { + FormatStyle Style = getLLVMStyle(); + // Floating point literals without suffixes. + std::vector FloatingPointStatements = { + StringRef("a = 0."), StringRef("b = 1.0"), + StringRef("c = .123'45E-10"), StringRef("d = 12'3.0e1"), + StringRef("e = 0Xa0eE.P10"), StringRef("f = 0xeE01.aFf3p6"), + }; + + struct FloatSuffix { + StringRef Lower; + StringRef Upper; + }; + // All legal floating point literals defined in the C++23 standard. + std::vector FloatingPointSuffixes = { + {"f", "F"}, {"l", "L"}, {"f16", "F16"}, {"f32", "F32"}, + {"f64", "F64"}, {"f128", "F128"}, {"bf16", "BF16"}, + }; + + // Test all combinations of literals with suffixes. + for (auto &Statement : FloatingPointStatements) { + for (auto &Suffix : FloatingPointSuffixes) { + std::string LowerLine = + std::string{Statement} + std::string{Suffix.Lower} + ";"; + std::string UpperLine = + std::string{Statement} + std::string{Suffix.Upper} + ";"; + + Style.NumericLiteralCase.Suffix = FormatStyle::NLCS_Leave; + verifyFormat(LowerLine, Style); + verifyFormat(UpperLine, Style); + + Style.NumericLiteralCase.Suffix = FormatStyle::NLCS_Lower; + verifyFormat(LowerLine, Style); + verifyFormat(LowerLine, UpperLine, Style); + + Style.NumericLiteralCase.Suffix = FormatStyle::NLCS_Upper; + verifyFormat(UpperLine, LowerLine, Style); + verifyFormat(UpperLine, Style); + } + } +} + +TEST_F(NumericLiteralCaseTest, CppStandardAndUserDefinedLiteralsAreUntouched) { + FormatStyle Style = getLLVMStyle(); + Style.NumericLiteralCase.Prefix = FormatStyle::NLCS_Upper; + Style.NumericLiteralCase.HexDigit = FormatStyle::NLCS_Upper; + Style.NumericLiteralCase.ExponentLetter = FormatStyle::NLCS_Upper; + Style.NumericLiteralCase.Suffix = FormatStyle::NLCS_Upper; + + // C++ user-defined suffixes begin with '_' or are reserved for the standard + // library. + constexpr StringRef UDLiterals{"a = 12.if;\n" + "b = -3i;\n" + "c = 100'01il;\n" + "d = 100'0.12il;\n" + "e = 12h;\n" + "f = 0XABE12h;\n" + "g = 0XFA03min;\n" + "h = 0X12B4Ds;\n" + "i = 20.13E-1ms;\n" + "j = 20.13E-1us;\n" + "k = 20.13E-1ns;\n" + "l = 20.13E-1y;\n" + "m = 20.13E-1d;\n" + "n = 20.13E-1d;\n" + "o = 1d;\n" + "p = 102_ffl_lzlz;\n" + "q = 10.2_l;\n" + "r = 0XABDE.0'1P-23_f;\n" + "s = 102_foo_bar;\n" + "t = 123.456_felfz_ballpen;\n" + "u = 0XBEAD1_spacebar;"}; + + verifyFormat(UDLiterals, Style); + Style.NumericLiteralCase.Suffix = FormatStyle::NLCS_Lower; + verifyFormat(UDLiterals, Style); +} + +TEST_F(NumericLiteralCaseTest, FixRanges) { + FormatStyle Style = getLLVMStyle(); + Style.NumericLiteralCase.Prefix = FormatStyle::NLCS_Lower; + Style.NumericLiteralCase.HexDigit = FormatStyle::NLCS_Lower; + Style.NumericLiteralCase.ExponentLetter = FormatStyle::NLCS_Lower; + Style.NumericLiteralCase.Suffix = FormatStyle::NLCS_Lower; + + constexpr StringRef CodeBlock{"a = 0xFea3duLL;\n" + "b = 0X.aEbp-12f;\n" + "c = 0uLL;\n" + "// clang-format off\n" + "e = 0xBeAdu;\n" + "// clang-format on\n" + "g = 0xabCDu;\n" + "h = 0b010uL;\n" + "// clang-format off\n" + "i = 0B1010'000Zu;\n" + "// clang-format on\n" + "k = 0XaBuL;"}; + + verifyFormat("a = 0xfea3dull;\n" + "b = 0x.aebp-12f;\n" + "c = 0ull;\n" + "// clang-format off\n" + "e = 0xBeAdu;\n" + "// clang-format on\n" + "g = 0xabcdu;\n" + "h = 0b010ul;\n" + "// clang-format off\n" + "i = 0B1010'000Zu;\n" + "// clang-format on\n" + "k = 0xabul;", + CodeBlock, Style); +} + +TEST_F(NumericLiteralCaseTest, UnderScoreSeparatorLanguages) { + FormatStyle Style = getLLVMStyle(); + + constexpr StringRef CodeBlock{"a = 0xFea_3dl;\n" + "b = 0123_345;\n" + "c = 0b11____00lU;\n" + "d = 0XB_e_A_du;\n" + "e = 123_456.333__456e-10f;\n" + "f = .1_0E-10D;\n" + "g = 1_0.F;\n" + "h = 0B1_0;"}; + auto TestUnderscore = [&](auto Language) { + Style.Language = Language; + Style.NumericLiteralCase.Prefix = FormatStyle::NLCS_Lower; + Style.NumericLiteralCase.HexDigit = FormatStyle::NLCS_Upper; + Style.NumericLiteralCase.ExponentLetter = FormatStyle::NLCS_Lower; + Style.NumericLiteralCase.Suffix = FormatStyle::NLCS_Upper; + verifyFormat("a = 0xFEA_3DL;\n" + "b = 0123_345;\n" + "c = 0b11____00LU;\n" + "d = 0xB_E_A_DU;\n" + "e = 123_456.333__456e-10F;\n" + "f = .1_0e-10D;\n" + "g = 1_0.F;\n" + "h = 0b1_0;", + CodeBlock, Style); + + Style.NumericLiteralCase.Prefix = FormatStyle::NLCS_Upper; + Style.NumericLiteralCase.HexDigit = FormatStyle::NLCS_Lower; + Style.NumericLiteralCase.ExponentLetter = FormatStyle::NLCS_Upper; + Style.NumericLiteralCase.Suffix = FormatStyle::NLCS_Lower; + + verifyFormat("a = 0Xfea_3dl;\n" + "b = 0123_345;\n" + "c = 0B11____00lu;\n" + "d = 0Xb_e_a_du;\n" + "e = 123_456.333__456E-10f;\n" + "f = .1_0E-10d;\n" + "g = 1_0.f;\n" + "h = 0B1_0;", + CodeBlock, Style); + }; + + TestUnderscore(FormatStyle::LK_CSharp); + TestUnderscore(FormatStyle::LK_Java); + TestUnderscore(FormatStyle::LK_JavaScript); + + Style.Language = FormatStyle::LK_JavaScript; + Style.NumericLiteralCase.Prefix = FormatStyle::NLCS_Upper; + verifyFormat("o = 0O0_10_010;", "o = 0o0_10_010;", Style); + Style.NumericLiteralCase.Prefix = FormatStyle::NLCS_Lower; + verifyFormat("o = 0o0_10_010;", "o = 0O0_10_010;", Style); +} + +} // namespace +} // namespace test +} // namespace format +} // namespace clang