[clang-format] Add an option to put one constructor initializer per line

[owenpan]

Summary

See PR50549.

[MyDeveloperDay]

Seem similar to D90232: [clang-format] Formatting constructor initializer lists by putting them always on different lines (update to D14484) which seems to have got stalled

I sort of feel I prefer the design where we have an enum rather than introducing a separate option.

[MyDeveloperDay]

We already have

AllowAllConstructorInitializersOnNextLine and ConstructorInitializerAllOnOneLineOrOnePerLine

Sort of feels like we need to combine them with this,

I should also say I'd quite like this functionality, its just how do we deliver it via the options that I think we might want to think about, as I sort of feel the 3 options (if we introduced another) are competing with each other.

[HazardyKnusperkeks]

In D105099#2847328, @MyDeveloperDay wrote:

Seem similar to D90232: [clang-format] Formatting constructor initializer lists by putting them always on different lines (update to D14484) which seems to have got stalled

I sort of feel I prefer the design where we have an enum rather than introducing a separate option.

Yeah I thought, I already saw something like that.

I too think the way with the enum is a better one.

[curdeius]

Formatting part and tests look good to me, but I'd rather see this patch merge all related boolean options into one enum.
Just thinking out loud, but is it doable to merge AllowAllConstructorInitializersOnNextLine, ConstructorInitializerAllOnOneLineOrOnePerLine and this patch's ConstructorInitializerAlwaysOnePerLine into e.g. ConstructorInitializerStyle: AllowNextLine | NonBinPack==AllOnOneLineOrOnePerLine | OnePerLine. And one other enum value for the default case without special handling.
Of course, we'd need to keep that backward compatible.

[owenpan]

In D105099#2847332, @MyDeveloperDay wrote:

We already have

AllowAllConstructorInitializersOnNextLine and ConstructorInitializerAllOnOneLineOrOnePerLine

Sort of feels like we need to combine them with this,

I should also say I'd quite like this functionality, its just how do we deliver it via the options that I think we might want to think about, as I sort of feel the 3 options (if we introduced another) are competing with each other.

AllowAllConstructorInitializersOnNextLine is like a sub-option of ConstructorInitializerAllOnOneLineOrOnePerLine; it has no effect unless the latter is true. The new ConstructorInitializerAlwaysOnePerLine option, if set to true, overrides ConstructorInitializerAllOnOneLineOrOnePerLine as it should with Always. I think it would be contrived to combine these options in an enum. Is it even practical to do so without breaking the unit tests and backward compatibility?

[owenpan]

In D105099#2847933, @HazardyKnusperkeks wrote:

In D105099#2847328, @MyDeveloperDay wrote:

Seem similar to D90232: [clang-format] Formatting constructor initializer lists by putting them always on different lines (update to D14484) which seems to have got stalled

I sort of feel I prefer the design where we have an enum rather than introducing a separate option.

Yeah I thought, I already saw something like that.

I too think the way with the enum is a better one.

I was aware of that one. Didn't it get blocked because it failed the unit tests? Besides, it didn't handle the AfterColon case.

[owenpan]

In D105099#2848317, @curdeius wrote:

Formatting part and tests look good to me, but I'd rather see this patch merge all related boolean options into one enum.
Just thinking out loud, but is it doable to merge AllowAllConstructorInitializersOnNextLine, ConstructorInitializerAllOnOneLineOrOnePerLine and this patch's ConstructorInitializerAlwaysOnePerLine into e.g. ConstructorInitializerStyle: AllowNextLine | NonBinPack==AllOnOneLineOrOnePerLine | OnePerLine. And one other enum value for the default case without special handling.
Of course, we'd need to keep that backward compatible.

If we were to start this all over without the need of backward compatibility and the existence of the related unit tests, an enum might be a better option. Then I still think the user might have some trouble relating the following to the enum.

If AlwaysOnePerLine:
  Put each on its own line.
Else If AllOnOneLineOrOnePerline:
  If they all fit on one line:
    Put all of them on a single line.
  Else If AllOnNextLine:
    Put (the rest of) them on the next line.
  Else:
    Put each on its own line.
Else:
  ...

[curdeius]

In D105099#2848583, @owenpan wrote:

