[clang-format] Allow empty loops on a single line.

[gedare]

Summary

Changes the AllowShortLoopsOnASingleLine from a boolean to a style option
consisting of three choices: Never, NonEmpty, and All. Never does not merge a
loop body back to the header's line. NonEmpty allows for merging a loop body
only if it has an expression. The new option is All, which will merge empty
loop bodies, i.e., a semi-colon.

The options of true and false are maintained for backward compatibility to mean
NonEmpty and Never, respectively.

See also Github Issue 61708.
https://github.com/llvm/llvm-project/issues/61708

[HazardyKnusperkeks]

clang/lib/Format/Format.cpp

595–599

[gedare]

Reorder traits and add comment about backward compatibility.

NOTE: Clang-Format Team Automated Review Comment

It looks like your clang-format review does not contain any unit tests, please try to ensure all code changes have a unit test (unless this is an NFC or refactoring, adding documentation etc..)

Add your unit tests in clang/unittests/Format and you can build with ninja FormatTests. We recommend using the verifyFormat(xxx) format of unit tests rather than EXPECT_EQ as this will ensure you change is tolerant to random whitespace changes (see FormatTest.cpp as an example)

For situations where your change is altering the TokenAnnotator.cpp which can happen if you are trying to improve the annotation phase to ensure we are correctly identifying the type of a token, please add a token annotator test in TokenAnnotatorTest.cpp

[gedare]

Regenerate complete diff

[HazardyKnusperkeks]

Please wait for other opinions.

[owenpan]

Like while (a);, while (a) {} is also an empty loop, so NonEmpty is misleading if it excludes the former but not the latter. IMO we should just fix the bug without extending the option because any loop with a single-statement body is a short loop.

clang/unittests/Format/FormatTest.cpp

1444–1467

There should be no spaces between ) and ;.

[gedare]

In D154550#4526386, @owenpan wrote:

Like while (a);, while (a) {} is also an empty loop, so NonEmpty is misleading if it excludes the former but not the latter. IMO we should just fix the bug without extending the option because any loop with a single-statement body is a short loop.

Agreed, except that many style guides (notably, K&R, LLVM, and Google) treat these two cases differently. The loop with only a semi-colon is a special case, and is what I'm looking to support. K&R defines the semi-colon terminated for/while loop as a body composed of a null statement. I believe that { } is instead an empty body, as it does not parse as a statement, despite generating identical code. Maybe`NonNullStatement` is precise and better than NonEmpty? I will prepare that change, and fix the spacing before the ;.

Whether someone thinks collapsing bracketed bodies that are short should be supported is a separate problem, and even if so, it would require a similar style option change as I suggest to allow for backward compatibility. I'm not personally interested in that case, as the code base I work with uses the isolated semicolon.

[gedare]

Change option name from NonEmpty to NonNullStatement. Fix space before semi.

[owenpan]

In D154550#4529346, @gedare wrote:

In D154550#4526386, @owenpan wrote:

Like while (a);, while (a) {} is also an empty loop, so NonEmpty is misleading if it excludes the former but not the latter. IMO we should just fix the bug without extending the option because any loop with a single-statement body is a short loop.

Agreed, except that many style guides (notably, K&R, LLVM, and Google) treat these two cases differently.

LLVM doesn't merge short loops. Google uses {} instead of ; whereas AFAIK K&R does the opposite. I don't know of any major style that requires breaking before the null statement and merging the empty block.

[gedare]

This comment was removed by gedare.

[gedare]

In D154550#4562061, @owenpan wrote:

In D154550#4529346, @gedare wrote:

In D154550#4526386, @owenpan wrote:

Like while (a);, while (a) {} is also an empty loop, so NonEmpty is misleading if it excludes the former but not the latter. IMO we should just fix the bug without extending the option because any loop with a single-statement body is a short loop.

Agreed, except that many style guides (notably, K&R, LLVM, and Google) treat these two cases differently.

LLVM doesn't merge short loops. Google uses {} instead of ; whereas AFAIK K&R does the opposite. I don't know of any major style that requires breaking before the null statement and merging the empty block.

Got it. I can prepare a change to merge null as a short loop. I will get back to this in a couple weeks.

[gedare]

