diff --git a/clang/docs/ClangFormatStyleOptions.rst b/clang/docs/ClangFormatStyleOptions.rst --- a/clang/docs/ClangFormatStyleOptions.rst +++ b/clang/docs/ClangFormatStyleOptions.rst @@ -646,22 +646,8 @@ 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. - Note that this parameter has no effect if - ```ConstructorInitializerAllOnOneLineOrOnePerLine``` is false. - - .. code-block:: c++ - - true: - MyClass::MyClass() : - member0(0), member1(2) {} - - false: - MyClass::MyClass() : - member0(0), - member1(2) {} + This option is **deprecated**. See ``NextLine`` of + ``PackConstructorInitializers``. **AllowAllParametersOfDeclarationOnNextLine** (``bool``) If the function declaration doesn't fit on a line, @@ -2002,7 +1988,7 @@ SecondValueVeryVeryVeryVeryLong; **BreakConstructorInitializers** (``BreakConstructorInitializersStyle``) - The constructor initializers style to use. + The break constructor initializers style to use. Possible values: @@ -2140,23 +2126,8 @@ }}} **ConstructorInitializerAllOnOneLineOrOnePerLine** (``bool``) - If the constructor initializers don't fit on a line, put each - initializer on its own line. - - .. 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; - } + This option is **deprecated**. See ``CurrentLine`` of + ``PackConstructorInitializers``. **ConstructorInitializerIndentWidth** (``unsigned``) The number of characters to use for indentation of constructor @@ -3143,6 +3114,60 @@ # define BAR #endif +**PackConstructorInitializers** (``PackConstructorInitializersStyle``) + The pack constructor initializers style to use. + + Possible values: + + * ``PCIS_Never`` (in configuration: ``Never``) + Always put each constructor initializer on its own line. + + .. code-block:: c++ + + Constructor() + : a(), + b() + + * ``PCIS_BinPack`` (in configuration: ``BinPack``) + Bin-pack constructor initializers. + + .. code-block:: c++ + + Constructor() + : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), + cccccccccccccccccccc() + + * ``PCIS_CurrentLine`` (in configuration: ``CurrentLine``) + Put all constructor initializers on the current line if they fit. + Otherwise, put each one on its own line. + + .. code-block:: c++ + + Constructor() : a(), b() + + Constructor() + : aaaaaaaaaaaaaaaaaaaa(), + bbbbbbbbbbbbbbbbbbbb(), + ddddddddddddd() + + * ``PCIS_NextLine`` (in configuration: ``NextLine``) + Same as ``PCIS_CurrentLine`` except that if all constructor initializers + do not fit on the current line, try to fit them on the next line. + + .. code-block:: c++ + + Constructor() : a(), b() + + Constructor() + : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd() + + Constructor() + : aaaaaaaaaaaaaaaaaaaa(), + bbbbbbbbbbbbbbbbbbbb(), + cccccccccccccccccccc() + + + **PenaltyBreakAssignment** (``unsigned``) The penalty for breaking around an assignment operator. diff --git a/clang/include/clang/Format/Format.h b/clang/include/clang/Format/Format.h --- a/clang/include/clang/Format/Format.h +++ b/clang/include/clang/Format/Format.h @@ -505,20 +505,8 @@ /// \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. - /// Note that this parameter has no effect if - /// ```ConstructorInitializerAllOnOneLineOrOnePerLine``` is false. - /// \code - /// true: - /// MyClass::MyClass() : - /// member0(0), member1(2) {} - /// - /// false: - /// MyClass::MyClass() : - /// member0(0), - /// member1(2) {} + /// This option is **deprecated**. See ``NextLine`` of + /// ``PackConstructorInitializers``. bool AllowAllConstructorInitializersOnNextLine; /// If the function declaration doesn't fit on a line, @@ -1790,7 +1778,7 @@ BCIS_AfterColon }; - /// The constructor initializers style to use. + /// The break constructor initializers style to use. BreakConstructorInitializersStyle BreakConstructorInitializers; /// Break after each annotation on a field in Java files. @@ -1893,25 +1881,9 @@ /// \endcode bool CompactNamespaces; - // clang-format off - /// If the constructor initializers don't fit on a line, put each - /// initializer on its own line. - /// \code - /// true: - /// SomeClass::Constructor() - /// : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) { - /// return 0; - /// } - /// - /// false: - /// SomeClass::Constructor() - /// : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), - /// aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) { - /// return 0; - /// } - /// \endcode + /// This option is **deprecated**. See ``CurrentLine`` of + /// ``PackConstructorInitializers``. bool ConstructorInitializerAllOnOneLineOrOnePerLine; - // clang-format on /// The number of characters to use for indentation of constructor /// initializer lists as well as inheritance lists. @@ -2087,6 +2059,52 @@ /// not use this in config files, etc. Use at your own risk. bool ExperimentalAutoDetectBinPacking; + /// Different ways to try to fit all constructor initializers on a line. + enum PackConstructorInitializersStyle : unsigned char { + /// Always put each constructor initializer on its own line. + /// \code + /// Constructor() + /// : a(), + /// b() + /// \endcode + PCIS_Never, + /// Bin-pack constructor initializers. + /// \code + /// Constructor() + /// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), + /// cccccccccccccccccccc() + /// \endcode + PCIS_BinPack, + /// Put all constructor initializers on the current line if they fit. + /// Otherwise, put each one on its own line. + /// \code + /// Constructor() : a(), b() + /// + /// Constructor() + /// : aaaaaaaaaaaaaaaaaaaa(), + /// bbbbbbbbbbbbbbbbbbbb(), + /// ddddddddddddd() + /// \endcode + PCIS_CurrentLine, + /// Same as ``PCIS_CurrentLine`` except that if all constructor initializers + /// do not fit on the current line, try to fit them on the next line. + /// \code + /// Constructor() : a(), b() + /// + /// Constructor() + /// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd() + /// + /// Constructor() + /// : aaaaaaaaaaaaaaaaaaaa(), + /// bbbbbbbbbbbbbbbbbbbb(), + /// cccccccccccccccccccc() + /// \endcode + PCIS_NextLine, + }; + + /// The pack constructor initializers style to use. + PackConstructorInitializersStyle PackConstructorInitializers; + /// If ``true``, clang-format adds missing namespace end comments for /// short namespaces and fixes invalid existing ones. Short ones are /// controlled by "ShortNamespaceLines". @@ -3083,7 +3101,7 @@ /// ForEach and If macros. This is useful in projects where ForEach/If /// macros are treated as function calls instead of control statements. /// ``SBPO_ControlStatementsExceptForEachMacros`` remains an alias for - /// backward compatability. + /// backward compatibility. /// \code /// void f() { /// Q_FOREACH(...) { @@ -3391,8 +3409,6 @@ AlignOperands == R.AlignOperands && AlignTrailingComments == R.AlignTrailingComments && AllowAllArgumentsOnNextLine == R.AllowAllArgumentsOnNextLine && - AllowAllConstructorInitializersOnNextLine == - R.AllowAllConstructorInitializersOnNextLine && AllowAllParametersOfDeclarationOnNextLine == R.AllowAllParametersOfDeclarationOnNextLine && AllowShortEnumsOnASingleLine == R.AllowShortEnumsOnASingleLine && @@ -3423,8 +3439,6 @@ BreakStringLiterals == R.BreakStringLiterals && ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas && BreakInheritanceList == R.BreakInheritanceList && - ConstructorInitializerAllOnOneLineOrOnePerLine == - R.ConstructorInitializerAllOnOneLineOrOnePerLine && ConstructorInitializerIndentWidth == R.ConstructorInitializerIndentWidth && ContinuationIndentWidth == R.ContinuationIndentWidth && @@ -3436,6 +3450,7 @@ EmptyLineBeforeAccessModifier == R.EmptyLineBeforeAccessModifier && ExperimentalAutoDetectBinPacking == R.ExperimentalAutoDetectBinPacking && + PackConstructorInitializers == R.PackConstructorInitializers && FixNamespaceComments == R.FixNamespaceComments && ForEachMacros == R.ForEachMacros && IncludeStyle.IncludeBlocks == R.IncludeStyle.IncludeBlocks && diff --git a/clang/lib/Format/ContinuationIndenter.cpp b/clang/lib/Format/ContinuationIndenter.cpp --- a/clang/lib/Format/ContinuationIndenter.cpp +++ b/clang/lib/Format/ContinuationIndenter.cpp @@ -958,7 +958,7 @@ State.Line->MustBeDeclaration) || (!Style.AllowAllArgumentsOnNextLine && !State.Line->MustBeDeclaration) || - (!Style.AllowAllConstructorInitializersOnNextLine && + (Style.PackConstructorInitializers != FormatStyle::PCIS_NextLine && PreviousIsBreakingCtorInitializerColon) || Previous.is(TT_DictLiteral)) State.Stack.back().BreakBeforeParameter = true; @@ -967,7 +967,7 @@ // and we allow all arguments on the next line, we should not break // before the next parameter. if (PreviousIsBreakingCtorInitializerColon && - Style.AllowAllConstructorInitializersOnNextLine) + Style.PackConstructorInitializers == FormatStyle::PCIS_NextLine) State.Stack.back().BreakBeforeParameter = false; } @@ -1247,10 +1247,10 @@ ? 0 : 2); State.Stack.back().NestedBlockIndent = State.Stack.back().Indent; - if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine) { + if (Style.PackConstructorInitializers > FormatStyle::PCIS_BinPack) { State.Stack.back().AvoidBinPacking = true; State.Stack.back().BreakBeforeParameter = - !Style.AllowAllConstructorInitializersOnNextLine; + Style.PackConstructorInitializers != FormatStyle::PCIS_NextLine; } else { State.Stack.back().BreakBeforeParameter = false; } @@ -1260,7 +1260,7 @@ State.Stack.back().Indent = State.FirstIndent + Style.ConstructorInitializerIndentWidth; State.Stack.back().NestedBlockIndent = State.Stack.back().Indent; - if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine) + if (Style.PackConstructorInitializers > FormatStyle::PCIS_BinPack) State.Stack.back().AvoidBinPacking = true; } if (Current.is(TT_InheritanceColon)) diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp --- a/clang/lib/Format/Format.cpp +++ b/clang/lib/Format/Format.cpp @@ -264,6 +264,17 @@ } }; +template <> +struct ScalarEnumerationTraits { + static void + enumeration(IO &IO, FormatStyle::PackConstructorInitializersStyle &Value) { + IO.enumCase(Value, "Never", FormatStyle::PCIS_Never); + IO.enumCase(Value, "BinPack", FormatStyle::PCIS_BinPack); + IO.enumCase(Value, "CurrentLine", FormatStyle::PCIS_CurrentLine); + IO.enumCase(Value, "NextLine", FormatStyle::PCIS_NextLine); + } +}; + template <> struct ScalarEnumerationTraits { static void @@ -552,8 +563,6 @@ IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments); IO.mapOptional("AllowAllArgumentsOnNextLine", Style.AllowAllArgumentsOnNextLine); - IO.mapOptional("AllowAllConstructorInitializersOnNextLine", - Style.AllowAllConstructorInitializersOnNextLine); IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine", Style.AllowAllParametersOfDeclarationOnNextLine); IO.mapOptional("AllowShortEnumsOnASingleLine", @@ -633,8 +642,6 @@ IO.mapOptional("ColumnLimit", Style.ColumnLimit); IO.mapOptional("CommentPragmas", Style.CommentPragmas); IO.mapOptional("CompactNamespaces", Style.CompactNamespaces); - IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine", - Style.ConstructorInitializerAllOnOneLineOrOnePerLine); IO.mapOptional("ConstructorInitializerIndentWidth", Style.ConstructorInitializerIndentWidth); IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth); @@ -648,6 +655,32 @@ Style.EmptyLineBeforeAccessModifier); IO.mapOptional("ExperimentalAutoDetectBinPacking", Style.ExperimentalAutoDetectBinPacking); + + IO.mapOptional("PackConstructorInitializers", + Style.PackConstructorInitializers); + // For backward compatibility. + StringRef BasedOn; + IO.mapOptional("BasedOnStyle", BasedOn); + const bool IsGoogleOrChromium = BasedOn.equals_insensitive("google") || + BasedOn.equals_insensitive("chromium"); + bool OnCurrentLine = IsGoogleOrChromium; + bool OnNextLine = IsGoogleOrChromium; + IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine", + OnCurrentLine); + IO.mapOptional("AllowAllConstructorInitializersOnNextLine", OnNextLine); + if (IsGoogleOrChromium && + Style.PackConstructorInitializers == FormatStyle::PCIS_NextLine) { + if (!OnCurrentLine) + Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack; + else if (!OnNextLine) + Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; + } else if (Style.PackConstructorInitializers == FormatStyle::PCIS_BinPack && + OnCurrentLine) { + Style.PackConstructorInitializers = OnNextLine + ? FormatStyle::PCIS_NextLine + : FormatStyle::PCIS_CurrentLine; + } + IO.mapOptional("FixNamespaceComments", Style.FixNamespaceComments); IO.mapOptional("ForEachMacros", Style.ForEachMacros); IO.mapOptional("IfMacros", Style.IfMacros); @@ -988,7 +1021,6 @@ LLVMStyle.AlignConsecutiveDeclarations = FormatStyle::ACS_None; LLVMStyle.AlignConsecutiveMacros = FormatStyle::ACS_None; LLVMStyle.AllowAllArgumentsOnNextLine = true; - LLVMStyle.AllowAllConstructorInitializersOnNextLine = true; LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true; LLVMStyle.AllowShortEnumsOnASingleLine = true; LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; @@ -1034,7 +1066,6 @@ LLVMStyle.ColumnLimit = 80; LLVMStyle.CommentPragmas = "^ IWYU pragma:"; LLVMStyle.CompactNamespaces = false; - LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false; LLVMStyle.ConstructorInitializerIndentWidth = 4; LLVMStyle.ContinuationIndentWidth = 4; LLVMStyle.Cpp11BracedListStyle = true; @@ -1043,6 +1074,7 @@ LLVMStyle.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never; LLVMStyle.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock; LLVMStyle.ExperimentalAutoDetectBinPacking = false; + LLVMStyle.PackConstructorInitializers = FormatStyle::PCIS_BinPack; LLVMStyle.FixNamespaceComments = true; LLVMStyle.ForEachMacros.push_back("foreach"); LLVMStyle.ForEachMacros.push_back("Q_FOREACH"); @@ -1158,7 +1190,6 @@ GoogleStyle.AllowShortLoopsOnASingleLine = true; GoogleStyle.AlwaysBreakBeforeMultilineStrings = true; GoogleStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; - GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true; GoogleStyle.DerivePointerAlignment = true; GoogleStyle.IncludeStyle.IncludeCategories = {{"^", 2, 0, false}, {"^<.*\\.h>", 1, 0, false}, @@ -1171,6 +1202,7 @@ GoogleStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Never; GoogleStyle.ObjCSpaceAfterProperty = false; GoogleStyle.ObjCSpaceBeforeProtocolList = true; + GoogleStyle.PackConstructorInitializers = FormatStyle::PCIS_NextLine; GoogleStyle.PointerAlignment = FormatStyle::PAS_Left; GoogleStyle.RawStringFormats = { { diff --git a/clang/lib/Format/TokenAnnotator.cpp b/clang/lib/Format/TokenAnnotator.cpp --- a/clang/lib/Format/TokenAnnotator.cpp +++ b/clang/lib/Format/TokenAnnotator.cpp @@ -3747,13 +3747,18 @@ return Style.BreakBeforeConceptDeclarations; return (Style.AlwaysBreakTemplateDeclarations == FormatStyle::BTDS_Yes); } - if (Right.is(TT_CtorInitializerComma) && - Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma && - !Style.ConstructorInitializerAllOnOneLineOrOnePerLine) - return true; - if (Right.is(TT_CtorInitializerColon) && + if (Style.PackConstructorInitializers == FormatStyle::PCIS_Never) { + if (Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeColon && + (Left.is(TT_CtorInitializerComma) || Right.is(TT_CtorInitializerColon))) + return true; + + if (Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon && + Left.isOneOf(TT_CtorInitializerColon, TT_CtorInitializerComma)) + return true; + } + if (Style.PackConstructorInitializers < FormatStyle::PCIS_CurrentLine && Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma && - !Style.ConstructorInitializerAllOnOneLineOrOnePerLine) + Right.isOneOf(TT_CtorInitializerComma, TT_CtorInitializerColon)) return true; // Break only if we have multiple inheritance. if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma && diff --git a/clang/unittests/Format/FormatTest.cpp b/clang/unittests/Format/FormatTest.cpp --- a/clang/unittests/Format/FormatTest.cpp +++ b/clang/unittests/Format/FormatTest.cpp @@ -5960,7 +5960,26 @@ " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); FormatStyle OnePerLine = getLLVMStyle(); - OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; + OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_Never; + 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.PackConstructorInitializers = FormatStyle::PCIS_NextLine; OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; verifyFormat("SomeClass::Constructor()\n" " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" @@ -6013,8 +6032,6 @@ FormatStyle Style = getLLVMStyle(); Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; Style.ColumnLimit = 60; - Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; - Style.AllowAllConstructorInitializersOnNextLine = true; Style.BinPackParameters = false; for (int i = 0; i < 4; ++i) { @@ -6022,14 +6039,14 @@ Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; Style.AllowAllArgumentsOnNextLine = i & 2; - Style.AllowAllConstructorInitializersOnNextLine = true; + Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); verifyFormat("Constructor() : a(a), b(b) {}", Style); - Style.AllowAllConstructorInitializersOnNextLine = false; + Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a)\n" " , bbbbbbbbbbbbbbbbbbbbb(b) {}", @@ -6037,24 +6054,24 @@ verifyFormat("Constructor() : a(a), b(b) {}", Style); Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; - Style.AllowAllConstructorInitializersOnNextLine = true; + Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); - Style.AllowAllConstructorInitializersOnNextLine = false; + Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; - Style.AllowAllConstructorInitializersOnNextLine = true; + Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); - Style.AllowAllConstructorInitializersOnNextLine = false; + Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbb(b) {}", @@ -6066,14 +6083,13 @@ // BreakConstructorInitializers modes Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; Style.AllowAllParametersOfDeclarationOnNextLine = true; - Style.AllowAllConstructorInitializersOnNextLine = false; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" " : aaaaaaaaaaaaaaaaaaaa(a)\n" " , bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); - Style.AllowAllConstructorInitializersOnNextLine = true; + Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb,\n" @@ -6082,7 +6098,7 @@ Style); Style.AllowAllParametersOfDeclarationOnNextLine = false; - Style.AllowAllConstructorInitializersOnNextLine = false; + Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb)\n" @@ -6099,7 +6115,7 @@ " bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); - Style.AllowAllConstructorInitializersOnNextLine = true; + Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb,\n" @@ -6108,7 +6124,7 @@ Style); Style.AllowAllParametersOfDeclarationOnNextLine = false; - Style.AllowAllConstructorInitializersOnNextLine = false; + Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb)\n" @@ -6124,7 +6140,7 @@ " bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); - Style.AllowAllConstructorInitializersOnNextLine = true; + Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb,\n" @@ -6133,7 +6149,7 @@ Style); Style.AllowAllParametersOfDeclarationOnNextLine = false; - Style.AllowAllConstructorInitializersOnNextLine = false; + Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb) :\n" @@ -6149,7 +6165,8 @@ for (int i = 0; i < 4; ++i) { // Test all combinations of parameters that should not have an effect. Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; - Style.AllowAllConstructorInitializersOnNextLine = i & 2; + Style.PackConstructorInitializers = + i & 2 ? FormatStyle::PCIS_BinPack : FormatStyle::PCIS_Never; Style.AllowAllArgumentsOnNextLine = true; verifyFormat("void foo() {\n" @@ -6265,13 +6282,13 @@ verifyFormat("template \n" "Constructor() : Initializer(FitsOnTheLine) {}", getStyleWithColumns(Style, 50)); - Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; + Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat( "SomeClass::Constructor() :\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", Style); - Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; + Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack; verifyFormat( "SomeClass::Constructor() :\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", @@ -6326,8 +6343,7 @@ Style); FormatStyle OnePerLine = Style; - OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; - OnePerLine.AllowAllConstructorInitializersOnNextLine = false; + OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("SomeClass::Constructor() :\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" @@ -6510,7 +6526,7 @@ // This test takes VERY long when memoization is broken. FormatStyle OnePerLine = getLLVMStyle(); - OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; + OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_NextLine; OnePerLine.BinPackParameters = false; std::string input = "Constructor()\n" " : aaaa(a,\n"; @@ -18213,7 +18229,6 @@ Style.Language = FormatStyle::LK_Cpp; CHECK_PARSE_BOOL(AlignTrailingComments); CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); - CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine); @@ -18225,7 +18240,6 @@ CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); CHECK_PARSE_BOOL(BreakStringLiterals); CHECK_PARSE_BOOL(CompactNamespaces); - CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); CHECK_PARSE_BOOL(DeriveLineEnding); CHECK_PARSE_BOOL(DerivePointerAlignment); CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); @@ -18444,6 +18458,16 @@ CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, FormatStyle::BILS_BeforeComma); + Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack; + CHECK_PARSE("PackConstructorInitializers: Never", PackConstructorInitializers, + FormatStyle::PCIS_Never); + CHECK_PARSE("PackConstructorInitializers: BinPack", + PackConstructorInitializers, FormatStyle::PCIS_BinPack); + CHECK_PARSE("PackConstructorInitializers: CurrentLine", + PackConstructorInitializers, FormatStyle::PCIS_CurrentLine); + CHECK_PARSE("PackConstructorInitializers: NextLine", + PackConstructorInitializers, FormatStyle::PCIS_NextLine); + Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock; CHECK_PARSE("EmptyLineBeforeAccessModifier: Never", EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Never); @@ -19203,7 +19227,7 @@ ", c(c) {}", Style); - Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; + Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; Style.ConstructorInitializerIndentWidth = 4; verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); verifyFormat(