Author: Björn Schäpers Date: 2025-10-18T22:25:28Z New Revision: cf28a476fb0fae2b19112ce0532b308e79d7bf39
URL: https://github.com/llvm/llvm-project/commit/cf28a476fb0fae2b19112ce0532b308e79d7bf39 DIFF: https://github.com/llvm/llvm-project/commit/cf28a476fb0fae2b19112ce0532b308e79d7bf39.diff LOG: [clang-format] Remove special handling of comments after brace/paren (#71672) Fixes http://llvm.org/PR55487 (#55487) The code did not match the documentation about Cpp11BracedListStyle. Changed handling of comments after opening braces, which are supposedly function call like to behave exactly like their parenthesis counter part. Added: Modified: clang/docs/ClangFormatStyleOptions.rst clang/include/clang/Format/Format.h clang/lib/Format/BreakableToken.cpp clang/lib/Format/ContinuationIndenter.cpp clang/lib/Format/Format.cpp clang/lib/Format/FormatToken.cpp clang/lib/Format/TokenAnnotator.cpp clang/lib/Format/WhitespaceManager.cpp clang/unittests/Format/ConfigParseTest.cpp clang/unittests/Format/FormatTest.cpp clang/unittests/Format/FormatTestCSharp.cpp clang/unittests/Format/FormatTestComments.cpp clang/unittests/Format/FormatTestJava.cpp clang/unittests/Format/FormatTestTextProto.cpp clang/unittests/Format/FormatTestVerilog.cpp Removed: ################################################################################ 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:`¶ <Cpp11BracedListStyle>` - If ``true``, format braced lists as best suited for C++11 braced - lists. +**Cpp11BracedListStyle** (``BracedListStyle``) :versionbadge:`clang-format 3.4` :ref:`¶ <Cpp11BracedListStyle>` + The style to handle braced lists. - Important diff erences: + 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<int> x{ 1, 2, 3, 4 }; + vector<T> 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<int> x{1, 2, 3, 4}; + vector<T> 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<int> x{1, 2, 3, 4}; + vector<T> x{{}, {}, {}, {}}; + f(MyMap[{composite, key}]); + new int[3]{1, 2, 3}; + Type name{// Comment + value}; - .. code-block:: c++ - true: false: - vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 }; - vector<T> x{{}, {}, {}, {}}; vector<T> 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 diff erences: - /// - /// * 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<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 }; - /// vector<T> x{{}, {}, {}, {}}; vector<T> 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<int> x{ 1, 2, 3, 4 }; + /// vector<T> 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<int> x{1, 2, 3, 4}; + /// vector<T> 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<int> x{1, 2, 3, 4}; + /// vector<T> 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<FormatStyle::BreakTemplateDeclarationsStyle> { } }; +template <> struct ScalarEnumerationTraits<FormatStyle::BracedListStyle> { + 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<FormatStyle::DAGArgStyle> { 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<int> x{ 1, 2, 3, 4 };", ExtraSpaces); verifyFormat("vector<T> 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); _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
