https://github.com/VolatileAcorn updated
https://github.com/llvm/llvm-project/pull/101882
>From e6f04cd8cd22d309a6f6c945c121c77e96371f86 Mon Sep 17 00:00:00 2001
From: Tom Pottage <pottage...@gmail.com>
Date: Fri, 2 Aug 2024 20:26:47 +0100
Subject: [PATCH] [clang-format] Deprecate BinPackParameters and add
BreakParameters. BreakParameters includes a new break always value.
---
clang/docs/ClangFormatStyleOptions.rst | 60 +++++---
clang/include/clang/Format/Format.h | 56 +++++---
clang/lib/Format/ContinuationIndenter.cpp | 28 +---
clang/lib/Format/Format.cpp | 38 ++++-
clang/lib/Format/FormatToken.h | 18 +++
clang/lib/Format/TokenAnnotator.cpp | 8 ++
clang/unittests/Format/ConfigParseTest.cpp | 16 ++-
clang/unittests/Format/FormatTest.cpp | 131 +++++++++++++++---
clang/unittests/Format/FormatTestComments.cpp | 30 +++-
clang/unittests/Format/FormatTestObjC.cpp | 4 +-
10 files changed, 303 insertions(+), 86 deletions(-)
diff --git a/clang/docs/ClangFormatStyleOptions.rst
b/clang/docs/ClangFormatStyleOptions.rst
index 6c2e6da594847..f8ec19438f771 100644
--- a/clang/docs/ClangFormatStyleOptions.rst
+++ b/clang/docs/ClangFormatStyleOptions.rst
@@ -1617,7 +1617,7 @@ the configuration (without a prefix: ``Auto``).
**AllowAllParametersOfDeclarationOnNextLine** (``Boolean``)
:versionbadge:`clang-format 3.3` :ref:`¶
<AllowAllParametersOfDeclarationOnNextLine>`
If the function declaration doesn't fit on a line,
allow putting all parameters of a function declaration onto
- the next line even if ``BinPackParameters`` is ``false``.
+ the next line even if ``BreakParameters`` is ``OnePerLine``.
.. code-block:: c++
@@ -2068,19 +2068,7 @@ the configuration (without a prefix: ``Auto``).
.. _BinPackParameters:
**BinPackParameters** (``Boolean``) :versionbadge:`clang-format 3.7` :ref:`¶
<BinPackParameters>`
- If ``false``, a function declaration's or function definition's
- parameters will either all be on the same line or will have one line each.
-
- .. code-block:: c++
-
- true:
- void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
- int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
-
- false:
- void f(int aaaaaaaaaaaaaaaaaaaa,
- int aaaaaaaaaaaaaaaaaaaa,
- int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
+ This option is **deprecated**. See ``BreakParameters``.
.. _BitFieldColonSpacing:
@@ -3401,6 +3389,44 @@ the configuration (without a prefix: ``Auto``).
+.. _BreakParameters:
+
+**BreakParameters** (``BreakParametersStyle``) :versionbadge:`clang-format 20`
:ref:`¶ <BreakParameters>`
+ The break parameters style to use.
+
+ Possible values:
+
+ * ``BRPS_OnePerLine`` (in configuration: ``OnePerLine``)
+ Put all parameters on the current line if they fit.
+ Otherwise, put each one on its own line.
+
+ .. code-block:: c++
+
+ void f(int a, int b, int c);
+
+ void f(int a,
+ int b,
+ int ccccccccccccccccccccccccccccccccccccc);
+
+ * ``BRPS_Never`` (in configuration: ``Never``)
+ Bin-pack parameters.
+
+ .. code-block:: c++
+
+ void f(int a, int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
+ int ccccccccccccccccccccccccccccccccccccccccccc);
+
+ * ``BRPS_Always`` (in configuration: ``Always``)
+ Always put each parameter on its own line.
+
+ .. code-block:: c++
+
+ void f(int a,
+ int b,
+ int c);
+
+
+
.. _BreakStringLiterals:
**BreakStringLiterals** (``Boolean``) :versionbadge:`clang-format 3.9` :ref:`¶
<BreakStringLiterals>`
@@ -4776,7 +4802,7 @@ the configuration (without a prefix: ``Auto``).
items into as few lines as possible when they go over ``ColumnLimit``.
If ``Auto`` (the default), delegates to the value in
- ``BinPackParameters``. If that is ``true``, bin-packs Objective-C
+ ``BreakParameters``. If that is ``Never``, bin-packs Objective-C
protocol conformance list items into as few lines as possible
whenever they go over ``ColumnLimit``.
@@ -4790,13 +4816,13 @@ the configuration (without a prefix: ``Auto``).
.. code-block:: objc
- Always (or Auto, if BinPackParameters=true):
+ Always (or Auto, if BreakParameters==Never):
@interface ccccccccccccc () <
ccccccccccccc, ccccccccccccc,
ccccccccccccc, ccccccccccccc> {
}
- Never (or Auto, if BinPackParameters=false):
+ Never (or Auto, if BreakParameters!=Never):
@interface ddddddddddddd () <
ddddddddddddd,
ddddddddddddd,
diff --git a/clang/include/clang/Format/Format.h
b/clang/include/clang/Format/Format.h
index c454ab2bc0ce2..c4f00dc6c6f67 100644
--- a/clang/include/clang/Format/Format.h
+++ b/clang/include/clang/Format/Format.h
@@ -659,7 +659,7 @@ struct FormatStyle {
/// If the function declaration doesn't fit on a line,
/// allow putting all parameters of a function declaration onto
- /// the next line even if ``BinPackParameters`` is ``false``.
+ /// the next line even if ``BreakParameters`` is ``OnePerLine``.
/// \code
/// true:
/// void myFunction(
@@ -1192,20 +1192,9 @@ struct FormatStyle {
/// \version 3.7
bool BinPackArguments;
- /// If ``false``, a function declaration's or function definition's
- /// parameters will either all be on the same line or will have one line
each.
- /// \code
- /// true:
- /// void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
- /// int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
- ///
- /// false:
- /// void f(int aaaaaaaaaaaaaaaaaaaa,
- /// int aaaaaaaaaaaaaaaaaaaa,
- /// int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
- /// \endcode
+ /// This option is **deprecated**. See ``BreakParameters``.
/// \version 3.7
- bool BinPackParameters;
+ // bool BinPackParameters;
/// Styles for adding spacing around ``:`` in bitfield definitions.
enum BitFieldColonSpacingStyle : int8_t {
@@ -2386,6 +2375,37 @@ struct FormatStyle {
/// \version 7
BreakInheritanceListStyle BreakInheritanceList;
+ /// Different ways to break parameters.
+ enum BreakParametersStyle : int8_t {
+ /// Put all parameters on the current line if they fit.
+ /// Otherwise, put each one on its own line.
+ /// \code
+ /// void f(int a, int b, int c);
+ ///
+ /// void f(int a,
+ /// int b,
+ /// int ccccccccccccccccccccccccccccccccccccc);
+ /// \endcode
+ BRPS_OnePerLine,
+ /// Bin-pack parameters.
+ /// \code
+ /// void f(int a, int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
+ /// int ccccccccccccccccccccccccccccccccccccccccccc);
+ /// \endcode
+ BRPS_Never,
+ /// Always put each parameter on its own line.
+ /// \code
+ /// void f(int a,
+ /// int b,
+ /// int c);
+ /// \endcode
+ BRPS_Always,
+ };
+
+ /// The break parameters style to use.
+ /// \version 20
+ BreakParametersStyle BreakParameters;
+
/// The template declaration breaking style to use.
/// \version 19
BreakTemplateDeclarationsStyle BreakTemplateDeclarations;
@@ -3378,7 +3398,7 @@ struct FormatStyle {
/// items into as few lines as possible when they go over ``ColumnLimit``.
///
/// If ``Auto`` (the default), delegates to the value in
- /// ``BinPackParameters``. If that is ``true``, bin-packs Objective-C
+ /// ``BreakParameters``. If that is ``Never``, bin-packs Objective-C
/// protocol conformance list items into as few lines as possible
/// whenever they go over ``ColumnLimit``.
///
@@ -3390,13 +3410,13 @@ struct FormatStyle {
/// onto individual lines whenever they go over ``ColumnLimit``.
///
/// \code{.objc}
- /// Always (or Auto, if BinPackParameters=true):
+ /// Always (or Auto, if BreakParameters==Never):
/// @interface ccccccccccccc () <
/// ccccccccccccc, ccccccccccccc,
/// ccccccccccccc, ccccccccccccc> {
/// }
///
- /// Never (or Auto, if BinPackParameters=false):
+ /// Never (or Auto, if BreakParameters!=Never):
/// @interface ddddddddddddd () <
/// ddddddddddddd,
/// ddddddddddddd,
@@ -5024,7 +5044,6 @@ struct FormatStyle {
R.AlwaysBreakBeforeMultilineStrings &&
AttributeMacros == R.AttributeMacros &&
BinPackArguments == R.BinPackArguments &&
- BinPackParameters == R.BinPackParameters &&
BitFieldColonSpacing == R.BitFieldColonSpacing &&
BracedInitializerIndentWidth == R.BracedInitializerIndentWidth &&
BreakAdjacentStringLiterals == R.BreakAdjacentStringLiterals &&
@@ -5041,6 +5060,7 @@ struct FormatStyle {
BreakFunctionDefinitionParameters ==
R.BreakFunctionDefinitionParameters &&
BreakInheritanceList == R.BreakInheritanceList &&
+ BreakParameters == R.BreakParameters &&
BreakStringLiterals == R.BreakStringLiterals &&
BreakTemplateDeclarations == R.BreakTemplateDeclarations &&
ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas
&&
diff --git a/clang/lib/Format/ContinuationIndenter.cpp
b/clang/lib/Format/ContinuationIndenter.cpp
index df86a774ba0f4..933c6b64046f2 100644
--- a/clang/lib/Format/ContinuationIndenter.cpp
+++ b/clang/lib/Format/ContinuationIndenter.cpp
@@ -128,24 +128,6 @@ static bool startsSegmentOfBuilderTypeCall(const
FormatToken &Tok) {
return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope();
}
-// Returns \c true if \c Current starts a new parameter.
-static bool startsNextParameter(const FormatToken &Current,
- const FormatStyle &Style) {
- const FormatToken &Previous = *Current.Previous;
- if (Current.is(TT_CtorInitializerComma) &&
- Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma) {
- return true;
- }
- if (Style.Language == FormatStyle::LK_Proto && Current.is(TT_SelectorName))
- return true;
- return Previous.is(tok::comma) && !Current.isTrailingComment() &&
- ((Previous.isNot(TT_CtorInitializerComma) ||
- Style.BreakConstructorInitializers !=
- FormatStyle::BCIS_BeforeComma) &&
- (Previous.isNot(TT_InheritanceComma) ||
- Style.BreakInheritanceList != FormatStyle::BILS_BeforeComma));
-}
-
static bool opensProtoMessageField(const FormatToken &LessTok,
const FormatStyle &Style) {
if (LessTok.isNot(tok::less))
@@ -411,7 +393,8 @@ bool ContinuationIndenter::mustBreak(const LineState
&State) {
// sets BreakBeforeParameter to avoid bin packing and this creates a
// completely unnecessary line break after a template type that isn't
// line-wrapped.
- (Previous.NestingLevel == 1 || Style.BinPackParameters)) ||
+ (Previous.NestingLevel == 1 ||
+ Style.BreakParameters == FormatStyle::BRPS_Never)) ||
(Style.BreakBeforeTernaryOperators && Current.is(TT_ConditionalExpr) &&
Previous.isNot(tok::question)) ||
(!Style.BreakBeforeTernaryOperators &&
@@ -1914,15 +1897,16 @@ void
ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
Current.MatchingParen->getPreviousNonComment() &&
Current.MatchingParen->getPreviousNonComment()->is(tok::comma);
- // If ObjCBinPackProtocolList is unspecified, fall back to
BinPackParameters
+ // If ObjCBinPackProtocolList is unspecified, fall back to BreakParameters
// for backwards compatibility.
bool ObjCBinPackProtocolList =
(Style.ObjCBinPackProtocolList == FormatStyle::BPS_Auto &&
- Style.BinPackParameters) ||
+ Style.BreakParameters == FormatStyle::BRPS_Never) ||
Style.ObjCBinPackProtocolList == FormatStyle::BPS_Always;
bool BinPackDeclaration =
- (State.Line->Type != LT_ObjCDecl && Style.BinPackParameters) ||
+ (State.Line->Type != LT_ObjCDecl &&
+ Style.BreakParameters == FormatStyle::BRPS_Never) ||
(State.Line->Type == LT_ObjCDecl && ObjCBinPackProtocolList);
bool GenericSelection =
diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp
index 7fd42e46e0ccb..ac352b95b0bf7 100644
--- a/clang/lib/Format/Format.cpp
+++ b/clang/lib/Format/Format.cpp
@@ -134,6 +134,14 @@ template <> struct
ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
}
};
+template <> struct ScalarEnumerationTraits<FormatStyle::BreakParametersStyle> {
+ static void enumeration(IO &IO, FormatStyle::BreakParametersStyle &Value) {
+ IO.enumCase(Value, "OnePerLine", FormatStyle::BRPS_OnePerLine);
+ IO.enumCase(Value, "Never", FormatStyle::BRPS_Never);
+ IO.enumCase(Value, "Always", FormatStyle::BRPS_Always);
+ }
+};
+
template <> struct ScalarEnumerationTraits<FormatStyle::BinPackStyle> {
static void enumeration(IO &IO, FormatStyle::BinPackStyle &Value) {
IO.enumCase(Value, "Auto", FormatStyle::BPS_Auto);
@@ -852,6 +860,15 @@ template <> struct MappingTraits<FormatStyle> {
bool OnCurrentLine = IsGoogleOrChromium;
bool OnNextLine = true;
+ // For backward compatibility:
+ // The default value of BinPackParameters was true unless BasedOnStyle was
+ // Mozilla or Chromium. If BinPackParameters is true then the equilvalent
+ // value for BreakParameters is BRPS_Never and BRPS_OnePerLine otherwise.
+ const bool IsChromiumOrMozilla =
+ BasedOnStyle.equals_insensitive("chromium") ||
+ BasedOnStyle.equals_insensitive("mozilla");
+ bool BinPackParameters = !IsChromiumOrMozilla;
+
bool BreakBeforeInheritanceComma = false;
bool BreakConstructorInitializersBeforeComma = false;
@@ -870,6 +887,7 @@ template <> struct MappingTraits<FormatStyle> {
IO.mapOptional("AlwaysBreakAfterReturnType", Style.BreakAfterReturnType);
IO.mapOptional("AlwaysBreakTemplateDeclarations",
Style.BreakTemplateDeclarations);
+ IO.mapOptional("BinPackParameters", BinPackParameters);
IO.mapOptional("BreakBeforeInheritanceComma",
BreakBeforeInheritanceComma);
IO.mapOptional("BreakConstructorInitializersBeforeComma",
@@ -947,7 +965,6 @@ template <> struct MappingTraits<FormatStyle> {
Style.AlwaysBreakBeforeMultilineStrings);
IO.mapOptional("AttributeMacros", Style.AttributeMacros);
IO.mapOptional("BinPackArguments", Style.BinPackArguments);
- IO.mapOptional("BinPackParameters", Style.BinPackParameters);
IO.mapOptional("BitFieldColonSpacing", Style.BitFieldColonSpacing);
IO.mapOptional("BracedInitializerIndentWidth",
Style.BracedInitializerIndentWidth);
@@ -973,6 +990,7 @@ template <> struct MappingTraits<FormatStyle> {
IO.mapOptional("BreakFunctionDefinitionParameters",
Style.BreakFunctionDefinitionParameters);
IO.mapOptional("BreakInheritanceList", Style.BreakInheritanceList);
+ IO.mapOptional("BreakParameters", Style.BreakParameters);
IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
IO.mapOptional("BreakTemplateDeclarations",
Style.BreakTemplateDeclarations);
@@ -1159,6 +1177,18 @@ template <> struct MappingTraits<FormatStyle> {
Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
}
+ // If BinPackParameters was specified but BreakParameters was not,
+ // initialize the latter from the former for backwards compatibility.
+ if (IsChromiumOrMozilla) {
+ if (BinPackParameters &&
+ (Style.BreakParameters == FormatStyle::BRPS_OnePerLine)) {
+ Style.BreakParameters = FormatStyle::BRPS_Never;
+ }
+ } else if (!BinPackParameters &&
+ (Style.BreakParameters == FormatStyle::BRPS_Never)) {
+ Style.BreakParameters = FormatStyle::BRPS_OnePerLine;
+ }
+
if (!IsGoogleOrChromium) {
if (Style.PackConstructorInitializers == FormatStyle::PCIS_BinPack &&
OnCurrentLine) {
@@ -1449,7 +1479,6 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind
Language) {
LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
LLVMStyle.AttributeMacros.push_back("__capability");
LLVMStyle.BinPackArguments = true;
- LLVMStyle.BinPackParameters = true;
LLVMStyle.BitFieldColonSpacing = FormatStyle::BFCS_Both;
LLVMStyle.BracedInitializerIndentWidth = std::nullopt;
LLVMStyle.BraceWrapping = {/*AfterCaseLabel=*/false,
@@ -1483,6 +1512,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind
Language) {
LLVMStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
LLVMStyle.BreakFunctionDefinitionParameters = false;
LLVMStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
+ LLVMStyle.BreakParameters = FormatStyle::BRPS_Never;
LLVMStyle.BreakStringLiterals = true;
LLVMStyle.BreakTemplateDeclarations = FormatStyle::BTDS_MultiLine;
LLVMStyle.ColumnLimit = 80;
@@ -1823,7 +1853,7 @@ FormatStyle getChromiumStyle(FormatStyle::LanguageKind
Language) {
ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
ChromiumStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
ChromiumStyle.AllowShortLoopsOnASingleLine = false;
- ChromiumStyle.BinPackParameters = false;
+ ChromiumStyle.BreakParameters = FormatStyle::BRPS_OnePerLine;
ChromiumStyle.DerivePointerAlignment = false;
if (Language == FormatStyle::LK_ObjC)
ChromiumStyle.ColumnLimit = 80;
@@ -1838,11 +1868,11 @@ FormatStyle getMozillaStyle() {
MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
FormatStyle::DRTBS_TopLevel;
MozillaStyle.BinPackArguments = false;
- MozillaStyle.BinPackParameters = false;
MozillaStyle.BreakAfterReturnType = FormatStyle::RTBS_TopLevel;
MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
MozillaStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
MozillaStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
+ MozillaStyle.BreakParameters = FormatStyle::BRPS_OnePerLine;
MozillaStyle.BreakTemplateDeclarations = FormatStyle::BTDS_Yes;
MozillaStyle.ConstructorInitializerIndentWidth = 2;
MozillaStyle.ContinuationIndentWidth = 2;
diff --git a/clang/lib/Format/FormatToken.h b/clang/lib/Format/FormatToken.h
index abcedb66b57cc..fb97f4630ab24 100644
--- a/clang/lib/Format/FormatToken.h
+++ b/clang/lib/Format/FormatToken.h
@@ -1978,6 +1978,24 @@ inline bool continuesLineComment(const FormatToken
&FormatTok,
FormatTok.OriginalColumn >= MinContinueColumn;
}
+// Returns \c true if \c Current starts a new parameter.
+inline bool startsNextParameter(const FormatToken &Current,
+ const FormatStyle &Style) {
+ const FormatToken &Previous = *Current.Previous;
+ if (Current.is(TT_CtorInitializerComma) &&
+ Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma) {
+ return true;
+ }
+ if (Style.Language == FormatStyle::LK_Proto && Current.is(TT_SelectorName))
+ return true;
+ return Previous.is(tok::comma) && !Current.isTrailingComment() &&
+ ((Previous.isNot(TT_CtorInitializerComma) ||
+ Style.BreakConstructorInitializers !=
+ FormatStyle::BCIS_BeforeComma) &&
+ (Previous.isNot(TT_InheritanceComma) ||
+ Style.BreakInheritanceList != FormatStyle::BILS_BeforeComma));
+}
+
} // namespace format
} // namespace clang
diff --git a/clang/lib/Format/TokenAnnotator.cpp
b/clang/lib/Format/TokenAnnotator.cpp
index 4ed3e9d0e8e85..6dc8d95c99d81 100644
--- a/clang/lib/Format/TokenAnnotator.cpp
+++ b/clang/lib/Format/TokenAnnotator.cpp
@@ -5458,6 +5458,14 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine
&Line,
return true;
}
+ // Ignores the first parameter as this will be handled separately by
+ // BreakFunctionDefinitionParameters or AlignAfterOpenBracket.
+ if (FormatStyle::BRPS_Always == Style.BreakParameters &&
+ Line.MightBeFunctionDecl && !Left.opensScope() &&
+ startsNextParameter(Right, Style)) {
+ return true;
+ }
+
const auto *BeforeLeft = Left.Previous;
const auto *AfterRight = Right.Next;
diff --git a/clang/unittests/Format/ConfigParseTest.cpp
b/clang/unittests/Format/ConfigParseTest.cpp
index cc044153b7c9b..6251645325140 100644
--- a/clang/unittests/Format/ConfigParseTest.cpp
+++ b/clang/unittests/Format/ConfigParseTest.cpp
@@ -160,7 +160,6 @@ TEST(ConfigParseTest, ParsesConfigurationBools) {
CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
CHECK_PARSE_BOOL(BinPackArguments);
- CHECK_PARSE_BOOL(BinPackParameters);
CHECK_PARSE_BOOL(BreakAdjacentStringLiterals);
CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
@@ -428,6 +427,21 @@ TEST(ConfigParseTest, ParsesConfiguration) {
CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
FormatStyle::BILS_BeforeComma);
+ Style.BreakParameters = FormatStyle::BRPS_Never;
+ CHECK_PARSE("BreakParameters: OnePerLine", BreakParameters,
+ FormatStyle::BRPS_OnePerLine);
+ CHECK_PARSE("BreakParameters: Never", BreakParameters,
+ FormatStyle::BRPS_Never);
+ CHECK_PARSE("BreakParameters: Always", BreakParameters,
+ FormatStyle::BRPS_Always);
+ // For backward compatibility.
+ CHECK_PARSE("BasedOnStyle: Mozilla\n"
+ "BinPackParameters: true",
+ BreakParameters, FormatStyle::BRPS_Never);
+ CHECK_PARSE("BasedOnStyle: Llvm\n"
+ "BinPackParameters: false",
+ BreakParameters, FormatStyle::BRPS_OnePerLine);
+
Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack;
CHECK_PARSE("PackConstructorInitializers: Never",
PackConstructorInitializers,
FormatStyle::PCIS_Never);
diff --git a/clang/unittests/Format/FormatTest.cpp
b/clang/unittests/Format/FormatTest.cpp
index 2a754a29e81e7..c7ca14e391f96 100644
--- a/clang/unittests/Format/FormatTest.cpp
+++ b/clang/unittests/Format/FormatTest.cpp
@@ -2338,7 +2338,7 @@ TEST_F(FormatTest, FormatsForLoop) {
"for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
FormatStyle NoBinPacking = getLLVMStyle();
- NoBinPacking.BinPackParameters = false;
+ NoBinPacking.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat("for (int aaaaaaaaaaa = 1;\n"
" aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
" aaaaaaaaaaaaaaaa,\n"
@@ -7165,7 +7165,7 @@ TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
"}");
FormatStyle OnePerLine = getLLVMStyle();
- OnePerLine.BinPackParameters = false;
+ OnePerLine.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat(
"if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
" aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
@@ -7319,7 +7319,7 @@ TEST_F(FormatTest,
ExpressionIndentationBreakingBeforeOperators) {
Style = getLLVMStyleWithColumns(20);
Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
- Style.BinPackParameters = false;
+ Style.BreakParameters = FormatStyle::BRPS_OnePerLine;
Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
Style.ContinuationIndentWidth = 2;
verifyFormat("struct Foo {\n"
@@ -7694,7 +7694,7 @@ TEST_F(FormatTest, ConstructorInitializers) {
" : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
" aaaaaaaaaaaaaaaaaaaaaa) {}",
OnePerLine);
- OnePerLine.BinPackParameters = false;
+ OnePerLine.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat(
"Constructor()\n"
" : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
@@ -7718,7 +7718,7 @@ TEST_F(FormatTest, ConstructorInitializers) {
TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
FormatStyle Style = getLLVMStyleWithColumns(60);
Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
- Style.BinPackParameters = false;
+ Style.BreakParameters = FormatStyle::BRPS_OnePerLine;
for (int i = 0; i < 4; ++i) {
// Test all combinations of parameters that should not have an effect.
@@ -7954,7 +7954,7 @@ TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
}
// This parameter should not affect declarations.
- Style.BinPackParameters = false;
+ Style.BreakParameters = FormatStyle::BRPS_OnePerLine;
Style.AllowAllArgumentsOnNextLine = false;
Style.AllowAllParametersOfDeclarationOnNextLine = true;
verifyFormat("void FunctionCallWithReallyLongName(\n"
@@ -8049,7 +8049,7 @@ TEST_F(FormatTest, BreakFunctionDefinitionParameters) {
// Test the style where all parameters are on their own lines.
Style.AllowAllParametersOfDeclarationOnNextLine = false;
- Style.BinPackParameters = false;
+ Style.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat("void functionDecl(paramA, paramB, paramC);\n"
"void emptyFunctionDefinition() {}\n"
"void functionDefinition(\n"
@@ -8244,7 +8244,7 @@ TEST_F(FormatTest,
BreakConstructorInitializersAfterColon) {
" aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
" aaaaaaaaaaaaaaaaaaaaaa) {}",
OnePerLine);
- OnePerLine.BinPackParameters = false;
+ OnePerLine.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat("Constructor() :\n"
" aaaaaaaaaaaaaaaaaaaaaaaa(\n"
" aaaaaaaaaaa().aaa(),\n"
@@ -8409,7 +8409,7 @@ TEST_F(FormatTest, MemoizationTests) {
// This test takes VERY long when memoization is broken.
FormatStyle OnePerLine = getLLVMStyle();
OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
- OnePerLine.BinPackParameters = false;
+ OnePerLine.BreakParameters = FormatStyle::BRPS_OnePerLine;
std::string input = "Constructor()\n"
" : aaaa(a,\n";
for (unsigned i = 0, e = 80; i != e; ++i)
@@ -8830,7 +8830,7 @@ TEST_F(FormatTest, BreaksDesireably) {
TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
FormatStyle NoBinPacking = getGoogleStyle();
- NoBinPacking.BinPackParameters = false;
+ NoBinPacking.BreakParameters = FormatStyle::BRPS_OnePerLine;
NoBinPacking.BinPackArguments = true;
verifyFormat("void f() {\n"
" f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
@@ -8862,7 +8862,7 @@ TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
FormatStyle NoBinPacking = getGoogleStyle();
- NoBinPacking.BinPackParameters = false;
+ NoBinPacking.BreakParameters = FormatStyle::BRPS_OnePerLine;
NoBinPacking.BinPackArguments = false;
verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
" aaaaaaaaaaaaaaaaaaaa,\n"
@@ -8925,6 +8925,97 @@ TEST_F(FormatTest,
FormatsOneParameterPerLineIfNecessary) {
NoBinPacking);
}
+TEST_F(FormatTest, FormatsDeclarationBreakAlways) {
+ FormatStyle BreakAlways = getGoogleStyle();
+ BreakAlways.BreakParameters = FormatStyle::BRPS_Always;
+ verifyFormat("void f(int a,\n"
+ " int b);",
+ BreakAlways);
+ verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " int bbbbbbbbbbbbbbbbbbbbbbbbb,\n"
+ " int cccccccccccccccccccccccc);",
+ BreakAlways);
+
+ // Ensure AlignAfterOpenBracket interacts correctly with
+ // BreakParameters set to Always.
+ BreakAlways.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
+ verifyFormat(
+ "void someLongFunctionName(\n"
+ " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " int b);",
+ BreakAlways);
+ BreakAlways.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent;
+ verifyFormat(
+ "void someLongFunctionName(\n"
+ " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " int b\n"
+ ");",
+ BreakAlways);
+}
+
+TEST_F(FormatTest, FormatsDefinitionBreakAlways) {
+ FormatStyle BreakAlways = getGoogleStyle();
+ BreakAlways.BreakParameters = FormatStyle::BRPS_Always;
+ verifyFormat("void f(int a,\n"
+ " int b) {\n"
+ " f(a, b);\n"
+ "}",
+ BreakAlways);
+
+ // Ensure BinPackArguments interact correctly when BreakParameters is set to
+ // Always.
+ verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " int bbbbbbbbbbbbbbbbbbbbbbbbb,\n"
+ " int cccccccccccccccccccccccc) {\n"
+ " f(aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbb,\n"
+ " cccccccccccccccccccccccc);\n"
+ "}",
+ BreakAlways);
+ BreakAlways.BinPackArguments = false;
+ verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " int bbbbbbbbbbbbbbbbbbbbbbbbb,\n"
+ " int cccccccccccccccccccccccc) {\n"
+ " f(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " bbbbbbbbbbbbbbbbbbbbbbbbb,\n"
+ " cccccccccccccccccccccccc);\n"
+ "}",
+ BreakAlways);
+
+ // Ensure BreakFunctionDefinitionParameters interacts correctly when
+ // BreakParameters is set to Always
+ BreakAlways.BreakFunctionDefinitionParameters = true;
+ verifyFormat("void f(\n"
+ " int a,\n"
+ " int b) {\n"
+ " f(a, b);\n"
+ "}",
+ BreakAlways);
+ BreakAlways.BreakFunctionDefinitionParameters = false;
+
+ // Ensure AlignAfterOpenBracket interacts correctly with
+ // BreakParameters set to Always.
+ BreakAlways.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
+ verifyFormat(
+ "void someLongFunctionName(\n"
+ " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " int b) {\n"
+ " someLongFunctionName(\n"
+ " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, b);\n"
+ "}",
+ BreakAlways);
+ BreakAlways.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent;
+ verifyFormat(
+ "void someLongFunctionName(\n"
+ " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " int b\n"
+ ") {\n"
+ " someLongFunctionName(\n"
+ " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, b\n"
+ " );\n"
+ "}",
+ BreakAlways);
+}
+
TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
FormatStyle Style = getLLVMStyleWithColumns(15);
Style.ExperimentalAutoDetectBinPacking = true;
@@ -9256,7 +9347,7 @@ TEST_F(FormatTest, AlignsAfterOpenBracket) {
Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
Style.BinPackArguments = false;
- Style.BinPackParameters = false;
+ Style.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
" aaaaaaaaaaa aaaaaaaa,\n"
" aaaaaaaaa aaaaaaa,\n"
@@ -9295,7 +9386,7 @@ TEST_F(FormatTest, AlignsAfterOpenBracket) {
Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent;
Style.BinPackArguments = false;
- Style.BinPackParameters = false;
+ Style.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
" aaaaaaaaaaa aaaaaaaa,\n"
" aaaaaaaaa aaaaaaa,\n"
@@ -10706,7 +10797,7 @@ TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
" .a();");
FormatStyle NoBinPacking = getLLVMStyle();
- NoBinPacking.BinPackParameters = false;
+ NoBinPacking.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
" .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
" .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
@@ -13618,7 +13709,7 @@ TEST_F(FormatTest, HandlesIncludeDirectives) {
TEST_F(FormatTest, IncompleteParameterLists) {
FormatStyle NoBinPacking = getLLVMStyle();
- NoBinPacking.BinPackParameters = false;
+ NoBinPacking.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
" double *min_x,\n"
" double *max_x,\n"
@@ -14284,7 +14375,7 @@ TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
" [](const Input &i) -> Output { return "
"Output{1, 2}; });");
FormatStyle NoBinPacking = getLLVMStyle();
- NoBinPacking.BinPackParameters = false;
+ NoBinPacking.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat("waarudo::unit desk = {\n"
" .s = \"desk\", .p = p, .b = [] { return w::r{3, 10, 1, 1, "
"1, 1} * w::m; }};",
@@ -19789,7 +19880,7 @@ TEST_F(FormatTest, AlignConsecutiveDeclarations) {
Alignment.AlignConsecutiveAssignments.Enabled = false;
Alignment.ColumnLimit = 30;
- Alignment.BinPackParameters = false;
+ Alignment.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat("void foo(float a,\n"
" float b,\n"
" int c,\n"
@@ -19803,7 +19894,7 @@ TEST_F(FormatTest, AlignConsecutiveDeclarations) {
" uint32_t *c,\n"
" bool d) {}",
Alignment);
- Alignment.BinPackParameters = true;
+ Alignment.BreakParameters = FormatStyle::BRPS_Never;
Alignment.ColumnLimit = 80;
// Bug 33507
@@ -23229,7 +23320,7 @@ TEST_F(FormatTest, FormatsLambdas) {
" LambdaBodyMustBeBreak);\n"
"};",
LLVMWithBeforeLambdaBody);
- LLVMWithBeforeLambdaBody.BinPackParameters = false;
+ LLVMWithBeforeLambdaBody.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
LLVMWithBeforeLambdaBody);
verifyFormat(
@@ -26626,7 +26717,7 @@ TEST_F(FormatTest, AlignAfterOpenBracketBlockIndent) {
Medium, Style);
Style.BinPackArguments = false;
- Style.BinPackParameters = false;
+ Style.BreakParameters = FormatStyle::BRPS_OnePerLine;
verifyFormat(Short, Style);
diff --git a/clang/unittests/Format/FormatTestComments.cpp
b/clang/unittests/Format/FormatTestComments.cpp
index 8f84d59cbb2e2..46a3868fb459d 100644
--- a/clang/unittests/Format/FormatTestComments.cpp
+++ b/clang/unittests/Format/FormatTestComments.cpp
@@ -362,6 +362,26 @@ TEST_F(FormatTestComments,
KeepsParameterWithTrailingCommentsOnTheirOwnLine) {
format("aaaaaaaaaa(aaaa(aaaa,\n"
"aaaa), //\n"
"aaaa, bbbbb);"));
+
+ FormatStyle BreakAlways = getLLVMStyle();
+ BreakAlways.BreakParameters = FormatStyle::BRPS_Always;
+ EXPECT_EQ("SomeFunction(a,\n"
+ " b, // comment\n"
+ " c,\n"
+ " d);",
+ format("SomeFunction(a,\n"
+ " b, // comment\n"
+ " c, d);",
+ BreakAlways));
+ EXPECT_EQ("SomeFunction(a,\n"
+ " b,\n"
+ " // comment\n"
+ " c);",
+ format("SomeFunction(a,\n"
+ " b,\n"
+ " // comment\n"
+ " c);",
+ BreakAlways));
}
TEST_F(FormatTestComments, RemovesTrailingWhitespaceOfComments) {
@@ -404,7 +424,13 @@ TEST_F(FormatTestComments, UnderstandsBlockComments) {
" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
FormatStyle NoBinPacking = getLLVMStyle();
- NoBinPacking.BinPackParameters = false;
+ NoBinPacking.BreakParameters = FormatStyle::BRPS_OnePerLine;
+ verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n"
+ " /* parameter 2 */ aaaaaa,\n"
+ " /* parameter 3 */ aaaaaa,\n"
+ " /* parameter 4 */ aaaaaa);",
+ NoBinPacking);
+ NoBinPacking.BreakParameters = FormatStyle::BRPS_Always;
verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n"
" /* parameter 2 */ aaaaaa,\n"
" /* parameter 3 */ aaaaaa,\n"
@@ -2449,7 +2475,7 @@ TEST_F(FormatTestComments, BlockComments) {
getLLVMStyleWithColumns(50)));
FormatStyle NoBinPacking = getLLVMStyle();
- NoBinPacking.BinPackParameters = false;
+ NoBinPacking.BreakParameters = FormatStyle::BRPS_OnePerLine;
EXPECT_EQ("someFunction(1, /* comment 1 */\n"
" 2, /* comment 2 */\n"
" 3, /* comment 3 */\n"
diff --git a/clang/unittests/Format/FormatTestObjC.cpp
b/clang/unittests/Format/FormatTestObjC.cpp
index d2c3459e0f846..9f6fd742ef25f 100644
--- a/clang/unittests/Format/FormatTestObjC.cpp
+++ b/clang/unittests/Format/FormatTestObjC.cpp
@@ -377,7 +377,7 @@ TEST_F(FormatTestObjC, FormatObjCInterface) {
" ddddddddddddd> {\n"
"}");
- Style.BinPackParameters = false;
+ Style.BreakParameters = FormatStyle::BRPS_OnePerLine;
Style.ObjCBinPackProtocolList = FormatStyle::BPS_Auto;
verifyFormat("@interface eeeeeeeeeeeee () <\n"
" eeeeeeeeeeeee,\n"
@@ -411,7 +411,7 @@ TEST_F(FormatTestObjC, FormatObjCInterface) {
"+ (id)init;\n"
"@end");
Style.ColumnLimit = 40;
- // BinPackParameters should be true by default.
+ // BreakParameters should be BRPS_Never by default.
verifyFormat("void eeeeeeee(int eeeee, int eeeee,\n"
" int eeeee, int eeeee);");
// ObjCBinPackProtocolList should be BPS_Never by default.
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