If we were to start this all over without the need of backward compatibility and the existence of the related unit tests, an enum might be a better option. Then I still think the user might have some trouble relating the following to the enum.

If AlwaysOnePerLine:
  Put each on its own line.
Else If AllOnOneLineOrOnePerline:
  If they all fit on one line:
    Put all of them on a single line.
  Else If AllOnNextLine:
    Put (the rest of) them on the next line.
  Else:
    Put each on its own line.
Else:
  ...

Is there anything else in the "Else:" part above? Is there an option that we forgot?

I'm not sure if I understand you correctly. Is your point that an enum option would be hard to find by the users?
But if the doc of each currently existing option pointed to this enum option it would be pretty easy, no?
Or does backward compatibility seem difficult to achieve? It should be a straightforward mapping.

Also, I find that having option that are mutually exclusive (or one that doesn't change anything when another is enabled) is a smell that tells us to use an enum.
Personally I find it harder to finder multiple options that concern the same aspect of the code style rather than a single option.

What I find problematic is clear and descriptive names for all options and possible values, but that's unrelated to whether it's a single enum option or several boolean options.
Having said that, I need to admit that ConstructorInitializerAllOnOneLineOrOnePerLine name makes my blood run cold :).

[MyDeveloperDay]

is a smell that tells us to use an enum.

I totally agree

Personally I find it harder to finder multiple options that concern the same aspect of the code style rather than a single option.

To be honest, I think we know the options some of the best (apart of course from @djasper and @klimek), and most of the time I'm totally confused, as to which options do which, it ends up being trail and error. This way bugs creep in.

Yes I feel that way too this should have been

ConstructorInitializer: Compact

or

ConstructorInitializer: OnePerLine

It would make it easier to add new behavior without over complicating things

[owenpan]

Else:
  ...

Is there anything else in the "Else:" part above? Is there an option that we forgot?

No, it's just what you called "one other enum value for the default case without special handling."

I'm not sure if I understand you correctly. Is your point that an enum option would be hard to find by the users?
But if the doc of each currently existing option pointed to this enum option it would be pretty easy, no?

An enum makes it easier for the user to find all related options, but my point is that in this case it would be harder for the user to relate the enum names to the behaviors because of the nested If.

Or does backward compatibility seem difficult to achieve? It should be a straightforward mapping.

Part of backward compatibility is not breaking/changing existing unit tests, which may be difficult to do.

Also, I find that having option that are mutually exclusive (or one that doesn't change anything when another is enabled) is a smell that tells us to use an enum.

You are not suggesting using two enums, one for the outer If and the other for the nested If, right?

If we didn't have AllOnOneLineOrOnePerLine, we could simply use an enum for ConstructorInitializer with three values:

• OnePerLine (i.e., AlwaysOnePerLine = true)
• BinPack (i.e., AllOnOneLineOrOnePerLine = OnNextLine = true)
• Neither (i.e., AlwaysOnePerLine = AllOnOneLineOrOnePerLine = false)

[owenpan]

In favor of https://reviews.llvm.org/D108752.

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: c++
     callFunction(a,
                  b,
                  c,
                  d);
 
 **AllowAllConstructorInitializersOnNextLine** (``bool``)
   If a constructor definition with a member initializer list doesn't
   fit on a single line, allow putting all member initializers onto the next
-  line, if ```ConstructorInitializerAllOnOneLineOrOnePerLine``` is true.
+  line, if ``ConstructorInitializerAllOnOneLineOrOnePerLine`` is true.
   Note that this parameter has no effect if
-  ```ConstructorInitializerAllOnOneLineOrOnePerLine``` is false.
+  ``ConstructorInitializerAllOnOneLineOrOnePerLine`` is false.
 
   .. code-block:: c++
 
     true:
     MyClass::MyClass() :
         member0(0), member1(2) {}
 
     false:
**CompactNamespaces** (``bool``)
 
   .. code-block:: c++
 
     namespace Foo { namespace Bar {
     namespace Extra {
     }}}
 
 **ConstructorInitializerAllOnOneLineOrOnePerLine** (``bool``)
-  If the constructor initializers don't fit on a line, put each
-  initializer on its own line.
+  If the constructor initializers don't fit on a line, put each initializer
+  on its own line.
+  Note that this parameter has no effect if
+  ``ConstructorInitializerAlwaysOnePerLine`` is true.
 
   .. code-block:: c++
 
     true:
     SomeClass::Constructor()
         : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
       return 0;
     }
 
     false:
     SomeClass::Constructor()
         : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa),
           aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
       return 0;
     }
 
