diff --git a/clang/docs/ClangFormatStyleOptions.rst b/clang/docs/ClangFormatStyleOptions.rst index b746df5dab264..570cab262c115 100644 --- a/clang/docs/ClangFormatStyleOptions.rst +++ b/clang/docs/ClangFormatStyleOptions.rst @@ -245,7 +245,7 @@ the configuration (without a prefix: ``Auto``). .. note:: This currently only applies to braced initializer lists (when - ``Cpp11BracedListStyle`` is ``true``) and parentheses. + ``Cpp11BracedListStyle`` is not ``Block``) and parentheses. @@ -3816,29 +3816,72 @@ the configuration (without a prefix: ``Auto``). .. _Cpp11BracedListStyle: -**Cpp11BracedListStyle** (``Boolean``) :versionbadge:`clang-format 3.4` :ref:`¶ ` - If ``true``, format braced lists as best suited for C++11 braced - lists. +**Cpp11BracedListStyle** (``BracedListStyle``) :versionbadge:`clang-format 3.4` :ref:`¶ ` + The style to handle braced lists. - Important differences: + Possible values: - * No spaces inside the braced list. - * No line break before the closing brace. - * Indentation with the continuation indent, not with the block indent. + * ``BLS_Block`` (in configuration: ``Block``) + Best suited for pre C++11 braced lists. - Fundamentally, C++11 braced lists are formatted exactly like function - calls would be formatted in their place. If the braced list follows a name - (e.g. a type or variable name), clang-format formats as if the ``{}`` were - the parentheses of a function call with that name. If there is no name, - a zero-length name is assumed. + * Spaces inside the braced list. + * Line break before the closing brace. + * Indentation with the block indent. + + + .. code-block:: c++ + + vector x{ 1, 2, 3, 4 }; + vector x{ {}, {}, {}, {} }; + f(MyMap[{ composite, key }]); + new int[3]{ 1, 2, 3 }; + Type name{ // Comment + value + }; + + * ``BLS_FunctionCall`` (in configuration: ``FunctionCall``) + Best suited for C++11 braced lists. + + * No spaces inside the braced list. + * No line break before the closing brace. + * Indentation with the continuation indent. + + Fundamentally, C++11 braced lists are formatted exactly like function + calls would be formatted in their place. If the braced list follows a + name (e.g. a type or variable name), clang-format formats as if the + ``{}`` were the parentheses of a function call with that name. If there + is no name, a zero-length name is assumed. + + .. code-block:: c++ + + vector x{1, 2, 3, 4}; + vector x{{}, {}, {}, {}}; + f(MyMap[{composite, key}]); + new int[3]{1, 2, 3}; + Type name{ // Comment + value}; + + * ``BLS_AlignFirstComment`` (in configuration: ``AlignFirstComment``) + Same as ``FunctionCall``, except for the handling of a comment at the + begin, it then aligns everything following with the comment. + + * No spaces inside the braced list. (Even for a comment at the first + position.) + * No line break before the closing brace. + * Indentation with the continuation indent, except when followed by a + line comment, then it uses the block indent. + + + .. code-block:: c++ + + vector x{1, 2, 3, 4}; + vector x{{}, {}, {}, {}}; + f(MyMap[{composite, key}]); + new int[3]{1, 2, 3}; + Type name{// Comment + value}; - .. code-block:: c++ - true: false: - vector x{1, 2, 3, 4}; vs. vector x{ 1, 2, 3, 4 }; - vector x{{}, {}, {}, {}}; vector x{ {}, {}, {}, {} }; - f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]); - new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 }; .. _DeriveLineEnding: @@ -6625,7 +6668,7 @@ the configuration (without a prefix: ``Auto``). .. note:: This option doesn't apply to initializer braces if - ``Cpp11BracedListStyle`` is set to ``true``. + ``Cpp11BracedListStyle`` is not ``Block``. Possible values: diff --git a/clang/include/clang/Format/Format.h b/clang/include/clang/Format/Format.h index 3df5b92654094..2852c4a2916a4 100644 --- a/clang/include/clang/Format/Format.h +++ b/clang/include/clang/Format/Format.h @@ -94,7 +94,7 @@ struct FormatStyle { /// /// \note /// This currently only applies to braced initializer lists (when - /// ``Cpp11BracedListStyle`` is ``true``) and parentheses. + /// ``Cpp11BracedListStyle`` is not ``Block``) and parentheses. /// \endnote BAS_BlockIndent, }; @@ -2555,29 +2555,67 @@ struct FormatStyle { /// \version 3.7 unsigned ContinuationIndentWidth; - /// If ``true``, format braced lists as best suited for C++11 braced - /// lists. - /// - /// Important differences: - /// - /// * No spaces inside the braced list. - /// * No line break before the closing brace. - /// * Indentation with the continuation indent, not with the block indent. - /// - /// Fundamentally, C++11 braced lists are formatted exactly like function - /// calls would be formatted in their place. If the braced list follows a name - /// (e.g. a type or variable name), clang-format formats as if the ``{}`` were - /// the parentheses of a function call with that name. If there is no name, - /// a zero-length name is assumed. - /// \code - /// true: false: - /// vector x{1, 2, 3, 4}; vs. vector x{ 1, 2, 3, 4 }; - /// vector x{{}, {}, {}, {}}; vector x{ {}, {}, {}, {} }; - /// f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]); - /// new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 }; - /// \endcode + /// Different ways to handle braced lists. + enum BracedListStyle : int8_t { + /// Best suited for pre C++11 braced lists. + /// + /// * Spaces inside the braced list. + /// * Line break before the closing brace. + /// * Indentation with the block indent. + /// + /// \code + /// vector x{ 1, 2, 3, 4 }; + /// vector x{ {}, {}, {}, {} }; + /// f(MyMap[{ composite, key }]); + /// new int[3]{ 1, 2, 3 }; + /// Type name{ // Comment + /// value + /// }; + /// \endcode + BLS_Block, + /// Best suited for C++11 braced lists. + /// + /// * No spaces inside the braced list. + /// * No line break before the closing brace. + /// * Indentation with the continuation indent. + /// + /// Fundamentally, C++11 braced lists are formatted exactly like function + /// calls would be formatted in their place. If the braced list follows a + /// name (e.g. a type or variable name), clang-format formats as if the + /// ``{}`` were the parentheses of a function call with that name. If there + /// is no name, a zero-length name is assumed. + /// \code + /// vector x{1, 2, 3, 4}; + /// vector x{{}, {}, {}, {}}; + /// f(MyMap[{composite, key}]); + /// new int[3]{1, 2, 3}; + /// Type name{ // Comment + /// value}; + /// \endcode + BLS_FunctionCall, + /// Same as ``FunctionCall``, except for the handling of a comment at the + /// begin, it then aligns everything following with the comment. + /// + /// * No spaces inside the braced list. (Even for a comment at the first + /// position.) + /// * No line break before the closing brace. + /// * Indentation with the continuation indent, except when followed by a + /// line comment, then it uses the block indent. + /// + /// \code + /// vector x{1, 2, 3, 4}; + /// vector x{{}, {}, {}, {}}; + /// f(MyMap[{composite, key}]); + /// new int[3]{1, 2, 3}; + /// Type name{// Comment + /// value}; + /// \endcode + BLS_AlignFirstComment, + }; + + /// The style to handle braced lists. /// \version 3.4 - bool Cpp11BracedListStyle; + BracedListStyle Cpp11BracedListStyle; /// This option is **deprecated**. See ``DeriveLF`` and ``DeriveCRLF`` of /// ``LineEnding``. @@ -4933,7 +4971,7 @@ struct FormatStyle { /// Specifies when to insert a space in empty braces. /// \note /// This option doesn't apply to initializer braces if - /// ``Cpp11BracedListStyle`` is set to ``true``. + /// ``Cpp11BracedListStyle`` is not ``Block``. /// \endnote /// \version 22 SpaceInEmptyBracesStyle SpaceInEmptyBraces; diff --git a/clang/lib/Format/BreakableToken.cpp b/clang/lib/Format/BreakableToken.cpp index 29db20067c361..994a427517ffc 100644 --- a/clang/lib/Format/BreakableToken.cpp +++ b/clang/lib/Format/BreakableToken.cpp @@ -306,8 +306,10 @@ BreakableStringLiteralUsingOperators::BreakableStringLiteralUsingOperators( // In Verilog, all strings are quoted by double quotes, joined by commas, // and wrapped in braces. The comma is always before the newline. assert(QuoteStyle == DoubleQuotes); - LeftBraceQuote = Style.Cpp11BracedListStyle ? "{\"" : "{ \""; - RightBraceQuote = Style.Cpp11BracedListStyle ? "\"}" : "\" }"; + LeftBraceQuote = + Style.Cpp11BracedListStyle != FormatStyle::BLS_Block ? "{\"" : "{ \""; + RightBraceQuote = + Style.Cpp11BracedListStyle != FormatStyle::BLS_Block ? "\"}" : "\" }"; Postfix = "\","; Prefix = "\""; } else { diff --git a/clang/lib/Format/ContinuationIndenter.cpp b/clang/lib/Format/ContinuationIndenter.cpp index b7d85693b2082..26a95421775f3 100644 --- a/clang/lib/Format/ContinuationIndenter.cpp +++ b/clang/lib/Format/ContinuationIndenter.cpp @@ -833,7 +833,7 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun, auto IsOpeningBracket = [&](const FormatToken &Tok) { auto IsStartOfBracedList = [&]() { return Tok.is(tok::l_brace) && Tok.isNot(BK_Block) && - Style.Cpp11BracedListStyle; + Style.Cpp11BracedListStyle != FormatStyle::BLS_Block; }; if (Tok.isNoneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) && !IsStartOfBracedList()) { @@ -925,7 +925,12 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun, TT_TableGenDAGArgOpenerToBreak) && !(Current.MacroParent && Previous.MacroParent) && (Current.isNot(TT_LineComment) || - Previous.isOneOf(BK_BracedInit, TT_VerilogMultiLineListLParen)) && + (Previous.is(BK_BracedInit) && + (Style.Cpp11BracedListStyle != FormatStyle::BLS_FunctionCall || + !Previous.Previous || + Previous.Previous->isNoneOf(tok::identifier, tok::l_paren, + BK_BracedInit))) || + Previous.is(TT_VerilogMultiLineListLParen)) && !IsInTemplateString(Current)) { CurrentState.Indent = State.Column + Spaces; CurrentState.IsAligned = true; diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp index 093e88ffcc85d..edd126c7724b8 100644 --- a/clang/lib/Format/Format.cpp +++ b/clang/lib/Format/Format.cpp @@ -304,6 +304,18 @@ struct ScalarEnumerationTraits { } }; +template <> struct ScalarEnumerationTraits { + static void enumeration(IO &IO, FormatStyle::BracedListStyle &Value) { + IO.enumCase(Value, "Block", FormatStyle::BLS_Block); + IO.enumCase(Value, "FunctionCall", FormatStyle::BLS_FunctionCall); + IO.enumCase(Value, "AlignFirstComment", FormatStyle::BLS_AlignFirstComment); + + // For backward compatibility. + IO.enumCase(Value, "false", FormatStyle::BLS_Block); + IO.enumCase(Value, "true", FormatStyle::BLS_AlignFirstComment); + } +}; + template <> struct ScalarEnumerationTraits { static void enumeration(IO &IO, FormatStyle::DAGArgStyle &Value) { IO.enumCase(Value, "DontBreak", FormatStyle::DAS_DontBreak); @@ -1628,7 +1640,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) { LLVMStyle.CompactNamespaces = false; LLVMStyle.ConstructorInitializerIndentWidth = 4; LLVMStyle.ContinuationIndentWidth = 4; - LLVMStyle.Cpp11BracedListStyle = true; + LLVMStyle.Cpp11BracedListStyle = FormatStyle::BLS_AlignFirstComment; LLVMStyle.DerivePointerAlignment = false; LLVMStyle.DisableFormat = false; LLVMStyle.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never; @@ -1904,7 +1916,7 @@ FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) { // beneficial there. Investigate turning this on once proper string reflow // has been implemented. GoogleStyle.BreakStringLiterals = false; - GoogleStyle.Cpp11BracedListStyle = false; + GoogleStyle.Cpp11BracedListStyle = FormatStyle::BLS_Block; GoogleStyle.SpacesInContainerLiterals = false; } else if (Language == FormatStyle::LK_ObjC) { GoogleStyle.AlwaysBreakBeforeMultilineStrings = false; @@ -2000,7 +2012,7 @@ FormatStyle getMozillaStyle() { MozillaStyle.BreakTemplateDeclarations = FormatStyle::BTDS_Yes; MozillaStyle.ConstructorInitializerIndentWidth = 2; MozillaStyle.ContinuationIndentWidth = 2; - MozillaStyle.Cpp11BracedListStyle = false; + MozillaStyle.Cpp11BracedListStyle = FormatStyle::BLS_Block; MozillaStyle.FixNamespaceComments = false; MozillaStyle.IndentCaseLabels = true; MozillaStyle.ObjCSpaceAfterProperty = true; @@ -2023,7 +2035,7 @@ FormatStyle getWebKitStyle() { Style.BreakBeforeBraces = FormatStyle::BS_WebKit; Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; Style.ColumnLimit = 0; - Style.Cpp11BracedListStyle = false; + Style.Cpp11BracedListStyle = FormatStyle::BLS_Block; Style.FixNamespaceComments = false; Style.IndentWidth = 4; Style.NamespaceIndentation = FormatStyle::NI_Inner; @@ -2043,7 +2055,7 @@ FormatStyle getGNUStyle() { Style.BreakBeforeBraces = FormatStyle::BS_GNU; Style.BreakBeforeTernaryOperators = true; Style.ColumnLimit = 79; - Style.Cpp11BracedListStyle = false; + Style.Cpp11BracedListStyle = FormatStyle::BLS_Block; Style.FixNamespaceComments = false; Style.KeepFormFeed = true; Style.SpaceBeforeParens = FormatStyle::SBPO_Always; diff --git a/clang/lib/Format/FormatToken.cpp b/clang/lib/Format/FormatToken.cpp index cf02280617794..d1c62642efd43 100644 --- a/clang/lib/Format/FormatToken.cpp +++ b/clang/lib/Format/FormatToken.cpp @@ -67,7 +67,7 @@ bool FormatToken::isBlockIndentedInitRBrace(const FormatStyle &Style) const { assert(is(tok::r_brace)); assert(MatchingParen); assert(MatchingParen->is(tok::l_brace)); - if (!Style.Cpp11BracedListStyle || + if (Style.Cpp11BracedListStyle == FormatStyle::BLS_Block || Style.AlignAfterOpenBracket != FormatStyle::BAS_BlockIndent) { return false; } @@ -88,7 +88,8 @@ bool FormatToken::opensBlockOrBlockTypeList(const FormatStyle &Style) const { return is(TT_ArrayInitializerLSquare) || is(TT_ProtoExtensionLSquare) || (is(tok::l_brace) && (getBlockKind() == BK_Block || is(TT_DictLiteral) || - (!Style.Cpp11BracedListStyle && NestingLevel == 0))) || + (Style.Cpp11BracedListStyle == FormatStyle::BLS_Block && + NestingLevel == 0))) || (is(tok::less) && Style.isProto()); } @@ -184,7 +185,8 @@ void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) { // In C++11 braced list style, we should not format in columns unless they // have many items (20 or more) or we allow bin-packing of function call // arguments. - if (Style.Cpp11BracedListStyle && !Style.BinPackArguments && + if (Style.Cpp11BracedListStyle != FormatStyle::BLS_Block && + !Style.BinPackArguments && (Commas.size() < 19 || !Style.BinPackLongBracedList)) { return; } @@ -228,7 +230,7 @@ void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) { ItemEnd = Token->MatchingParen; const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment(); ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd)); - if (Style.Cpp11BracedListStyle && + if (Style.Cpp11BracedListStyle != FormatStyle::BLS_Block && !ItemEnd->Previous->isTrailingComment()) { // In Cpp11 braced list style, the } and possibly other subsequent // tokens will need to stay on a line with the last element. diff --git a/clang/lib/Format/TokenAnnotator.cpp b/clang/lib/Format/TokenAnnotator.cpp index ffbd3839e8eb7..778d2ca938bdd 100644 --- a/clang/lib/Format/TokenAnnotator.cpp +++ b/clang/lib/Format/TokenAnnotator.cpp @@ -4094,7 +4094,8 @@ void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) const { if (Current->is(TT_LineComment)) { if (Prev->is(BK_BracedInit) && Prev->opensScope()) { Current->SpacesRequiredBefore = - (Style.Cpp11BracedListStyle && !Style.SpacesInParensOptions.Other) + (Style.Cpp11BracedListStyle == FormatStyle::BLS_AlignFirstComment && + !Style.SpacesInParensOptions.Other) ? 0 : 1; } else if (Prev->is(TT_VerilogMultiLineListLParen)) { @@ -4445,8 +4446,10 @@ unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, (Left.ParameterCount <= 1 || Style.AllowAllArgumentsOnNextLine)) { return 0; } - if (Left.is(tok::l_brace) && !Style.Cpp11BracedListStyle) + if (Left.is(tok::l_brace) && + Style.Cpp11BracedListStyle == FormatStyle::BLS_Block) { return 19; + } return Left.ParameterCount > 1 ? Style.PenaltyBreakBeforeFirstCallParameter : 19; } @@ -4612,7 +4615,7 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, // Format empty list as `<>`. if (Left.is(tok::less) && Right.is(tok::greater)) return false; - return !Style.Cpp11BracedListStyle; + return Style.Cpp11BracedListStyle == FormatStyle::BLS_Block; } // Don't attempt to format operator<(), as it is handled later. if (Right.isNot(TT_OverloadedOperatorLParen)) @@ -4780,7 +4783,8 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, const auto SpaceRequiredForArrayInitializerLSquare = [](const FormatToken &LSquareTok, const FormatStyle &Style) { return Style.SpacesInContainerLiterals || - (Style.isProto() && !Style.Cpp11BracedListStyle && + (Style.isProto() && + Style.Cpp11BracedListStyle == FormatStyle::BLS_Block && LSquareTok.endsSequence(tok::l_square, tok::colon, TT_SelectorName)); }; @@ -4813,7 +4817,8 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, if ((Left.is(tok::l_brace) && Left.isNot(BK_Block)) || (Right.is(tok::r_brace) && Right.MatchingParen && Right.MatchingParen->isNot(BK_Block))) { - return !Style.Cpp11BracedListStyle || Style.SpacesInParensOptions.Other; + return Style.Cpp11BracedListStyle == FormatStyle::BLS_Block || + Style.SpacesInParensOptions.Other; } if (Left.is(TT_BlockComment)) { // No whitespace in x(/*foo=*/1), except for JavaScript. @@ -4995,7 +5000,7 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, Left.Children.empty()) { if (Left.is(BK_Block)) return Style.SpaceInEmptyBraces != FormatStyle::SIEB_Never; - if (Style.Cpp11BracedListStyle) { + if (Style.Cpp11BracedListStyle != FormatStyle::BLS_Block) { return Style.SpacesInParens == FormatStyle::SIPO_Custom && Style.SpacesInParensOptions.InEmptyParentheses; } @@ -5077,7 +5082,7 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, if (Left.MatchingParen && Left.MatchingParen->is(TT_ProtoExtensionLSquare) && Right.isOneOf(tok::l_brace, tok::less)) { - return !Style.Cpp11BracedListStyle; + return Style.Cpp11BracedListStyle == FormatStyle::BLS_Block; } // A percent is probably part of a formatting specification, such as %lld. if (Left.is(tok::percent)) @@ -5517,7 +5522,7 @@ bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, if (Left.is(tok::greater) && Right.is(tok::greater)) { if (Style.isTextProto() || (Style.Language == FormatStyle::LK_Proto && Left.is(TT_DictLiteral))) { - return !Style.Cpp11BracedListStyle; + return Style.Cpp11BracedListStyle == FormatStyle::BLS_Block; } return Right.is(TT_TemplateCloser) && Left.is(TT_TemplateCloser) && ((Style.Standard < FormatStyle::LS_Cpp11) || @@ -6378,7 +6383,7 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line, return false; } if (Left.is(tok::equal) && Right.is(tok::l_brace) && - !Style.Cpp11BracedListStyle) { + Style.Cpp11BracedListStyle == FormatStyle::BLS_Block) { return false; } if (Left.is(TT_AttributeLParen) || diff --git a/clang/lib/Format/WhitespaceManager.cpp b/clang/lib/Format/WhitespaceManager.cpp index 7348a3af8cf95..92612946ce87d 100644 --- a/clang/lib/Format/WhitespaceManager.cpp +++ b/clang/lib/Format/WhitespaceManager.cpp @@ -1238,7 +1238,8 @@ void WhitespaceManager::alignArrayInitializersRightJustified( if (!CellDescs.isRectangular()) return; - const int BracePadding = Style.Cpp11BracedListStyle ? 0 : 1; + const int BracePadding = + Style.Cpp11BracedListStyle != FormatStyle::BLS_Block ? 0 : 1; auto &Cells = CellDescs.Cells; // Now go through and fixup the spaces. auto *CellIter = Cells.begin(); @@ -1314,7 +1315,8 @@ void WhitespaceManager::alignArrayInitializersLeftJustified( if (!CellDescs.isRectangular()) return; - const int BracePadding = Style.Cpp11BracedListStyle ? 0 : 1; + const int BracePadding = + Style.Cpp11BracedListStyle != FormatStyle::BLS_Block ? 0 : 1; auto &Cells = CellDescs.Cells; // Now go through and fixup the spaces. auto *CellIter = Cells.begin(); diff --git a/clang/unittests/Format/ConfigParseTest.cpp b/clang/unittests/Format/ConfigParseTest.cpp index 52f02c3ba8686..6488e38badee7 100644 --- a/clang/unittests/Format/ConfigParseTest.cpp +++ b/clang/unittests/Format/ConfigParseTest.cpp @@ -176,7 +176,6 @@ TEST(ConfigParseTest, ParsesConfigurationBools) { CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); CHECK_PARSE_BOOL(BreakStringLiterals); CHECK_PARSE_BOOL(CompactNamespaces); - CHECK_PARSE_BOOL(Cpp11BracedListStyle); CHECK_PARSE_BOOL(DerivePointerAlignment); CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); CHECK_PARSE_BOOL(DisableFormat); @@ -1139,6 +1138,18 @@ TEST(ConfigParseTest, ParsesConfiguration) { FormatStyle::SDS_Leave); CHECK_PARSE("SeparateDefinitionBlocks: Never", SeparateDefinitionBlocks, FormatStyle::SDS_Never); + + CHECK_PARSE("Cpp11BracedListStyle: Block", Cpp11BracedListStyle, + FormatStyle::BLS_Block); + CHECK_PARSE("Cpp11BracedListStyle: FunctionCall", Cpp11BracedListStyle, + FormatStyle::BLS_FunctionCall); + CHECK_PARSE("Cpp11BracedListStyle: AlignFirstComment", Cpp11BracedListStyle, + FormatStyle::BLS_AlignFirstComment); + // For backward compatibility: + CHECK_PARSE("Cpp11BracedListStyle: false", Cpp11BracedListStyle, + FormatStyle::BLS_Block); + CHECK_PARSE("Cpp11BracedListStyle: true", Cpp11BracedListStyle, + FormatStyle::BLS_AlignFirstComment); } TEST(ConfigParseTest, ParsesConfigurationWithLanguages) { diff --git a/clang/unittests/Format/FormatTest.cpp b/clang/unittests/Format/FormatTest.cpp index b9ad930164944..0fb8139832d5e 100644 --- a/clang/unittests/Format/FormatTest.cpp +++ b/clang/unittests/Format/FormatTest.cpp @@ -14363,7 +14363,7 @@ TEST_F(FormatTest, LayoutCxx11BraceInitializers) { BreakBeforeLambdaBody); FormatStyle ExtraSpaces = getLLVMStyle(); - ExtraSpaces.Cpp11BracedListStyle = false; + ExtraSpaces.Cpp11BracedListStyle = FormatStyle::BLS_Block; ExtraSpaces.ColumnLimit = 75; verifyFormat("vector x{ 1, 2, 3, 4 };", ExtraSpaces); verifyFormat("vector x{ {}, {}, {}, {} };", ExtraSpaces); @@ -20346,7 +20346,7 @@ TEST_F(FormatTest, AlignConsecutiveDeclarations) { " return 0;\n" "}()};", BracedAlign); - BracedAlign.Cpp11BracedListStyle = false; + BracedAlign.Cpp11BracedListStyle = FormatStyle::BLS_Block; verifyFormat("const auto result{ []() {\n" " const auto something = 1;\n" " return 2;\n" @@ -21953,14 +21953,14 @@ TEST_F(FormatTest, CatchAlignArrayOfStructuresRightAlignment) { "});", Style); - Style.Cpp11BracedListStyle = false; + Style.Cpp11BracedListStyle = FormatStyle::BLS_Block; verifyFormat("struct test demo[] = {\n" " { 56, 23, \"hello\" },\n" " { -1, 93463, \"world\" },\n" " { 7, 5, \"!!\" }\n" "};", Style); - Style.Cpp11BracedListStyle = true; + Style.Cpp11BracedListStyle = FormatStyle::BLS_AlignFirstComment; Style.ColumnLimit = 0; verifyFormat( @@ -22220,14 +22220,14 @@ TEST_F(FormatTest, CatchAlignArrayOfStructuresLeftAlignment) { " };", Style); - Style.Cpp11BracedListStyle = false; + Style.Cpp11BracedListStyle = FormatStyle::BLS_Block; verifyFormat("struct test demo[] = {\n" " { 56, 23, \"hello\" },\n" " { -1, 93463, \"world\" },\n" " { 7, 5, \"!!\" }\n" "};", Style); - Style.Cpp11BracedListStyle = true; + Style.Cpp11BracedListStyle = FormatStyle::BLS_AlignFirstComment; Style.ColumnLimit = 0; verifyFormat( diff --git a/clang/unittests/Format/FormatTestCSharp.cpp b/clang/unittests/Format/FormatTestCSharp.cpp index ea85ed6140dd0..d7fb15d5dd9ac 100644 --- a/clang/unittests/Format/FormatTestCSharp.cpp +++ b/clang/unittests/Format/FormatTestCSharp.cpp @@ -1194,7 +1194,7 @@ TEST_F(FormatTestCSharp, CSharpSpaces) { Style.SpaceBeforeSquareBrackets = false; Style.SpacesInSquareBrackets = false; Style.SpaceBeforeCpp11BracedList = true; - Style.Cpp11BracedListStyle = false; + Style.Cpp11BracedListStyle = FormatStyle::BLS_Block; Style.SpacesInContainerLiterals = false; Style.SpaceAfterCStyleCast = false; diff --git a/clang/unittests/Format/FormatTestComments.cpp b/clang/unittests/Format/FormatTestComments.cpp index 69026bce98705..fc80bf4024fd9 100644 --- a/clang/unittests/Format/FormatTestComments.cpp +++ b/clang/unittests/Format/FormatTestComments.cpp @@ -4699,6 +4699,58 @@ TEST_F(FormatTestComments, SplitCommentIntroducers) { getLLVMStyleWithColumns(10))); } +TEST_F(FormatTestComments, LineCommentsOnStartOfFunctionCall) { + auto Style = getLLVMStyle(); + + EXPECT_EQ(Style.Cpp11BracedListStyle, FormatStyle::BLS_AlignFirstComment); + verifyFormat("Type name{// Comment\n" + " value};", + Style); + + Style.Cpp11BracedListStyle = FormatStyle::BLS_Block; + verifyFormat("Type name{ // Comment\n" + " value\n" + "};", + Style); + + Style.Cpp11BracedListStyle = FormatStyle::BLS_FunctionCall; + verifyFormat("Type name{ // Comment\n" + " value};", + Style); + + verifyFormat("T foo( // Comment\n" + " arg);", + Style); + + verifyFormat("T bar{ // Comment\n" + " arg};", + Style); + + verifyFormat("T baz({ // Comment\n" + " arg});", + Style); + + verifyFormat("T baz{{ // Comment\n" + " arg}};", + Style); + + verifyFormat("T b0z(f( // Comment\n" + " arg));", + Style); + + verifyFormat("T b0z(F{ // Comment\n" + " arg});", + Style); + + verifyFormat("func( // Comment\n" + " arg);", + Style); + + verifyFormat("func({ // Comment\n" + " arg});", + Style); +} + } // end namespace } // namespace test } // end namespace format diff --git a/clang/unittests/Format/FormatTestJava.cpp b/clang/unittests/Format/FormatTestJava.cpp index 127556488bab0..1416614bae29a 100644 --- a/clang/unittests/Format/FormatTestJava.cpp +++ b/clang/unittests/Format/FormatTestJava.cpp @@ -236,7 +236,7 @@ TEST_F(FormatTestJava, ArrayInitializers) { "};"); FormatStyle Style = getStyleWithColumns(65); - Style.Cpp11BracedListStyle = false; + Style.Cpp11BracedListStyle = FormatStyle::BLS_Block; verifyFormat( "expected = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,\n" " 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };", diff --git a/clang/unittests/Format/FormatTestTextProto.cpp b/clang/unittests/Format/FormatTestTextProto.cpp index fd65c9a58db5d..6cddb838a0abe 100644 --- a/clang/unittests/Format/FormatTestTextProto.cpp +++ b/clang/unittests/Format/FormatTestTextProto.cpp @@ -514,7 +514,7 @@ TEST_F(FormatTestTextProto, FormatsRepeatedListInitializers) { "key: value"); auto Style = getDefaultStyle(); - Style.Cpp11BracedListStyle = true; + Style.Cpp11BracedListStyle = FormatStyle::BLS_AlignFirstComment; verifyFormat("keys: [1]", Style); } diff --git a/clang/unittests/Format/FormatTestVerilog.cpp b/clang/unittests/Format/FormatTestVerilog.cpp index 5c50ae6fcfac8..63e2cadfdd7a1 100644 --- a/clang/unittests/Format/FormatTestVerilog.cpp +++ b/clang/unittests/Format/FormatTestVerilog.cpp @@ -1287,7 +1287,7 @@ TEST_F(FormatTestVerilog, StringLiteral) { getStyleWithColumns(getDefaultStyle(), 32)); // Space around braces should be correct. auto Style = getStyleWithColumns(getDefaultStyle(), 24); - Style.Cpp11BracedListStyle = false; + Style.Cpp11BracedListStyle = FormatStyle::BLS_Block; verifyFormat(R"(x({ "xxxxxxxxxxxxxxxx ", "xxxx" });)", R"(x("xxxxxxxxxxxxxxxx xxxx");)", Style);