This is not needed due to https://github.com/llvm/llvm-project/pull/70768

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: c++
 
       auto lambda = [](int a) {};
       auto lambda2 = [](int a) { return a; };
 
 
 
 .. _AllowShortLoopsOnASingleLine:
 
-**AllowShortLoopsOnASingleLine** (``Boolean``) :versionbadge:`clang-format 3.7` :ref:`¶ <AllowShortLoopsOnASingleLine>`
-  If ``true``, ``while (true) continue;`` can be put on a single
+**AllowShortLoopsOnASingleLine** (``ShortWhileForLoopStyle``) :versionbadge:`clang-format 3.7` :ref:`¶ <AllowShortLoopsOnASingleLine>`
+  Dependent on the value, ``while (true) ;`` can be put on a single
   line.
 
+  Possible values:
+
+  * ``SWFLS_Never`` (in configuration: ``Never``)
+    Never merge loops into a single line.
+
+  * ``SWFLS_NonEmpty`` (in configuration: ``NonEmpty``)
+    Only merge non-empty loops.
+
+    .. code-block:: c++
+
+      while (true) continue ;
+      while (true)
+          ;
+
+  * ``SWFLS_All`` (in configuration: ``All``)
+    Merge all loops fitting on a single line.
+
+    .. code-block:: c++
+
+      while (true) continue ;
+      while (true) ;
+
+
+
 .. _AlwaysBreakAfterDefinitionReturnType:
 
 **AlwaysBreakAfterDefinitionReturnType** (``DefinitionReturnTypeBreakingStyle``) :versionbadge:`clang-format 3.7` :ref:`¶ <AlwaysBreakAfterDefinitionReturnType>`
   The function definition return type breaking style to use.  This
   option is **deprecated** and is retained for backwards compatibility.
 
   Possible values:
 

clang/docs/ReleaseNotes.rst

- Add ``NextLineOnly`` style to option ``PackConstructorInitializers``.
   put the initializers on the current line first, instead, it will try to
   put the initializers on the next line only.
 - Add additional Qualifier Ordering support for special cases such
   as templates, requires clauses, long qualified names.
 - Fix all known issues associated with ``LambdaBodyIndentation: OuterScope``.
 - Add ``BracedInitializerIndentWidth`` which can be used to configure
   the indentation level of the contents of braced init lists.
 - Add ``KeepEmptyLinesAtEOF`` to keep empty lines at end of file.
+- Add style options ``Never``, ``NonEmpty``, and ``All`` to control the
+  behavior of ``AllowShortLoopsOnASingleLine`` when handling empty loop bodies.
+  These options only affect while and for loops.
 
 libclang
 --------
 
 - Introduced the new function ``clang_CXXMethod_isExplicit``,
   which identifies whether a constructor or conversion function cursor
   was marked with the explicit identifier.
 

clang/include/clang/Format/Format.h

enum ShortLambdaStyle : int8_t {
     SLS_All,
   };
 
   /// Dependent on the value, ``auto lambda []() { return 0; }`` can be put on a
   /// single line.
   /// \version 9
   ShortLambdaStyle AllowShortLambdasOnASingleLine;
 
-  /// If ``true``, ``while (true) continue;`` can be put on a single
+  /// Different styles for merging short while and for loops.
+  enum ShortWhileForLoopStyle : int8_t {
+    /// Never merge loops into a single line.
+    SWFLS_Never,
+    /// Only merge non-empty loops.
+    /// \code
+    ///   while (true) continue ;
+    ///   while (true)
+    ///       ;
+    /// \endcode
+    SWFLS_NonEmpty,
+    /// Merge all loops fitting on a single line.
+    /// \code
+    ///   while (true) continue ;
+    ///   while (true) ;
+    /// \endcode
+    SWFLS_All,
+  };
+
+  /// Dependent on the value, ``while (true) ;`` can be put on a single
   /// line.
   /// \version 3.7