+**ConstructorInitializerAlwaysOnePerLine** (``bool``)
+  Always put each constructor initializer on its own line.
+
+  .. code-block:: c++
+
+    true:
+    MyClass::MyClass() :
+        member0(0),
+        member1(2) {}
+
+    false:
+    MyClass::MyClass() :
+        member0(0), member1(2) {}
+
 **ConstructorInitializerIndentWidth** (``unsigned``)
   The number of characters to use for indentation of constructor
   initializer lists as well as inheritance lists.
 
 **ContinuationIndentWidth** (``unsigned``)
   Indent width for line continuations.
 
   .. code-block:: c++

clang/include/clang/Format/Format.h

struct FormatStyle {
   ///                b,
   ///                c,
   ///                d);
   /// \endcode
   bool AllowAllArgumentsOnNextLine;
 
   /// \brief If a constructor definition with a member initializer list doesn't
   /// fit on a single line, allow putting all member initializers onto the next
-  /// line, if ```ConstructorInitializerAllOnOneLineOrOnePerLine``` is true.
+  /// line, if ``ConstructorInitializerAllOnOneLineOrOnePerLine`` is true.
   /// Note that this parameter has no effect if
-  /// ```ConstructorInitializerAllOnOneLineOrOnePerLine``` is false.
+  /// ``ConstructorInitializerAllOnOneLineOrOnePerLine`` is false.
   /// \code
   ///   true:
   ///   MyClass::MyClass() :
   ///       member0(0), member1(2) {}
   ///
   ///   false:
   ///   MyClass::MyClass() :
   ///       member0(0),

