Author: Tom Date: 2024-08-22T21:42:22-07:00 New Revision: 7c3237d778572931ff097e81df43d0bce9d1d4f8
URL: https://github.com/llvm/llvm-project/commit/7c3237d778572931ff097e81df43d0bce9d1d4f8 DIFF: https://github.com/llvm/llvm-project/commit/7c3237d778572931ff097e81df43d0bce9d1d4f8.diff LOG: [clang-format] Change BinPackParameters to enum and add AlwaysOnePerLine (#101882) Related issues that have requested this feature: #51833 #23796 #53190 Partially solves - this issue requests is for both arguments and parameters 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/FormatToken.cpp clang/lib/Format/FormatToken.h clang/lib/Format/TokenAnnotator.cpp clang/unittests/Format/ConfigParseTest.cpp clang/unittests/Format/FormatTest.cpp clang/unittests/Format/FormatTestComments.cpp clang/unittests/Format/FormatTestObjC.cpp Removed: ################################################################################ diff --git a/clang/docs/ClangFormatStyleOptions.rst b/clang/docs/ClangFormatStyleOptions.rst index c79a635d86a6ef..a427d7cd40fcdd 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 ``BinPackParameters`` is ``OnePerLine``. .. code-block:: c++ @@ -2067,20 +2067,41 @@ 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. +**BinPackParameters** (``BinPackParametersStyle``) :versionbadge:`clang-format 3.7` :ref:`¶ <BinPackParameters>` + The bin pack parameters style to use. - .. code-block:: c++ + Possible values: + + * ``BPPS_BinPack`` (in configuration: ``BinPack``) + Bin-pack parameters. + + .. code-block:: c++ + + void f(int a, int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, + int ccccccccccccccccccccccccccccccccccccccccccc); + + * ``BPPS_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); + + * ``BPPS_AlwaysOnePerLine`` (in configuration: ``AlwaysOnePerLine``) + Always put each parameter on its own line. + + .. code-block:: c++ + + void f(int a, + int b, + int c); - true: - void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa, - int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {} - false: - void f(int aaaaaaaaaaaaaaaaaaaa, - int aaaaaaaaaaaaaaaaaaaa, - int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {} .. _BitFieldColonSpacing: @@ -4817,7 +4838,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 + ``BinPackParameters``. If that is ``BinPack``, bin-packs Objective-C protocol conformance list items into as few lines as possible whenever they go over ``ColumnLimit``. @@ -4831,13 +4852,13 @@ the configuration (without a prefix: ``Auto``). .. code-block:: objc - Always (or Auto, if BinPackParameters=true): + Always (or Auto, if BinPackParameters==BinPack): @interface ccccccccccccc () < ccccccccccccc, ccccccccccccc, ccccccccccccc, ccccccccccccc> { } - Never (or Auto, if BinPackParameters=false): + Never (or Auto, if BinPackParameters!=BinPack): @interface ddddddddddddd () < ddddddddddddd, ddddddddddddd, diff --git a/clang/include/clang/Format/Format.h b/clang/include/clang/Format/Format.h index 2af1d4065c3cc1..d8b62c7652a0f6 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 ``BinPackParameters`` is ``OnePerLine``. /// \code /// true: /// void myFunction( @@ -1192,20 +1192,36 @@ 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 + /// Different way to try to fit all parameters on a line. + enum BinPackParametersStyle : int8_t { + /// Bin-pack parameters. + /// \code + /// void f(int a, int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, + /// int ccccccccccccccccccccccccccccccccccccccccccc); + /// \endcode + BPPS_BinPack, + /// 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 + BPPS_OnePerLine, + /// Always put each parameter on its own line. + /// \code + /// void f(int a, + /// int b, + /// int c); + /// \endcode + BPPS_AlwaysOnePerLine, + }; + + /// The bin pack parameters style to use. /// \version 3.7 - bool BinPackParameters; + BinPackParametersStyle BinPackParameters; /// Styles for adding spacing around ``:`` in bitfield definitions. enum BitFieldColonSpacingStyle : int8_t { @@ -3414,7 +3430,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 + /// ``BinPackParameters``. If that is ``BinPack``, bin-packs Objective-C /// protocol conformance list items into as few lines as possible /// whenever they go over ``ColumnLimit``. /// @@ -3426,13 +3442,13 @@ struct FormatStyle { /// onto individual lines whenever they go over ``ColumnLimit``. /// /// \code{.objc} - /// Always (or Auto, if BinPackParameters=true): + /// Always (or Auto, if BinPackParameters==BinPack): /// @interface ccccccccccccc () < /// ccccccccccccc, ccccccccccccc, /// ccccccccccccc, ccccccccccccc> { /// } /// - /// Never (or Auto, if BinPackParameters=false): + /// Never (or Auto, if BinPackParameters!=BinPack): /// @interface ddddddddddddd () < /// ddddddddddddd, /// ddddddddddddd, diff --git a/clang/lib/Format/ContinuationIndenter.cpp b/clang/lib/Format/ContinuationIndenter.cpp index 46dafad65863dc..4fcb776db45b58 100644 --- a/clang/lib/Format/ContinuationIndenter.cpp +++ b/clang/lib/Format/ContinuationIndenter.cpp @@ -128,25 +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) { - assert(Current.Previous); - const auto &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)); -} - // Returns \c true if \c Token in an alignable binary operator static bool isAlignableBinaryOperator(const FormatToken &Token) { // No need to align binary operators that only have two operands. @@ -437,7 +418,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.BinPackParameters == FormatStyle::BPPS_BinPack)) || (Style.BreakBeforeTernaryOperators && Current.is(TT_ConditionalExpr) && Previous.isNot(tok::question)) || (!Style.BreakBeforeTernaryOperators && @@ -1951,11 +1933,12 @@ void ContinuationIndenter::moveStatePastScopeOpener(LineState &State, // for backwards compatibility. bool ObjCBinPackProtocolList = (Style.ObjCBinPackProtocolList == FormatStyle::BPS_Auto && - Style.BinPackParameters) || + Style.BinPackParameters == FormatStyle::BPPS_BinPack) || Style.ObjCBinPackProtocolList == FormatStyle::BPS_Always; bool BinPackDeclaration = - (State.Line->Type != LT_ObjCDecl && Style.BinPackParameters) || + (State.Line->Type != LT_ObjCDecl && + Style.BinPackParameters == FormatStyle::BPPS_BinPack) || (State.Line->Type == LT_ObjCDecl && ObjCBinPackProtocolList); bool GenericSelection = diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp index 97fac41cdd3008..d2463b892fbb96 100644 --- a/clang/lib/Format/Format.cpp +++ b/clang/lib/Format/Format.cpp @@ -134,6 +134,19 @@ template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> { } }; +template <> +struct ScalarEnumerationTraits<FormatStyle::BinPackParametersStyle> { + static void enumeration(IO &IO, FormatStyle::BinPackParametersStyle &Value) { + IO.enumCase(Value, "BinPack", FormatStyle::BPPS_BinPack); + IO.enumCase(Value, "OnePerLine", FormatStyle::BPPS_OnePerLine); + IO.enumCase(Value, "AlwaysOnePerLine", FormatStyle::BPPS_AlwaysOnePerLine); + + // For backward compatibility. + IO.enumCase(Value, "true", FormatStyle::BPPS_BinPack); + IO.enumCase(Value, "false", FormatStyle::BPPS_OnePerLine); + } +}; + template <> struct ScalarEnumerationTraits<FormatStyle::BinPackStyle> { static void enumeration(IO &IO, FormatStyle::BinPackStyle &Value) { IO.enumCase(Value, "Auto", FormatStyle::BPS_Auto); @@ -1461,7 +1474,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) { LLVMStyle.AlwaysBreakBeforeMultilineStrings = false; LLVMStyle.AttributeMacros.push_back("__capability"); LLVMStyle.BinPackArguments = true; - LLVMStyle.BinPackParameters = true; + LLVMStyle.BinPackParameters = FormatStyle::BPPS_BinPack; LLVMStyle.BitFieldColonSpacing = FormatStyle::BFCS_Both; LLVMStyle.BracedInitializerIndentWidth = std::nullopt; LLVMStyle.BraceWrapping = {/*AfterCaseLabel=*/false, @@ -1836,7 +1849,7 @@ FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) { ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; ChromiumStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never; ChromiumStyle.AllowShortLoopsOnASingleLine = false; - ChromiumStyle.BinPackParameters = false; + ChromiumStyle.BinPackParameters = FormatStyle::BPPS_OnePerLine; ChromiumStyle.DerivePointerAlignment = false; if (Language == FormatStyle::LK_ObjC) ChromiumStyle.ColumnLimit = 80; @@ -1851,7 +1864,7 @@ FormatStyle getMozillaStyle() { MozillaStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_TopLevel; MozillaStyle.BinPackArguments = false; - MozillaStyle.BinPackParameters = false; + MozillaStyle.BinPackParameters = FormatStyle::BPPS_OnePerLine; MozillaStyle.BreakAfterReturnType = FormatStyle::RTBS_TopLevel; MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; MozillaStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; diff --git a/clang/lib/Format/FormatToken.cpp b/clang/lib/Format/FormatToken.cpp index 85bec71ffbbc8a..963e8f87793fa0 100644 --- a/clang/lib/Format/FormatToken.cpp +++ b/clang/lib/Format/FormatToken.cpp @@ -322,5 +322,22 @@ CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const { return BestFormat; } +bool startsNextParameter(const FormatToken &Current, const FormatStyle &Style) { + assert(Current.Previous); + const auto &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/FormatToken.h b/clang/lib/Format/FormatToken.h index abcedb66b57cc6..2d386d99aa841a 100644 --- a/clang/lib/Format/FormatToken.h +++ b/clang/lib/Format/FormatToken.h @@ -1978,6 +1978,9 @@ inline bool continuesLineComment(const FormatToken &FormatTok, FormatTok.OriginalColumn >= MinContinueColumn; } +// Returns \c true if \c Current starts a new parameter. +bool startsNextParameter(const FormatToken &Current, const FormatStyle &Style); + } // namespace format } // namespace clang diff --git a/clang/lib/Format/TokenAnnotator.cpp b/clang/lib/Format/TokenAnnotator.cpp index 0d5741ed76f7cb..f8bf8d9570d9a8 100644 --- a/clang/lib/Format/TokenAnnotator.cpp +++ b/clang/lib/Format/TokenAnnotator.cpp @@ -5479,6 +5479,14 @@ bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, return true; } + // Ignores the first parameter as this will be handled separately by + // BreakFunctionDefinitionParameters or AlignAfterOpenBracket. + if (Style.BinPackParameters == FormatStyle::BPPS_AlwaysOnePerLine && + 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 2ee0df99353ff5..b8bdfaaa74e10e 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); @@ -436,6 +435,19 @@ TEST(ConfigParseTest, ParsesConfiguration) { CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, FormatStyle::BILS_BeforeComma); + Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; + CHECK_PARSE("BinPackParameters: BinPack", BinPackParameters, + FormatStyle::BPPS_BinPack); + CHECK_PARSE("BinPackParameters: OnePerLine", BinPackParameters, + FormatStyle::BPPS_OnePerLine); + CHECK_PARSE("BinPackParameters: AlwaysOnePerLine", BinPackParameters, + FormatStyle::BPPS_AlwaysOnePerLine); + // For backward compatibility. + CHECK_PARSE("BinPackParameters: true", BinPackParameters, + FormatStyle::BPPS_BinPack); + CHECK_PARSE("BinPackParameters: false", BinPackParameters, + FormatStyle::BPPS_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 e895f16465491a..779109976a4f77 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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_AlwaysOnePerLine; + 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 BinPackParameters set + // to BPPS_AlwaysOnePerLine. + 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.BinPackParameters = FormatStyle::BPPS_AlwaysOnePerLine; + verifyFormat("void f(int a,\n" + " int b) {\n" + " f(a, b);\n" + "}", + BreakAlways); + + // Ensure BinPackArguments interact correctly when BinPackParameters is set to + // BPPS_AlwaysOnePerLine. + 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 + // BinPackParameters is set to BPPS_AlwaysOnePerLine. + 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 BinPackParameters set + // to BPPS_AlwaysOnePerLine. + 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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_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.BinPackParameters = FormatStyle::BPPS_BinPack; Alignment.ColumnLimit = 80; // Bug 33507 @@ -23229,7 +23320,7 @@ TEST_F(FormatTest, FormatsLambdas) { " LambdaBodyMustBeBreak);\n" "};", LLVMWithBeforeLambdaBody); - LLVMWithBeforeLambdaBody.BinPackParameters = false; + LLVMWithBeforeLambdaBody.BinPackParameters = FormatStyle::BPPS_OnePerLine; verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);", LLVMWithBeforeLambdaBody); verifyFormat( @@ -26709,7 +26800,7 @@ TEST_F(FormatTest, AlignAfterOpenBracketBlockIndent) { Medium, Style); Style.BinPackArguments = false; - Style.BinPackParameters = false; + Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; verifyFormat(Short, Style); diff --git a/clang/unittests/Format/FormatTestComments.cpp b/clang/unittests/Format/FormatTestComments.cpp index 8f84d59cbb2e2c..4eea14282c3256 100644 --- a/clang/unittests/Format/FormatTestComments.cpp +++ b/clang/unittests/Format/FormatTestComments.cpp @@ -362,6 +362,19 @@ TEST_F(FormatTestComments, KeepsParameterWithTrailingCommentsOnTheirOwnLine) { format("aaaaaaaaaa(aaaa(aaaa,\n" "aaaa), //\n" "aaaa, bbbbb);")); + + FormatStyle BreakAlways = getLLVMStyle(); + BreakAlways.BinPackParameters = FormatStyle::BPPS_AlwaysOnePerLine; + verifyFormat("int SomeFunction(a,\n" + " b, // comment\n" + " c,\n" + " d);", + BreakAlways); + verifyFormat("int SomeFunction(a,\n" + " b,\n" + " // comment\n" + " c);", + BreakAlways); } TEST_F(FormatTestComments, RemovesTrailingWhitespaceOfComments) { @@ -403,13 +416,27 @@ TEST_F(FormatTestComments, UnderstandsBlockComments) { verifyFormat("f(/* aaaaaaaaaaaaaaaaaa = */\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); - FormatStyle NoBinPacking = getLLVMStyle(); - NoBinPacking.BinPackParameters = false; + verifyFormat( + "int aaaaaaaaaaaaa(/* 1st */ int bbbbbbbbbb, /* 2nd */ int ccccccccccc,\n" + " /* 3rd */ int dddddddddddd);"); + + auto Style = getLLVMStyle(); + Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n" " /* parameter 2 */ aaaaaa,\n" " /* parameter 3 */ aaaaaa,\n" " /* parameter 4 */ aaaaaa);", - NoBinPacking); + Style); + verifyFormat("int a(/* 1st */ int b, /* 2nd */ int c);", Style); + verifyFormat("int aaaaaaaaaaaaa(/* 1st */ int bbbbbbbbbb,\n" + " /* 2nd */ int ccccccccccc,\n" + " /* 3rd */ int dddddddddddd);", + Style); + + Style.BinPackParameters = FormatStyle::BPPS_AlwaysOnePerLine; + verifyFormat("int a(/* 1st */ int b,\n" + " /* 2nd */ int c);", + Style); // Aligning block comments in macros. verifyGoogleFormat("#define A \\\n" @@ -2449,7 +2476,7 @@ TEST_F(FormatTestComments, BlockComments) { getLLVMStyleWithColumns(50))); FormatStyle NoBinPacking = getLLVMStyle(); - NoBinPacking.BinPackParameters = false; + NoBinPacking.BinPackParameters = FormatStyle::BPPS_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 d2c3459e0f846d..9b6f0c396d4dbf 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.BinPackParameters = FormatStyle::BPPS_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. + // BinPackParameters should be BPPS_BinPack 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
