llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-format Author: owenca (owenca) <details> <summary>Changes</summary> Also set it to SIEB_Always for WebKit style. Closes #<!-- -->85525. Closes #<!-- -->93635. --- Full diff: https://github.com/llvm/llvm-project/pull/153765.diff 7 Files Affected: - (modified) clang/docs/ClangFormatStyleOptions.rst (+32-5) - (modified) clang/include/clang/Format/Format.h (+29-8) - (modified) clang/lib/Format/Format.cpp (+21-3) - (modified) clang/lib/Format/TokenAnnotator.cpp (+17-10) - (modified) clang/lib/Format/UnwrappedLineFormatter.cpp (+2-1) - (modified) clang/unittests/Format/ConfigParseTest.cpp (+11-1) - (modified) clang/unittests/Format/FormatTest.cpp (+23-2) ``````````diff diff --git a/clang/docs/ClangFormatStyleOptions.rst b/clang/docs/ClangFormatStyleOptions.rst index 02986a94a656c..b44dc62f58303 100644 --- a/clang/docs/ClangFormatStyleOptions.rst +++ b/clang/docs/ClangFormatStyleOptions.rst @@ -6483,13 +6483,40 @@ the configuration (without a prefix: ``Auto``). .. _SpaceInEmptyBlock: **SpaceInEmptyBlock** (``Boolean``) :versionbadge:`clang-format 10` :ref:`¶ <SpaceInEmptyBlock>` - If ``true``, spaces will be inserted into ``{}``. + This option is **deprecated**. See ``Block`` of ``SpaceInEmptyBraces``. + +.. _SpaceInEmptyBraces: + +**SpaceInEmptyBraces** (``SpaceInEmptyBracesStyle``) :versionbadge:`clang-format 22` :ref:`¶ <SpaceInEmptyBraces>` + Specifies when to insert a space in empty braces. + + Possible values: + + * ``SIEB_Always`` (in configuration: ``Always``) + + .. code-block:: c++ + + void f() { } + class Unit { }; + int x{ }; + + * ``SIEB_Block`` (in configuration: ``Block``) + + .. code-block:: c++ + + void f() { } + class Unit { }; + int x{}; + + * ``SIEB_Never`` (in configuration: ``Never``) + + .. code-block:: c++ + + void f() {} + class Unit {}; + int x{}; - .. code-block:: c++ - true: false: - void f() { } vs. void f() {} - while (true) { } while (true) {} .. _SpaceInEmptyParentheses: diff --git a/clang/include/clang/Format/Format.h b/clang/include/clang/Format/Format.h index 31582a40de866..5f4ef7709f9d2 100644 --- a/clang/include/clang/Format/Format.h +++ b/clang/include/clang/Format/Format.h @@ -4813,14 +4813,35 @@ struct FormatStyle { /// \version 7 bool SpaceBeforeRangeBasedForLoopColon; - /// If ``true``, spaces will be inserted into ``{}``. - /// \code - /// true: false: - /// void f() { } vs. void f() {} - /// while (true) { } while (true) {} - /// \endcode + /// This option is **deprecated**. See ``Block`` of ``SpaceInEmptyBraces``. /// \version 10 - bool SpaceInEmptyBlock; + // bool SpaceInEmptyBlock; + + /// Style of when to insert a space in empty braces. + enum SpaceInEmptyBracesStyle : int8_t { + /// \code + /// void f() { } + /// class Unit { }; + /// int x{ }; + /// \endcode + SIEB_Always, + /// \code + /// void f() { } + /// class Unit { }; + /// int x{}; + /// \endcode + SIEB_Block, + /// \code + /// void f() {} + /// class Unit {}; + /// int x{}; + /// \endcode + SIEB_Never + }; + + /// Specifies when to insert a space in empty braces. + /// \version 22 + SpaceInEmptyBracesStyle SpaceInEmptyBraces; /// If ``true``, spaces may be inserted into ``()``. /// This option is **deprecated**. See ``InEmptyParentheses`` of @@ -5494,7 +5515,7 @@ struct FormatStyle { SpaceBeforeRangeBasedForLoopColon == R.SpaceBeforeRangeBasedForLoopColon && SpaceBeforeSquareBrackets == R.SpaceBeforeSquareBrackets && - SpaceInEmptyBlock == R.SpaceInEmptyBlock && + SpaceInEmptyBraces == R.SpaceInEmptyBraces && SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments && SpacesInAngles == R.SpacesInAngles && SpacesInContainerLiterals == R.SpacesInContainerLiterals && diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp index 063780721423f..e3b22cdabaccd 100644 --- a/clang/lib/Format/Format.cpp +++ b/clang/lib/Format/Format.cpp @@ -763,6 +763,15 @@ struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensStyle> { } }; +template <> +struct ScalarEnumerationTraits<FormatStyle::SpaceInEmptyBracesStyle> { + static void enumeration(IO &IO, FormatStyle::SpaceInEmptyBracesStyle &Value) { + IO.enumCase(Value, "Always", FormatStyle::SIEB_Always); + IO.enumCase(Value, "Block", FormatStyle::SIEB_Block); + IO.enumCase(Value, "Never", FormatStyle::SIEB_Never); + } +}; + template <> struct ScalarEnumerationTraits<FormatStyle::SpacesInAnglesStyle> { static void enumeration(IO &IO, FormatStyle::SpacesInAnglesStyle &Value) { IO.enumCase(Value, "Never", FormatStyle::SIAS_Never); @@ -931,6 +940,7 @@ template <> struct MappingTraits<FormatStyle> { bool DeriveLineEnding = true; bool UseCRLF = false; + bool SpaceInEmptyBlock = false; bool SpaceInEmptyParentheses = false; bool SpacesInConditionalStatement = false; bool SpacesInCStyleCastParentheses = false; @@ -960,6 +970,7 @@ template <> struct MappingTraits<FormatStyle> { IO.mapOptional("PointerBindsToType", Style.PointerAlignment); IO.mapOptional("SpaceAfterControlStatementKeyword", Style.SpaceBeforeParens); + IO.mapOptional("SpaceInEmptyBlock", SpaceInEmptyBlock); IO.mapOptional("SpaceInEmptyParentheses", SpaceInEmptyParentheses); IO.mapOptional("SpacesInConditionalStatement", SpacesInConditionalStatement); @@ -1193,7 +1204,7 @@ template <> struct MappingTraits<FormatStyle> { Style.SpaceBeforeRangeBasedForLoopColon); IO.mapOptional("SpaceBeforeSquareBrackets", Style.SpaceBeforeSquareBrackets); - IO.mapOptional("SpaceInEmptyBlock", Style.SpaceInEmptyBlock); + IO.mapOptional("SpaceInEmptyBraces", Style.SpaceInEmptyBraces); IO.mapOptional("SpacesBeforeTrailingComments", Style.SpacesBeforeTrailingComments); IO.mapOptional("SpacesInAngles", Style.SpacesInAngles); @@ -1276,6 +1287,13 @@ template <> struct MappingTraits<FormatStyle> { Style.LineEnding = FormatStyle::LE_DeriveCRLF; } + // If SpaceInEmptyBlock was specified but SpaceInEmptyBraces was not, + // initialize the latter from the former for backward compatibility. + if (SpaceInEmptyBlock && + Style.SpaceInEmptyBraces == FormatStyle::SIEB_Never) { + Style.SpaceInEmptyBraces = FormatStyle::SIEB_Block; + } + if (Style.SpacesInParens != FormatStyle::SIPO_Custom && (SpacesInParentheses || SpaceInEmptyParentheses || SpacesInConditionalStatement || SpacesInCStyleCastParentheses)) { @@ -1677,7 +1695,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) { LLVMStyle.SpaceBeforeParensOptions.AfterIfMacros = true; LLVMStyle.SpaceBeforeRangeBasedForLoopColon = true; LLVMStyle.SpaceBeforeSquareBrackets = false; - LLVMStyle.SpaceInEmptyBlock = false; + LLVMStyle.SpaceInEmptyBraces = FormatStyle::SIEB_Never; LLVMStyle.SpacesBeforeTrailingComments = 1; LLVMStyle.SpacesInAngles = FormatStyle::SIAS_Never; LLVMStyle.SpacesInContainerLiterals = true; @@ -1984,7 +2002,7 @@ FormatStyle getWebKitStyle() { Style.ObjCSpaceAfterProperty = true; Style.PointerAlignment = FormatStyle::PAS_Left; Style.SpaceBeforeCpp11BracedList = true; - Style.SpaceInEmptyBlock = true; + Style.SpaceInEmptyBraces = FormatStyle::SIEB_Always; return Style; } diff --git a/clang/lib/Format/TokenAnnotator.cpp b/clang/lib/Format/TokenAnnotator.cpp index 4801d27b1395a..379d2011f4ebd 100644 --- a/clang/lib/Format/TokenAnnotator.cpp +++ b/clang/lib/Format/TokenAnnotator.cpp @@ -4513,16 +4513,9 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, return Left.is(tok::hash); if (Left.isOneOf(tok::hashhash, tok::hash)) return Right.is(tok::hash); - if (Left.is(BK_Block) && Right.is(tok::r_brace) && - Right.MatchingParen == &Left && Line.Children.empty()) { - return Style.SpaceInEmptyBlock; - } if (Style.SpacesInParens == FormatStyle::SIPO_Custom) { - if ((Left.is(tok::l_paren) && Right.is(tok::r_paren)) || - (Left.is(tok::l_brace) && Left.isNot(BK_Block) && - Right.is(tok::r_brace) && Right.isNot(BK_Block))) { + if (Left.is(tok::l_paren) && Right.is(tok::r_paren)) return Style.SpacesInParensOptions.InEmptyParentheses; - } if (Style.SpacesInParensOptions.ExceptDoubleParentheses && Left.is(tok::r_paren) && Right.is(tok::r_paren)) { auto *InnerLParen = Left.MatchingParen; @@ -4800,8 +4793,6 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, Right.is(TT_ArraySubscriptLSquare))) { return false; } - if (Left.is(tok::l_brace) && Right.is(tok::r_brace)) - return !Left.Children.empty(); // No spaces in "{}". if ((Left.is(tok::l_brace) && Left.isNot(BK_Block)) || (Right.is(tok::r_brace) && Right.MatchingParen && Right.MatchingParen->isNot(BK_Block))) { @@ -4983,6 +4974,22 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, if (Left.is(tok::star) && Right.is(tok::comment)) return true; + if (Left.is(tok::l_brace) && Right.is(tok::r_brace) && + Left.Children.empty()) { + switch (Style.SpaceInEmptyBraces) { + case FormatStyle::SIEB_Always: + return true; + case FormatStyle::SIEB_Block: + if (Left.is(BK_Block)) + return true; + [[fallthrough]]; + default: + return Style.Cpp11BracedListStyle && + Style.SpacesInParens == FormatStyle::SIPO_Custom && + Style.SpacesInParensOptions.InEmptyParentheses; + } + } + const auto *BeforeLeft = Left.Previous; if (IsCpp) { diff --git a/clang/lib/Format/UnwrappedLineFormatter.cpp b/clang/lib/Format/UnwrappedLineFormatter.cpp index 0adf7ee9ed543..c938ff3965f9e 100644 --- a/clang/lib/Format/UnwrappedLineFormatter.cpp +++ b/clang/lib/Format/UnwrappedLineFormatter.cpp @@ -864,7 +864,8 @@ class LineJoiner { if (ShouldMerge()) { // We merge empty blocks even if the line exceeds the column limit. Tok->SpacesRequiredBefore = - (Style.SpaceInEmptyBlock || Line.Last->is(tok::comment)) ? 1 : 0; + Style.SpaceInEmptyBraces != FormatStyle::SIEB_Never || + Line.Last->is(tok::comment); Tok->CanBreakBefore = true; return 1; } else if (Limit != 0 && !Line.startsWithNamespace() && diff --git a/clang/unittests/Format/ConfigParseTest.cpp b/clang/unittests/Format/ConfigParseTest.cpp index 9de3cca71630d..7c993c0f8fd33 100644 --- a/clang/unittests/Format/ConfigParseTest.cpp +++ b/clang/unittests/Format/ConfigParseTest.cpp @@ -200,7 +200,6 @@ TEST(ConfigParseTest, ParsesConfigurationBools) { CHECK_PARSE_BOOL(RemoveSemicolon); CHECK_PARSE_BOOL(SkipMacroDefinitionBody); CHECK_PARSE_BOOL(SpacesInSquareBrackets); - CHECK_PARSE_BOOL(SpaceInEmptyBlock); CHECK_PARSE_BOOL(SpacesInContainerLiterals); CHECK_PARSE_BOOL(SpaceAfterCStyleCast); CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); @@ -688,6 +687,17 @@ TEST(ConfigParseTest, ParsesConfiguration) { SpaceBeforeParens, FormatStyle::SBPO_ControlStatementsExceptControlMacros); + Style.SpaceInEmptyBraces = FormatStyle::SIEB_Never; + CHECK_PARSE("SpaceInEmptyBraces: Always", SpaceInEmptyBraces, + FormatStyle::SIEB_Always); + CHECK_PARSE("SpaceInEmptyBraces: Block", SpaceInEmptyBraces, + FormatStyle::SIEB_Block); + CHECK_PARSE("SpaceInEmptyBraces: Never", SpaceInEmptyBraces, + FormatStyle::SIEB_Never); + // For backward compatibility: + CHECK_PARSE("SpaceInEmptyBlock: true", SpaceInEmptyBraces, + FormatStyle::SIEB_Block); + // For backward compatibility: Style.SpacesInParens = FormatStyle::SIPO_Never; Style.SpacesInParensOptions = {}; diff --git a/clang/unittests/Format/FormatTest.cpp b/clang/unittests/Format/FormatTest.cpp index 96cc650f52a5d..8c0dbe08f6903 100644 --- a/clang/unittests/Format/FormatTest.cpp +++ b/clang/unittests/Format/FormatTest.cpp @@ -7055,7 +7055,7 @@ TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { verifyFormat("enum E {};"); verifyFormat("enum E {}"); FormatStyle Style = getLLVMStyle(); - Style.SpaceInEmptyBlock = true; + Style.SpaceInEmptyBraces = FormatStyle::SIEB_Block; verifyFormat("void f() { }", "void f() {}", Style); Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; verifyFormat("{ }", Style); @@ -7083,7 +7083,7 @@ TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { Style); Style = getLLVMStyle(FormatStyle::LK_CSharp); - Style.SpaceInEmptyBlock = true; + Style.SpaceInEmptyBraces = FormatStyle::SIEB_Block; verifyFormat("Event += () => { };", Style); } @@ -25584,6 +25584,27 @@ TEST_F(FormatTest, SpacesInConditionalStatement) { verifyFormat("MYIF( a )\n return;\nelse\n return;", Spaces); } +TEST_F(FormatTest, SpaceInEmptyBraces) { + constexpr StringRef Code("void f() {}\n" + "class Unit {};\n" + "int x{};"); + verifyFormat(Code); + + auto Style = getWebKitStyle(); + EXPECT_EQ(Style.SpaceInEmptyBraces, FormatStyle::SIEB_Always); + + verifyFormat("void f() { }\n" + "class Unit { };\n" + "int x { };", + Code, Style); + + Style.SpaceInEmptyBraces = FormatStyle::SIEB_Block; + verifyFormat("void f() { }\n" + "class Unit { };\n" + "int x {};", + Code, Style); +} + TEST_F(FormatTest, AlternativeOperators) { // Test case for ensuring alternate operators are not // combined with their right most neighbour. `````````` </details> https://github.com/llvm/llvm-project/pull/153765 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
