[clang-format] Always break line after enum opening brace

[osandov]

Summary

clang-format currently puts the first enumerator on the same line as the
enum keyword and opening brace if it fits (for example, for anonymous
enums if IndentWidth is 8):

$ echo "enum { RED, GREEN, BLUE };" | clang-format -style="{BasedOnStyle: llvm, ColumnLimit: 15, IndentWidth: 8}"
enum { RED,
       GREEN,
       BLUE };

This doesn't seem to be intentional, as I can't find any style guide that
suggests wrapping enums this way. Always force the enumerator to be on a new
line, which gets us the desired result:

$ echo "enum { RED, GREEN, BLUE };" | ./bin/clang-format -style="{BasedOnStyle: llvm, ColumnLimit: 15, IndentWidth: 8}"
enum {
        RED,
        GREEN,
        BLUE
};

Test Plan:

New test added. Confirmed test failed without change and passed with change by
running:

$ ninja FormatTests && ./tools/clang/unittests/Format/FormatTests

[MyDeveloperDay]

Did you try:

BreakBeforeBraces: Custom
BraceWrapping:
  AfterEnum: true

with AfterEnum:true

$ clang-format enum.cpp
enum
{
  A,
};

enum
{
  B,
  C,
  D
};

enum
{
  E
};

with AfterEnum:false

$ clang-format enum.cpp
enum {
  A,
};

enum { B, C, D };

enum { E };

I believe example is not following the style of BraceWrapping.AfterEnum by virtue of the trailing ,

I think I'd expect the correct behaviour to be

enum { A, };

or

enum { 
   A, 
};

depending on that setting

[MyDeveloperDay]

I think what is interesting is

BreakBeforeBraces: Custom
BraceWrapping:
    AfterEnum: false

gets messed up completely by the , and that IS a bug in my view

$ clang-format enum.cpp
enum {
  A,
};

enum { B, C, D };

enum {
  B,
  C,
  D,
};

enum { E };

[osandov]

The style guide I'm following (the Linux kernel style) wants AfterEnum: false. A cursory search suggests that people treat this trailing comma behavior as a feature (https://stackoverflow.com/questions/23072223/clang-format-style-options-for-enums). However, I think this is separate from my issue. Consider the following example which doesn't have a trailing comma and doesn't fit on one line:

$ cat enum.cpp
enum { EOF, VOID, CHAR, SHORT, INT, LONG, SIGNED, UNSIGNED, BOOL, FLOAT, DOUBLE, COMPLEX, CONST, RESTRICT, VOLATILE, ATOMIC, STRUCT, UNION, ENUM, LPAREN, RPAREN, LBRACKET, RBRACKET, ASTERISK, DOT, NUMBER, IDENTIFIER };

The current code formats this very strangely:

$ clang-format -style="{BasedOnStyle: llvm, IndentWidth: 8}" enum.cpp            
enum { EOF,
       VOID,
       CHAR,
       SHORT,
       INT,
       LONG,
       SIGNED,
       UNSIGNED,
       BOOL,
       FLOAT,
       DOUBLE,
       COMPLEX,
       CONST,
       RESTRICT,
       VOLATILE,
       ATOMIC,
       STRUCT,
       UNION,
       ENUM,
       LPAREN,
       RPAREN,
       LBRACKET,
       RBRACKET,
       ASTERISK,
       DOT,
       NUMBER,
       IDENTIFIER };

With this change, I get what I expect:

$ ./bin/clang-format -style="{BasedOnStyle: llvm, IndentWidth: 8}" enum.cpp
enum {
        EOF,
        VOID,
        CHAR,
        SHORT,
        INT,
        LONG,
        SIGNED,
        UNSIGNED,
        BOOL,
        FLOAT,
        DOUBLE,
        COMPLEX,
        CONST,
        RESTRICT,
        VOLATILE,
        ATOMIC,
        STRUCT,
        UNION,
        ENUM,
        LPAREN,
        RPAREN,
        LBRACKET,
        RBRACKET,
        ASTERISK,
        DOT,
        NUMBER,
        IDENTIFIER
};

[MyDeveloperDay]

I understand now what you are trying to achieve, could you capture something more like that in your tests too.. (just so we don't break this change later)

[osandov]

Update summary and test case to better reflect the issue

[MyDeveloperDay]

LGTM

[osandov]

Thank you! I don't have commit access. How can I get this committed?

clang/lib/Format/ContinuationIndenter.cpp

if (startsSegmentOfBuilderTypeCall(Current) &&
     return true;
 
   // If the template declaration spans multiple lines, force wrap before the
   // function/class declaration
   if (Previous.ClosesTemplateDeclaration &&
       State.Stack.back().BreakBeforeParameter && Current.CanBreakBefore)
     return true;
 
-  if (State.Column <= NewLineColumn)
+  if (!State.Line->First->is(tok::kw_enum) && State.Column <= NewLineColumn)
     return false;
 
   if (Style.AlwaysBreakBeforeMultilineStrings &&
       (NewLineColumn == State.FirstIndent + Style.ContinuationIndentWidth ||
        Previous.is(tok::comma) || Current.NestingLevel < 2) &&
       !Previous.isOneOf(tok::kw_return, tok::lessless, tok::at,
                         Keywords.kw_dollar) &&
       !Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) &&

clang/unittests/Format/FormatTest.cpp

EXPECT_EQ("enum KeepEmptyLines {\n"
                    "\n"
                    "  THREE\n"
                    "}"));
   verifyFormat("enum E { // comment\n"
                "  ONE,\n"
                "  TWO\n"
                "};\n"
                "int i;");
+
+  FormatStyle EightIndent = getLLVMStyle();
+  EightIndent.IndentWidth = 8;
+  verifyFormat("enum {\n"
+               "        VOID,\n"
+               "        CHAR,\n"
+               "        SHORT,\n"
+               "        INT,\n"
+               "        LONG,\n"
+               "        SIGNED,\n"
+               "        UNSIGNED,\n"
+               "        BOOL,\n"
+               "        FLOAT,\n"
+               "        DOUBLE,\n"
+               "        COMPLEX\n"
+               "};",
+               EightIndent);
+
   // Not enums.
   verifyFormat("enum X f() {\n"
                "  a();\n"
                "  return 42;\n"
                "}");
   verifyFormat("enum X Type::f() {\n"
                "  a();\n"
                "  return 42;\n"