-  bool AllowShortLoopsOnASingleLine;
+  ShortWhileForLoopStyle AllowShortLoopsOnASingleLine;
  
   /// Different ways to break after the function definition return type.
   /// This option is **deprecated** and is retained for backwards compatibility.
   enum DefinitionReturnTypeBreakingStyle : int8_t {
     /// Break after return type automatically.
     /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
     DRTBS_None,
     /// Always break after the return type.
     DRTBS_All,

clang/lib/Format/Format.cpp

static void enumeration(IO &IO, FormatStyle::ShortLambdaStyle &Value) {
     IO.enumCase(Value, "false", FormatStyle::SLS_None);
     IO.enumCase(Value, "Empty", FormatStyle::SLS_Empty);
     IO.enumCase(Value, "Inline", FormatStyle::SLS_Inline);
     IO.enumCase(Value, "All", FormatStyle::SLS_All);
     IO.enumCase(Value, "true", FormatStyle::SLS_All);
   }
 };
 
+template <> struct ScalarEnumerationTraits<FormatStyle::ShortWhileForLoopStyle> {
+  static void enumeration(IO &IO, FormatStyle::ShortWhileForLoopStyle &Value) {
+    IO.enumCase(Value, "Never", FormatStyle::SWFLS_Never);
+    IO.enumCase(Value, "NonEmpty", FormatStyle::SWFLS_NonEmpty);
+    IO.enumCase(Value, "All", FormatStyle::SWFLS_All);
+
+    // For backward compatibility.
+    IO.enumCase(Value, "false", FormatStyle::SWFLS_Never);
+    IO.enumCase(Value, "true", FormatStyle::SWFLS_NonEmpty);
+  }
+};
+
 template <> struct ScalarEnumerationTraits<FormatStyle::SortIncludesOptions> {
   static void enumeration(IO &IO, FormatStyle::SortIncludesOptions &Value) {
     IO.enumCase(Value, "Never", FormatStyle::SI_Never);
     IO.enumCase(Value, "CaseInsensitive", FormatStyle::SI_CaseInsensitive);
     IO.enumCase(Value, "CaseSensitive", FormatStyle::SI_CaseSensitive);
 
     // For backward compatibility.
     IO.enumCase(Value, "false", FormatStyle::SI_Never);
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.AllowAllArgumentsOnNextLine = true;
   LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
   LLVMStyle.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
   LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
   LLVMStyle.AllowShortEnumsOnASingleLine = true;
   LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
   LLVMStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
   LLVMStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
-  LLVMStyle.AllowShortLoopsOnASingleLine = false;
+  LLVMStyle.AllowShortLoopsOnASingleLine = FormatStyle::SWFLS_Never;
   LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
   LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
   LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
   LLVMStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_MultiLine;
   LLVMStyle.AttributeMacros.push_back("__capability");
   LLVMStyle.BitFieldColonSpacing = FormatStyle::BFCS_Both;
   LLVMStyle.BinPackArguments = true;
   LLVMStyle.BinPackParameters = true;
FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
   }
 
   FormatStyle GoogleStyle = getLLVMStyle(Language);
 
   GoogleStyle.AccessModifierOffset = -1;
   GoogleStyle.AlignEscapedNewlines = FormatStyle::ENAS_Left;
   GoogleStyle.AllowShortIfStatementsOnASingleLine =
       FormatStyle::SIS_WithoutElse;
-  GoogleStyle.AllowShortLoopsOnASingleLine = true;
+  GoogleStyle.AllowShortLoopsOnASingleLine = FormatStyle::SWFLS_NonEmpty;
   GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
   GoogleStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
   GoogleStyle.DerivePointerAlignment = true;
   GoogleStyle.IncludeStyle.IncludeCategories = {{"^<ext/.*\\.h>", 2, 0, false},
                                                 {"^<.*\\.h>", 1, 0, false},
                                                 {"^<.*", 2, 0, false},
                                                 {".*", 3, 0, false}};
   GoogleStyle.IncludeStyle.IncludeIsMainRegex = "([-_](test|unittest))?$";
ChromiumStyle.JavaImportGroups = {
         "com.google.android.apps.chrome",
         "org.chromium",
         "java",
         "javax",
     };
     ChromiumStyle.SortIncludes = FormatStyle::SI_CaseSensitive;
   } else if (Language == FormatStyle::LK_JavaScript) {
     ChromiumStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
-    ChromiumStyle.AllowShortLoopsOnASingleLine = false;
+    ChromiumStyle.AllowShortLoopsOnASingleLine = FormatStyle::SWFLS_Never;
   } else {
     ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
     ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
     ChromiumStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
-    ChromiumStyle.AllowShortLoopsOnASingleLine = false;
+    ChromiumStyle.AllowShortLoopsOnASingleLine = FormatStyle::SWFLS_Never;
     ChromiumStyle.BinPackParameters = false;
     ChromiumStyle.DerivePointerAlignment = false;
     if (Language == FormatStyle::LK_ObjC)
       ChromiumStyle.ColumnLimit = 80;
   }
   return ChromiumStyle;
 }
 
FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language) {
   Style.BraceWrapping.BeforeCatch = true;
   Style.BraceWrapping.BeforeElse = true;
   Style.BraceWrapping.BeforeWhile = false;
   Style.PenaltyReturnTypeOnItsOwnLine = 1000;
   Style.AllowShortEnumsOnASingleLine = false;
   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
   Style.AllowShortCaseLabelsOnASingleLine = false;
   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
-  Style.AllowShortLoopsOnASingleLine = false;
+  Style.AllowShortLoopsOnASingleLine = FormatStyle::SWFLS_Never;
   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
   return Style;
 }
 
 FormatStyle getNoStyle() {
   FormatStyle NoStyle = getLLVMStyle();
   NoStyle.DisableFormat = true;

clang/lib/Format/UnwrappedLineFormatter.cpp

if (!Line.First->is(tok::kw_do) && !Line.First->is(tok::kw_else) &&
         !Line.Last->is(tok::kw_else) && Line.Last->isNot(tok::r_paren)) {
       return 0;
     }
     // Only merge `do while` if `do` is the only statement on the line.
     if (Line.First->is(tok::kw_do) && !Line.Last->is(tok::kw_do))
       return 0;
     if (1 + I[1]->Last->TotalLength > Limit)
       return 0;
+    if (I[1]->First->is(tok::semi)) {
+      if (Line.First->isOneOf(tok::kw_for, tok::kw_while, TT_ForEachMacro) &&
+          Style.AllowShortLoopsOnASingleLine == FormatStyle::SWFLS_All) { 
+        return 1;
+      }
+      return 0;
+    }
     // Don't merge with loops, ifs, a single semicolon or a line comment.
-    if (I[1]->First->isOneOf(tok::semi, tok::kw_if, tok::kw_for, tok::kw_while,
+    if (I[1]->First->isOneOf(tok::kw_if, tok::kw_for, tok::kw_while,
                              TT_ForEachMacro, TT_LineComment)) {
       return 0;
     }
     // Only inline simple if's (no nested if or else), unless specified
     if (Style.AllowShortIfStatementsOnASingleLine ==
         FormatStyle::SIS_WithoutElse) {
       if (I + 2 != E && Line.startsWith(tok::kw_if) &&
           I[2]->First->is(tok::kw_else)) {

clang/unittests/Format/ConfigParseTest.cpp

 
 TEST(ConfigParseTest, ParsesConfigurationBools) {
   FormatStyle Style = {};
   Style.Language = FormatStyle::LK_Cpp;
   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
-  CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
   CHECK_PARSE_BOOL(BinPackArguments);
   CHECK_PARSE_BOOL(BinPackParameters);
   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
   CHECK_PARSE_BOOL(BreakStringLiterals);
   CHECK_PARSE_BOOL(CompactNamespaces);
   CHECK_PARSE_BOOL(DerivePointerAlignment);
   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
#undef CHECK_ALIGN_CONSECUTIVE
   CHECK_PARSE("AllowShortLambdasOnASingleLine: All",
               AllowShortLambdasOnASingleLine, FormatStyle::SLS_All);
   // For backward compatibility:
   CHECK_PARSE("AllowShortLambdasOnASingleLine: false",
               AllowShortLambdasOnASingleLine, FormatStyle::SLS_None);
   CHECK_PARSE("AllowShortLambdasOnASingleLine: true",
               AllowShortLambdasOnASingleLine, FormatStyle::SLS_All);
 
+  Style.AllowShortLoopsOnASingleLine = FormatStyle::SWFLS_All;
+  CHECK_PARSE("AllowShortLoopsOnASingleLine: Never",
+              AllowShortLoopsOnASingleLine, FormatStyle::SWFLS_Never);
+  CHECK_PARSE("AllowShortLoopsOnASingleLine: NonEmpty",
+              AllowShortLoopsOnASingleLine, FormatStyle::SWFLS_NonEmpty);
+  CHECK_PARSE("AllowShortLoopsOnASingleLine: All",
+              AllowShortLoopsOnASingleLine, FormatStyle::SWFLS_All);
+  // For backward compatibility:
+  CHECK_PARSE("AllowShortLoopsOnASingleLine: false",
+              AllowShortLoopsOnASingleLine, FormatStyle::SWFLS_Never);
+  CHECK_PARSE("AllowShortLoopsOnASingleLine: true",
+              AllowShortLoopsOnASingleLine, FormatStyle::SWFLS_NonEmpty);
+
   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Both;
   CHECK_PARSE("SpaceAroundPointerQualifiers: Default",
               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Default);
   CHECK_PARSE("SpaceAroundPointerQualifiers: Before",
               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Before);
   CHECK_PARSE("SpaceAroundPointerQualifiers: After",
               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_After);
   CHECK_PARSE("SpaceAroundPointerQualifiers: Both",

clang/unittests/Format/FormatTest.cpp

verifyFormat("MYIF (a) {\n"
                "} else {\n"
                "  g();\n"
                "}",
                AllowsMergedIf);
 }
 
 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
   FormatStyle AllowsMergedLoops = getLLVMStyle();
-  AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
+  AllowsMergedLoops.AllowShortLoopsOnASingleLine = FormatStyle::SWFLS_NonEmpty;
   verifyFormat("while (true) continue;", AllowsMergedLoops);
   verifyFormat("for (;;) continue;", AllowsMergedLoops);
   verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
   verifyFormat("BOOST_FOREACH (int &v, vec) v *= 2;", AllowsMergedLoops);
   verifyFormat("while (true)\n"
                "  ;",
                AllowsMergedLoops);
   verifyFormat("for (;;)\n"
TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
   // Without braces labels are interpreted differently.
   verifyFormat("{\n"
                "  do\n"
                "  label:\n"
                "    a++;\n"
                "  while (true);\n"
                "}",
                AllowsMergedLoops);
+  AllowsMergedLoops.AllowShortLoopsOnASingleLine = FormatStyle::SWFLS_All;
+  verifyFormat("while (true) continue;", AllowsMergedLoops);
+  verifyFormat("for (;;) continue;", AllowsMergedLoops);
+  verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
+  verifyFormat("BOOST_FOREACH (int &v, vec) v *= 2;", AllowsMergedLoops);
+  verifyFormat("while (true) ;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;) ;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;)\n"
+               "  for (;;) continue;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;)\n"
+               "  for (;;) ;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;)\n"
+               "  while (true) ;",
+               AllowsMergedLoops);
+  verifyFormat("while (true)\n"
+               "  for (;;) continue;",
+               AllowsMergedLoops);
+  verifyFormat("while (true)\n"
+               "  for (;;) ;",
+               AllowsMergedLoops);
+  verifyFormat("BOOST_FOREACH (int &v, vec)\n"
+               "  for (;;) ;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;)\n"
+               "  BOOST_FOREACH (int &v, vec) ;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;) // Can't merge this\n"
+               "  ;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;) /* still don't merge */\n"
+               "  ;",
+               AllowsMergedLoops);
+  verifyFormat("do a++;\n"
+               "while (true);",
+               AllowsMergedLoops);
+  verifyFormat("do /* Don't merge */\n"
+               "  a++;\n"
+               "while (true);",
+               AllowsMergedLoops);
+  verifyFormat("do // Don't merge\n"
+               "  a++;\n"
+               "while (true);",
+               AllowsMergedLoops);
+  verifyFormat("do\n"
+               "  // Don't merge\n"
+               "  a++;\n"
+               "while (true);",
+               AllowsMergedLoops);
+  // Without braces labels are interpreted differently.
+  verifyFormat("{\n"
+               "  do\n"
+               "  label:\n"
+               "    a++;\n"
+               "  while (true);\n"
+               "}",
+               AllowsMergedLoops);
 }
 
 TEST_F(FormatTest, FormatShortBracedStatements) {
   FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
   EXPECT_EQ(AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine, false);
   EXPECT_EQ(AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine,
             FormatStyle::SIS_Never);
-  EXPECT_EQ(AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine, false);
+  EXPECT_EQ(AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine,
+            FormatStyle::SWFLS_Never);
   EXPECT_EQ(AllowSimpleBracedStatements.BraceWrapping.AfterFunction, false);
   verifyFormat("for (;;) {\n"
                "  f();\n"
                "}");
   verifyFormat("/*comment*/ for (;;) {\n"
                "  f();\n"
                "}");
   verifyFormat("BOOST_FOREACH (int v, vec) {\n"
TEST_F(FormatTest, FormatShortBracedStatements) {
 
   AllowSimpleBracedStatements.IfMacros.push_back("MYIF");
   // Where line-lengths matter, a 2-letter synonym that maintains line length.
   // Not IF to avoid any confusion that IF is somehow special.
   AllowSimpleBracedStatements.IfMacros.push_back("FI");
   AllowSimpleBracedStatements.ColumnLimit = 40;
   AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine =
       FormatStyle::SBS_Always;
-  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
+  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine =
+      FormatStyle::SWFLS_NonEmpty;
   AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
   AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
   AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
 
   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
   verifyFormat("if consteval {}", AllowSimpleBracedStatements);
verifyFormat("MYIF (true) {\n"
                AllowSimpleBracedStatements);
   verifyFormat("MYIF (true) {\n"
                "  f();\n"
                "} else {\n"
                "  f();\n"
                "}",
                AllowSimpleBracedStatements);
 
-  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
+  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine =
+      FormatStyle::SWFLS_Never;
   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
   verifyFormat("while (true) {\n"
                "  f();\n"
                "}",
                AllowSimpleBracedStatements);
   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
   verifyFormat("for (;;) {\n"
                "  f();\n"
                "}",
                AllowSimpleBracedStatements);
   verifyFormat("BOOST_FOREACH (int v, vec) {}", AllowSimpleBracedStatements);
   verifyFormat("BOOST_FOREACH (int v, vec) {\n"
                "  f();\n"
                "}",
                AllowSimpleBracedStatements);
 
   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
       FormatStyle::SIS_WithoutElse;
-  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
+  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine =
+      FormatStyle::SWFLS_NonEmpty;
   AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement =
       FormatStyle::BWACS_Always;
 
   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
   verifyFormat("MYIF (true) {}", AllowSimpleBracedStatements);
   verifyFormat("MYIF constexpr (true) {}", AllowSimpleBracedStatements);
verifyFormat("MYIF (true)\n"
                "{\n"
                "  f();\n"
                "} else\n"
                "{\n"
                "  f();\n"
                "}",
                AllowSimpleBracedStatements);
 
-  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
+  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine =
+    FormatStyle::SWFLS_Never;
   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
   verifyFormat("while (true)\n"
                "{\n"
                "  f();\n"
                "}",
                AllowSimpleBracedStatements);
   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
   verifyFormat("for (;;)\n"
verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
   verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
                "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
 }
 
 TEST_F(FormatTest, ForEachLoops) {
   FormatStyle Style = getLLVMStyle();
   EXPECT_EQ(Style.AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
-  EXPECT_EQ(Style.AllowShortLoopsOnASingleLine, false);
+  EXPECT_EQ(Style.AllowShortLoopsOnASingleLine, FormatStyle::SWFLS_Never);
   verifyFormat("void f() {\n"
                "  for (;;) {\n"
                "  }\n"
                "  foreach (Item *item, itemlist) {\n"
                "  }\n"
                "  Q_FOREACH (Item *item, itemlist) {\n"
                "  }\n"
                "  BOOST_FOREACH (Item *item, itemlist) {\n"
verifyFormat("void f() {\n"
                "  Q_FOREACH (int v, vec) {\n"
                "    v *= 2;\n"
                "  }\n"
                "}",
                Style);
 
   FormatStyle ShortBlocks = getLLVMStyle();
   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
-  EXPECT_EQ(ShortBlocks.AllowShortLoopsOnASingleLine, false);
+  EXPECT_EQ(ShortBlocks.AllowShortLoopsOnASingleLine, FormatStyle::SWFLS_Never);
   verifyFormat("void f() {\n"
                "  for (;;)\n"
                "    int j = 1;\n"
                "  Q_FOREACH (int &v, vec)\n"
                "    v *= 2;\n"
                "  for (;;) {\n"
                "    int j = 1;\n"
                "  }\n"
                "  Q_FOREACH (int &v, vec) {\n"
                "    int j = 1;\n"
                "  }\n"
                "}",
                ShortBlocks);
 
   FormatStyle ShortLoops = getLLVMStyle();
-  ShortLoops.AllowShortLoopsOnASingleLine = true;
+  ShortLoops.AllowShortLoopsOnASingleLine = FormatStyle::SWFLS_NonEmpty;
   EXPECT_EQ(ShortLoops.AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
   verifyFormat("void f() {\n"
                "  for (;;) int j = 1;\n"
                "  Q_FOREACH (int &v, vec) int j = 1;\n"
                "  for (;;) {\n"
                "    int j = 1;\n"
                "  }\n"
                "  Q_FOREACH (int &v, vec) {\n"
                "    int j = 1;\n"
                "  }\n"
                "}",
                ShortLoops);
 
   FormatStyle ShortBlocksAndLoops = getLLVMStyle();
   ShortBlocksAndLoops.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
-  ShortBlocksAndLoops.AllowShortLoopsOnASingleLine = true;
+  ShortBlocksAndLoops.AllowShortLoopsOnASingleLine = FormatStyle::SWFLS_NonEmpty;
   verifyFormat("void f() {\n"
                "  for (;;) int j = 1;\n"
                "  Q_FOREACH (int &v, vec) int j = 1;\n"
                "  for (;;) { int j = 1; }\n"
                "  Q_FOREACH (int &v, vec) { int j = 1; }\n"
                "}",
                ShortBlocksAndLoops);
 
TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
   SpaceIfMacros.SpaceBeforeParensOptions.AfterIfMacros = true;
   verifyFormat("MYIF (a)\n  return;", SpaceIfMacros);
   verifyFormat("MYIF (a)\n  return;\nelse MYIF (b)\n  return;", SpaceIfMacros);
   verifyFormat("MYIF (a)\n  return;\nelse\n  return;", SpaceIfMacros);
 
   FormatStyle SpaceForeachMacros = getLLVMStyle();
   EXPECT_EQ(SpaceForeachMacros.AllowShortBlocksOnASingleLine,
             FormatStyle::SBS_Never);
-  EXPECT_EQ(SpaceForeachMacros.AllowShortLoopsOnASingleLine, false);
+  EXPECT_EQ(SpaceForeachMacros.AllowShortLoopsOnASingleLine,
+            FormatStyle::SWFLS_Never);
   SpaceForeachMacros.SpaceBeforeParens = FormatStyle::SBPO_Custom;
   SpaceForeachMacros.SpaceBeforeParensOptions.AfterForeachMacros = true;
   verifyFormat("for (;;) {\n"
                "}",
                SpaceForeachMacros);
   verifyFormat("foreach (Item *item, itemlist) {\n"
                "}",
                SpaceForeachMacros);
verifyFormat("void f()\n"
                "  int i;\n"
                "}",
                AllmanBraceStyle);
   AllmanBraceStyle.ColumnLimit = 80;
 
   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
       FormatStyle::SIS_WithoutElse;
-  BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
+  BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine =
+      FormatStyle::SWFLS_NonEmpty;
   verifyFormat("void f(bool b)\n"
                "{\n"
                "  if (b)\n"
                "  {\n"
                "    return;\n"
                "  }\n"
                "}\n",
                BreakBeforeBraceShortIfs);
verifyFormat("int f()\n"
                "  { // comment\n"
                "  return 42;\n"
                "  }",
                WhitesmithsBraceStyle);
 
   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
       FormatStyle::SIS_OnlyFirstIf;
-  BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
+  BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine =
+      FormatStyle::SWFLS_NonEmpty;
   verifyFormat("void f(bool b)\n"
                "  {\n"
                "  if (b)\n"
                "    {\n"
                "    return;\n"
                "    }\n"
                "  }\n",
                BreakBeforeBraceShortIfs);