Author: owenca Date: 2021-08-27T06:27:46-07:00 New Revision: 8a780a2f18c590e27e51a2ab3cc81b481c42b42a
URL: https://github.com/llvm/llvm-project/commit/8a780a2f18c590e27e51a2ab3cc81b481c42b42a DIFF: https://github.com/llvm/llvm-project/commit/8a780a2f18c590e27e51a2ab3cc81b481c42b42a.diff LOG: [clang-format] Group options that pack constructor initializers Add a new option PackConstructorInitializers and deprecate the related options ConstructorInitializerAllOnOneLineOrOnePerLine and AllowAllConstructorInitializersOnNextLine. Below is the mapping: PackConstructorInitializers ConstructorInitializer... AllowAll... Never - - BinPack false - CurrentLine true false NextLine true true The option value Never fixes PR50549 by always placing each constructor initializer on its own line. Differential Revision: https://reviews.llvm.org/D108752 Added: Modified: clang/docs/ClangFormatStyleOptions.rst clang/include/clang/Format/Format.h clang/lib/Format/ContinuationIndenter.cpp clang/lib/Format/Format.cpp clang/lib/Format/TokenAnnotator.cpp clang/unittests/Format/FormatTest.cpp Removed: ################################################################################ diff --git a/clang/docs/ClangFormatStyleOptions.rst b/clang/docs/ClangFormatStyleOptions.rst index d8ac58734dc4a..677d498a1e57a 100644 --- a/clang/docs/ClangFormatStyleOptions.rst +++ b/clang/docs/ClangFormatStyleOptions.rst @@ -646,22 +646,8 @@ the configuration (without a prefix: ``Auto``). 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 @@ the configuration (without a prefix: ``Auto``). SecondValueVeryVeryVeryVeryLong; **BreakConstructorInitializers** (``BreakConstructorInitializersStyle``) - The constructor initializers style to use. + The break constructor initializers style to use. Possible values: @@ -2140,23 +2126,8 @@ the configuration (without a prefix: ``Auto``). }}} **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 @@ the configuration (without a prefix: ``Auto``). # 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 index 0e2193596daf7..7be21d1c82bf8 100644 --- a/clang/include/clang/Format/Format.h +++ b/clang/include/clang/Format/Format.h @@ -505,20 +505,8 @@ struct FormatStyle { /// \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 @@ struct FormatStyle { 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 @@ struct FormatStyle { /// \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 @@ struct FormatStyle { /// 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 @@ struct FormatStyle { /// 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 @@ struct FormatStyle { AlignOperands == R.AlignOperands && AlignTrailingComments == R.AlignTrailingComments && AllowAllArgumentsOnNextLine == R.AllowAllArgumentsOnNextLine && - AllowAllConstructorInitializersOnNextLine == - R.AllowAllConstructorInitializersOnNextLine && AllowAllParametersOfDeclarationOnNextLine == R.AllowAllParametersOfDeclarationOnNextLine && AllowShortEnumsOnASingleLine == R.AllowShortEnumsOnASingleLine && @@ -3423,8 +3439,6 @@ struct FormatStyle { 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 @@ struct FormatStyle { 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 index 1bf63cb909e06..a6c5b63910c14 100644 --- a/clang/lib/Format/ContinuationIndenter.cpp +++ b/clang/lib/Format/ContinuationIndenter.cpp @@ -958,7 +958,7 @@ unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State, 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 @@ unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State, // 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 @@ unsigned ContinuationIndenter::moveStateToNextToken(LineState &State, ? 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 @@ unsigned ContinuationIndenter::moveStateToNextToken(LineState &State, 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 index 2b860d2a25f7b..08e8e9e866949 100644 --- a/clang/lib/Format/Format.cpp +++ b/clang/lib/Format/Format.cpp @@ -264,6 +264,17 @@ struct ScalarEnumerationTraits<FormatStyle::BreakInheritanceListStyle> { } }; +template <> +struct ScalarEnumerationTraits<FormatStyle::PackConstructorInitializersStyle> { + 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<FormatStyle::EmptyLineAfterAccessModifierStyle> { static void @@ -552,8 +563,6 @@ template <> struct MappingTraits<FormatStyle> { 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 @@ template <> struct MappingTraits<FormatStyle> { 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 @@ template <> struct MappingTraits<FormatStyle> { 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 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) { 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 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) { 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 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) { 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 @@ FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) { GoogleStyle.AllowShortLoopsOnASingleLine = true; GoogleStyle.AlwaysBreakBeforeMultilineStrings = true; GoogleStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; - GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true; GoogleStyle.DerivePointerAlignment = true; GoogleStyle.IncludeStyle.IncludeCategories = {{"^<ext/.*\\.h>", 2, 0, false}, {"^<.*\\.h>", 1, 0, false}, @@ -1171,6 +1202,7 @@ FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) { 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 index 887f6e363db82..8506eb7b88fd8 100644 --- a/clang/lib/Format/TokenAnnotator.cpp +++ b/clang/lib/Format/TokenAnnotator.cpp @@ -3747,13 +3747,18 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, 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 index 383c2cf9e6c45..4ca3a22a76c8e 100644 --- a/clang/unittests/Format/FormatTest.cpp +++ b/clang/unittests/Format/FormatTest.cpp @@ -5960,7 +5960,26 @@ TEST_F(FormatTest, ConstructorInitializers) { " 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 @@ TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 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 @@ TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 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 @@ TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 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 @@ TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { // 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 @@ TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 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 @@ TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { " 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 @@ TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 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 @@ TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { " 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 @@ TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 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 @@ TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 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 @@ TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { verifyFormat("template <typename T>\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 @@ TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 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 @@ TEST_F(FormatTest, MemoizationTests) { // 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 @@ TEST_F(FormatTest, ParsesConfigurationBools) { 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 @@ TEST_F(FormatTest, ParsesConfigurationBools) { 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 @@ TEST_F(FormatTest, ParsesConfiguration) { 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 @@ TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { ", c(c) {}", Style); - Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; + Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; Style.ConstructorInitializerIndentWidth = 4; verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); verifyFormat( _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