   /// wrapped:
   /// \code
   ///   namespace Foo { namespace Bar {
   ///   namespace Extra {
   ///   }}}
   /// \endcode
   bool CompactNamespaces;
 
+  /// Always put each constructor initializer on its own line.
+  /// \code
+  ///   true:
+  ///   MyClass::MyClass() :
+  ///       member0(0),
+  ///       member1(2) {}
+  ///
+  ///   false:
+  ///   MyClass::MyClass() :
+  ///       member0(0), member1(2) {}
+  /// \endcode
+  bool ConstructorInitializerAlwaysOnePerLine;
+
   // clang-format off
-  /// If the constructor initializers don't fit on a line, put each
-  /// initializer on its own line.
+  /// If the constructor initializers don't fit on a line, put each initializer
+  /// on its own line.
+  /// Note that this parameter has no effect if
+  /// ``ConstructorInitializerAlwaysOnePerLine`` is true.
   /// \code
   ///   true:
   ///   SomeClass::Constructor()
   ///       : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
   ///     return 0;
   ///   }
   ///
   ///   false:
return AccessModifierOffset == R.AccessModifierOffset &&
            BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations &&
            BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
            BreakConstructorInitializers == R.BreakConstructorInitializers &&
            CompactNamespaces == R.CompactNamespaces &&
            BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations &&
            BreakStringLiterals == R.BreakStringLiterals &&
            ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas &&
            BreakInheritanceList == R.BreakInheritanceList &&
+           ConstructorInitializerAlwaysOnePerLine ==
+               R.ConstructorInitializerAlwaysOnePerLine &&
            ConstructorInitializerAllOnOneLineOrOnePerLine ==
                R.ConstructorInitializerAllOnOneLineOrOnePerLine &&
            ConstructorInitializerIndentWidth ==
                R.ConstructorInitializerIndentWidth &&
            ContinuationIndentWidth == R.ContinuationIndentWidth &&
            Cpp11BracedListStyle == R.Cpp11BracedListStyle &&
            DeriveLineEnding == R.DeriveLineEnding &&
            DerivePointerAlignment == R.DerivePointerAlignment &&

clang/lib/Format/Format.cpp

if (BreakConstructorInitializersBeforeComma &&
       Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
 
     IO.mapOptional("BreakAfterJavaFieldAnnotations",
                    Style.BreakAfterJavaFieldAnnotations);
     IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
     IO.mapOptional("ColumnLimit", Style.ColumnLimit);
     IO.mapOptional("CommentPragmas", Style.CommentPragmas);
     IO.mapOptional("CompactNamespaces", Style.CompactNamespaces);
+    IO.mapOptional("ConstructorInitializerAlwaysOnePerLine",
+                   Style.ConstructorInitializerAlwaysOnePerLine);
     IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
                    Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
     IO.mapOptional("ConstructorInitializerIndentWidth",
                    Style.ConstructorInitializerIndentWidth);
     IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
     IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
     IO.mapOptional("DeriveLineEnding", Style.DeriveLineEnding);
     IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
   LLVMStyle.BreakAfterJavaFieldAnnotations = false;
   LLVMStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
   LLVMStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
   LLVMStyle.BreakStringLiterals = true;
   LLVMStyle.ColumnLimit = 80;
   LLVMStyle.CommentPragmas = "^ IWYU pragma:";
   LLVMStyle.CompactNamespaces = false;
+  LLVMStyle.ConstructorInitializerAlwaysOnePerLine = false;
   LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
   LLVMStyle.ConstructorInitializerIndentWidth = 4;
   LLVMStyle.ContinuationIndentWidth = 4;
   LLVMStyle.Cpp11BracedListStyle = true;
   LLVMStyle.DeriveLineEnding = true;
   LLVMStyle.DerivePointerAlignment = false;
   LLVMStyle.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
   LLVMStyle.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;

clang/lib/Format/TokenAnnotator.cpp

if (Right.Previous->ClosesTemplateDeclaration &&
       Right.Previous->MatchingParen->NestingLevel == 0) {
     // Put concepts on the next line e.g.
     // template<typename T>
     // concept ...
     if (Right.is(tok::kw_concept))
       return Style.BreakBeforeConceptDeclarations;
     return (Style.AlwaysBreakTemplateDeclarations == FormatStyle::BTDS_Yes);
   }
-  if (Right.is(TT_CtorInitializerComma) &&
-      Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma &&
-      !Style.ConstructorInitializerAllOnOneLineOrOnePerLine)
+  if (Style.ConstructorInitializerAlwaysOnePerLine) {
+    if (Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeColon &&
+        (Left.is(TT_CtorInitializerComma) || Right.is(TT_CtorInitializerColon)))
       return true;
-  if (Right.is(TT_CtorInitializerColon) &&
+
+    if (Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon &&
+        Left.isOneOf(TT_CtorInitializerColon, TT_CtorInitializerComma))
+      return true;
+  }
+  if (Right.isOneOf(TT_CtorInitializerComma, TT_CtorInitializerColon) &&
       Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma &&
-      !Style.ConstructorInitializerAllOnOneLineOrOnePerLine)
+      (Style.ConstructorInitializerAlwaysOnePerLine ||
+       !Style.ConstructorInitializerAllOnOneLineOrOnePerLine))
     return true;
   // Break only if we have multiple inheritance.
   if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma &&
       Right.is(TT_InheritanceComma))
     return true;
   if (Style.BreakInheritanceList == FormatStyle::BILS_AfterComma &&
       Left.is(TT_InheritanceComma))
     return true;

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, ConstructorInitializers) {
   // lines, but that is not desirable.
   verifyFormat("Constructor()\n"
                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
 
   FormatStyle OnePerLine = getLLVMStyle();
   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
+
+  OnePerLine.ConstructorInitializerAlwaysOnePerLine = true;
+  verifyFormat("MyClass::MyClass()\n"
+               "    : a(a),\n"
+               "      b(b),\n"
+               "      c(c) {}",
+               OnePerLine);
+  verifyFormat("MyClass::MyClass()\n"
+               "    : a(a), // comment\n"
+               "      b(b),\n"
+               "      c(c) {}",
+               OnePerLine);
+  verifyFormat("MyClass::MyClass(int a)\n"
+               "    : b(a),      // comment\n"
+               "      c(a + 1) { // lined up\n"
+               "}",
+               OnePerLine);
+  verifyFormat("Constructor()\n"
+               "    : a(b, b, b) {}",
+               OnePerLine);
+  OnePerLine.ConstructorInitializerAlwaysOnePerLine = false;
+
   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
   verifyFormat("SomeClass::Constructor()\n"
                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
                OnePerLine);
   verifyFormat("SomeClass::Constructor()\n"
                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
   verifyFormat("Constructor() :\n"
                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
                Style);
 
   FormatStyle OnePerLine = Style;
   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
+
+  OnePerLine.ConstructorInitializerAlwaysOnePerLine = true;
+  verifyFormat("MyClass::MyClass() :\n"
+               "    a(a),\n"
+               "    b(b),\n"
+               "    c(c) {}",
+               OnePerLine);
+  verifyFormat("MyClass::MyClass() :\n"
+               "    a(a), // comment\n"
+               "    b(b),\n"
+               "    c(c) {}",
+               OnePerLine);
+  verifyFormat("MyClass::MyClass(int a) :\n"
+               "    b(a),      // comment\n"
+               "    c(a + 1) { // lined up\n"
+               "}",
+               OnePerLine);
+  verifyFormat("Constructor() :\n"
+               "    a(b, b, b) {}",
+               OnePerLine);
+  OnePerLine.ConstructorInitializerAlwaysOnePerLine = false;
+
   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
   verifyFormat("SomeClass::Constructor() :\n"
                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
                OnePerLine);
   verifyFormat("SomeClass::Constructor() :\n"
                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
TEST_F(FormatTest, ParsesConfigurationBools) {
   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
   CHECK_PARSE_BOOL(BinPackArguments);
   CHECK_PARSE_BOOL(BinPackParameters);
   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
   CHECK_PARSE_BOOL(BreakBeforeConceptDeclarations);
   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
   CHECK_PARSE_BOOL(BreakStringLiterals);
   CHECK_PARSE_BOOL(CompactNamespaces);
+  CHECK_PARSE_BOOL(ConstructorInitializerAlwaysOnePerLine);
   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
   CHECK_PARSE_BOOL(DeriveLineEnding);
   CHECK_PARSE_BOOL(DerivePointerAlignment);
   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
   CHECK_PARSE_BOOL(DisableFormat);
   CHECK_PARSE_BOOL(IndentAccessModifiers);
   CHECK_PARSE_BOOL(IndentCaseLabels);
   CHECK_PARSE_BOOL(IndentCaseBlocks);
TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
   verifyFormat("SomeClass::Constructor()\n"
                ": a(a)\n"
                ", b(b)\n"
                ", c(c) {}",
                Style);
 
   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
   Style.ConstructorInitializerIndentWidth = 4;
+
+  Style.ConstructorInitializerAlwaysOnePerLine = true;
+  Style.BreakBeforeBraces = FormatStyle::BS_Custom;
+  Style.BraceWrapping.AfterFunction = true;
+  Style.BraceWrapping.SplitEmptyFunction = false;
+  verifyFormat("MyClass::MyClass()\n"
+               "    : a(a)\n"
+               "    , b(b)\n"
+               "    , c(c)\n"
+               "{}",
+               Style);
+  verifyFormat("MyClass::MyClass()\n"
+               "    : a(a) // comment\n"
+               "    , b(b)\n"
+               "    , c(c)\n"
+               "{}",
+               Style);
+  verifyFormat("MyClass::MyClass(int a)\n"
+               "    : b(a)     // comment\n"
+               "    , c(a + 1) // lined up\n"
+               "{}",
+               Style);
+  verifyFormat("Constructor()\n"
+               "    : a(b, b, b)\n"
+               "{}",
+               Style);
+  Style.ConstructorInitializerAlwaysOnePerLine = false;
+  Style.BreakBeforeBraces = FormatStyle::BS_Attach;
+  Style.BraceWrapping.AfterFunction = false;
+  Style.BraceWrapping.SplitEmptyFunction = true;
+
   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
   verifyFormat(
       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
       Style);
   verifyFormat(
       "SomeClass::Constructor()\n"
       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
       Style);