[clang-format] [PR41407] Constructor initializer list indented incorrectly

[MyDeveloperDay]

Summary

When using ConstructorInitializerIndentWidth with a value of 0, after the first initializer the members would be incorrectly indented

C++ code to be formatted:
Foo::Foo() :
foo(0),
bar(1) {
}

Incorrectly formatted to:
Foo::Foo() :
foo(0),

bar(1) {

}

This fix addresses this.

I also introduce the VERIFYFORMAT() macro into the tests to allow for the line number of the failure to be printed when the tests fail, when developing tests for this, I found it hard to locate the exact line each time, passing LINE down via the VERIFYFORMAT() macro means you get a clear indication of where its breaking (if someone know a non macro trick for doing this I'd be happy to know it)

Moving forward I'd like to use this in new tests

[owenpan]

I had already proposed a fix:
https://reviews.llvm.org/D60359

clang/lib/Format/ContinuationIndenter.cpp

unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
   if (NextNonComment->isOneOf(TT_CtorInitializerColon, TT_InheritanceColon,
                               TT_InheritanceComma))
     return State.FirstIndent + Style.ConstructorInitializerIndentWidth;
   if (Previous.is(tok::r_paren) && !Current.isBinaryOperator() &&
       !Current.isOneOf(tok::colon, tok::comment))
     return ContinuationIndent;
   if (Current.is(TT_ProtoExtensionLSquare))
     return State.Stack.back().Indent;
+  // If the previous token is a Constructor initializer comma, and the
+  // ConstructorInitializerIndentWidth is 0 then the Indent will equal the
+  // FirstIndent, and it would default to the ContinuationIndentWidth and not
+  // the ConstructorInitializerIndentWidth width.
+  if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment &&
+      PreviousNonComment->is(TT_CtorInitializerComma))
+    return State.FirstIndent + Style.ConstructorInitializerIndentWidth;
   if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment &&
       PreviousNonComment->isNot(tok::r_brace))
     // Ensure that we fall back to the continuation indent width instead of
     // just flushing continuations left.
     return State.Stack.back().Indent + Style.ContinuationIndentWidth;
   return State.Stack.back().Indent;
 }
 

clang/unittests/Format/FormatTest.cpp

FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
     return getStyleWithColumns(getLLVMStyle(), ColumnLimit);
   }
 
   FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
     return getStyleWithColumns(getGoogleStyle(), ColumnLimit);
   }
 
   void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code,
-                    const FormatStyle &Style = getLLVMStyle()) {
+                    const FormatStyle &Style = getLLVMStyle(),
+                    int line = __LINE__) {
     EXPECT_EQ(Expected.str(), format(Expected, Style))
-        << "Expected code is not stable";
-    EXPECT_EQ(Expected.str(), format(Code, Style));
+        << "Expected code is not stable on line " << line;
+    EXPECT_EQ(Expected.str(), format(Code, Style)) << " on line " << line;
     if (Style.Language == FormatStyle::LK_Cpp) {
       // Objective-C++ is a superset of C++, so everything checked for C++
       // needs to be checked for Objective-C++ as well.
       FormatStyle ObjCStyle = Style;
       ObjCStyle.Language = FormatStyle::LK_ObjC;
       EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
     }
   }
 
   void verifyFormat(llvm::StringRef Code,
                     const FormatStyle &Style = getLLVMStyle()) {
     verifyFormat(Code, test::messUp(Code), Style);
   }
 
+#define VERIFYFORMAT(code, style)                                              \
+  verifyFormat(code, test::messUp(code), style, __LINE__)
+
   void verifyIncompleteFormat(llvm::StringRef Code,
                               const FormatStyle &Style = getLLVMStyle()) {
     EXPECT_EQ(Code.str(),
               format(test::messUp(Code), Style, SC_ExpectIncomplete));
   }
 
   void verifyGoogleFormat(llvm::StringRef Code) {
     verifyFormat(Code, getGoogleStyle());
TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
   verifyFormat(
       "SomeLongTemplateVariableName<\n"
       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
       Style);
   verifyFormat(
       "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
       "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
       Style);
+
+  Style = getLLVMStyle();
+  Style.ColumnLimit = 0;
+  Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
+  Style.ConstructorInitializerIndentWidth = 2;
+  Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
+  Style.AllowAllConstructorInitializersOnNextLine = false;
+  VERIFYFORMAT("SomeClass::Constructor() :\n  a(a),\n  b(b),\n  c(c) {}",
+               Style);
+
+  Style.ConstructorInitializerIndentWidth = 1;
+  VERIFYFORMAT("SomeClass::Constructor() :\n a(a),\n b(b),\n c(c) {}", Style);
+
+  Style.ConstructorInitializerIndentWidth = 0;
+  VERIFYFORMAT("SomeClass::Constructor() :\na(a),\nb(b),\nc(c) {}", Style);
 }
 
 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
   FormatStyle Style = getLLVMStyle();
   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
   Style.ConstructorInitializerIndentWidth = 4;
   verifyFormat("SomeClass::Constructor()\n"
                "    : a(a)\n"