[clang] 8a780a2 - [clang-format] Group options that pack constructor initializers
via cfe-commits
cfe-commits at lists.llvm.org
Fri Aug 27 06:32:53 PDT 2021
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(
More information about the cfe-commits
mailing list