Skip to content

Commit f6de80f

Browse files
HazardyKnusperkeksHazardyKnusperkeks
committed
[clang-format] Remove special handling of comments after brace/paren
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.
1 parent 7e7c923 commit f6de80f

15 files changed

+302
-75
lines changed

‎clang/docs/ClangFormatStyleOptions.rst‎

Lines changed: 61 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -3816,29 +3816,72 @@ the configuration (without a prefix: ``Auto``).
38163816

38173817
.. _Cpp11BracedListStyle:
38183818

3819-
**Cpp11BracedListStyle** (``Boolean``) :versionbadge:`clang-format 3.4` :ref:`<Cpp11BracedListStyle>`
3820-
If ``true``, format braced lists as best suited for C++11 braced
3821-
lists.
3819+
**Cpp11BracedListStyle** (``CppBracedListStyleStyle``) :versionbadge:`clang-format 3.4` :ref:`<Cpp11BracedListStyle>`
3820+
The style to handle braced lists.
38223821

3823-
Important differences:
3822+
Possible values:
38243823

3825-
* No spaces inside the braced list.
3826-
* No line break before the closing brace.
3827-
* Indentation with the continuation indent, not with the block indent.
3824+
* ``CBLSS_Block`` (in configuration: ``Block``)
3825+
Best suited for pre C++11 braced lists.
38283826

3829-
Fundamentally, C++11 braced lists are formatted exactly like function
3830-
calls would be formatted in their place. If the braced list follows a name
3831-
(e.g. a type or variable name), clang-format formats as if the ``{}`` were
3832-
the parentheses of a function call with that name. If there is no name,
3833-
a zero-length name is assumed.
3827+
* Spaces inside the braced list.
3828+
* Line break before the closing brace.
3829+
* Indentation with the block indent.
3830+
3831+
3832+
.. code-block:: c++
3833+
3834+
vector<int> x{ 1, 2, 3, 4 };
3835+
vector<T> x{ {}, {}, {}, {} };
3836+
f(MyMap[{ composite, key }]);
3837+
new int[3]{ 1, 2, 3 };
3838+
Type name{ //Comment
3839+
value
3840+
};
3841+
3842+
* ``CBLSS_FunctionCall`` (in configuration: ``FunctionCall``)
3843+
Best suited for C++11 braced lists.
3844+
3845+
* No spaces inside the braced list.
3846+
* No line break before the closing brace.
3847+
* Indentation with the continuation indent.
3848+
3849+
Fundamentally, C++11 braced lists are formatted exactly like function
3850+
calls would be formatted in their place. If the braced list follows a
3851+
name (e.g. a type or variable name), clang-format formats as if the
3852+
``{}`` were the parentheses of a function call with that name. If there
3853+
is no name, a zero-length name is assumed.
3854+
3855+
.. code-block:: c++
3856+
3857+
vector<int> x{1, 2, 3, 4};
3858+
vector<T> x{{}, {}, {}, {}};
3859+
f(MyMap[{composite, key}]);
3860+
new int[3]{1, 2, 3};
3861+
Type name{ //Comment
3862+
value};
3863+
3864+
* ``CBLSS_ToBeNamed`` (in configuration: ``ToBeNamed``)
3865+
Same as ``FunctionCall``, except for the handling of a comment at the
3866+
begin, it then aligns everything following with the comment.
3867+
3868+
* No spaces inside the braced list. (Even for a comment at the first
3869+
position.)
3870+
* No line break before the closing brace.
3871+
* Indentation with the continuation indent, except when followed by a
3872+
line comment, then it uses the block indent.
3873+
3874+
3875+
.. code-block:: c++
3876+
3877+
vector<int> x{1, 2, 3, 4};
3878+
vector<T> x{{}, {}, {}, {}};
3879+
f(MyMap[{composite, key}]);
3880+
new int[3]{1, 2, 3};
3881+
Type name{//Comment
3882+
value};
38343883

3835-
.. code-block:: c++
38363884

3837-
true: false:
3838-
vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 };
3839-
vector<T> x{{}, {}, {}, {}}; vector<T> x{ {}, {}, {}, {} };
3840-
f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]);
3841-
new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 };
38423885

38433886
.. _DeriveLineEnding:
38443887

‎clang/include/clang/Format/Format.h‎

Lines changed: 60 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -2555,29 +2555,67 @@ struct FormatStyle {
25552555
/// \version 3.7
25562556
unsigned ContinuationIndentWidth;
25572557

2558-
/// If ``true``, format braced lists as best suited for C++11 braced
2559-
/// lists.
2560-
///
2561-
/// Important differences:
2562-
///
2563-
/// * No spaces inside the braced list.
2564-
/// * No line break before the closing brace.
2565-
/// * Indentation with the continuation indent, not with the block indent.
2566-
///
2567-
/// Fundamentally, C++11 braced lists are formatted exactly like function
2568-
/// calls would be formatted in their place. If the braced list follows a name
2569-
/// (e.g. a type or variable name), clang-format formats as if the ``{}`` were
2570-
/// the parentheses of a function call with that name. If there is no name,
2571-
/// a zero-length name is assumed.
2572-
/// \code
2573-
/// true: false:
2574-
/// vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 };
2575-
/// vector<T> x{{}, {}, {}, {}}; vector<T> x{ {}, {}, {}, {} };
2576-
/// f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]);
2577-
/// new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 };
2578-
/// \endcode
2558+
/// Different ways to handle braced lists.
2559+
enum CppBracedListStyleStyle : int8_t {
2560+
/// Best suited for pre C++11 braced lists.
2561+
///
2562+
/// * Spaces inside the braced list.
2563+
/// * Line break before the closing brace.
2564+
/// * Indentation with the block indent.
2565+
///
2566+
/// \code
2567+
/// vector<int> x{ 1, 2, 3, 4 };
2568+
/// vector<T> x{ {}, {}, {}, {} };
2569+
/// f(MyMap[{ composite, key }]);
2570+
/// new int[3]{ 1, 2, 3 };
2571+
/// Type name{ //Comment
2572+
/// value
2573+
/// };
2574+
/// \endcode
2575+
CBLSS_Block,
2576+
/// Best suited for C++11 braced lists.
2577+
///
2578+
/// * No spaces inside the braced list.
2579+
/// * No line break before the closing brace.
2580+
/// * Indentation with the continuation indent.
2581+
///
2582+
/// Fundamentally, C++11 braced lists are formatted exactly like function
2583+
/// calls would be formatted in their place. If the braced list follows a
2584+
/// name (e.g. a type or variable name), clang-format formats as if the
2585+
/// ``{}`` were the parentheses of a function call with that name. If there
2586+
/// is no name, a zero-length name is assumed.
2587+
/// \code
2588+
/// vector<int> x{1, 2, 3, 4};
2589+
/// vector<T> x{{}, {}, {}, {}};
2590+
/// f(MyMap[{composite, key}]);
2591+
/// new int[3]{1, 2, 3};
2592+
/// Type name{ //Comment
2593+
/// value};
2594+
/// \endcode
2595+
CBLSS_FunctionCall,
2596+
/// Same as ``FunctionCall``, except for the handling of a comment at the
2597+
/// begin, it then aligns everything following with the comment.
2598+
///
2599+
/// * No spaces inside the braced list. (Even for a comment at the first
2600+
/// position.)
2601+
/// * No line break before the closing brace.
2602+
/// * Indentation with the continuation indent, except when followed by a
2603+
/// line comment, then it uses the block indent.
2604+
///
2605+
/// \code
2606+
/// vector<int> x{1, 2, 3, 4};
2607+
/// vector<T> x{{}, {}, {}, {}};
2608+
/// f(MyMap[{composite, key}]);
2609+
/// new int[3]{1, 2, 3};
2610+
/// Type name{//Comment
2611+
/// value};
2612+
/// \endcode
2613+
CBLSS_ToBeNamed,
2614+
};
2615+
2616+
/// The style to handle braced lists.
25792617
/// \version 3.4
2580-
bool Cpp11BracedListStyle;
2618+
CppBracedListStyleStyle Cpp11BracedListStyle;
25812619

25822620
/// This option is **deprecated**. See ``DeriveLF`` and ``DeriveCRLF`` of
25832621
/// ``LineEnding``.

‎clang/lib/Format/BreakableToken.cpp‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -306,8 +306,10 @@ BreakableStringLiteralUsingOperators::BreakableStringLiteralUsingOperators(
306306
// In Verilog, all strings are quoted by double quotes, joined by commas,
307307
// and wrapped in braces. The comma is always before the newline.
308308
assert(QuoteStyle == DoubleQuotes);
309-
LeftBraceQuote = Style.Cpp11BracedListStyle ? "{\"" : "{ \"";
310-
RightBraceQuote = Style.Cpp11BracedListStyle ? "\"}" : "\" }";
309+
LeftBraceQuote =
310+
Style.Cpp11BracedListStyle != FormatStyle::CBLSS_Block ? "{\"" : "{ \"";
311+
RightBraceQuote =
312+
Style.Cpp11BracedListStyle != FormatStyle::CBLSS_Block ? "\"}" : "\" }";
311313
Postfix = "\",";
312314
Prefix = "\"";
313315
} else {

‎clang/lib/Format/ContinuationIndenter.cpp‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -833,7 +833,7 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
833833
auto IsOpeningBracket = [&](const FormatToken &Tok) {
834834
auto IsStartOfBracedList = [&]() {
835835
return Tok.is(tok::l_brace) && Tok.isNot(BK_Block) &&
836-
Style.Cpp11BracedListStyle;
836+
Style.Cpp11BracedListStyle != FormatStyle::CBLSS_Block;
837837
};
838838
if (Tok.isNoneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) &&
839839
!IsStartOfBracedList()) {
@@ -925,7 +925,11 @@ void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
925925
TT_TableGenDAGArgOpenerToBreak) &&
926926
!(Current.MacroParent && Previous.MacroParent) &&
927927
(Current.isNot(TT_LineComment) ||
928-
Previous.isOneOf(BK_BracedInit, TT_VerilogMultiLineListLParen)) &&
928+
(Previous.is(BK_BracedInit) &&
929+
(Style.Cpp11BracedListStyle != FormatStyle::CBLSS_FunctionCall ||
930+
!Previous.Previous ||
931+
Previous.Previous->isNoneOf(tok::identifier, tok::l_paren))) ||
932+
Previous.is(TT_VerilogMultiLineListLParen)) &&
929933
!IsInTemplateString(Current)) {
930934
CurrentState.Indent = State.Column + Spaces;
931935
CurrentState.IsAligned = true;

‎clang/lib/Format/Format.cpp‎

Lines changed: 18 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -304,6 +304,19 @@ struct ScalarEnumerationTraits<FormatStyle::BreakTemplateDeclarationsStyle> {
304304
}
305305
};
306306

307+
template <>
308+
struct ScalarEnumerationTraits<FormatStyle::CppBracedListStyleStyle> {
309+
static void enumeration(IO &IO, FormatStyle::CppBracedListStyleStyle &Value) {
310+
IO.enumCase(Value, "Block", FormatStyle::CBLSS_Block);
311+
IO.enumCase(Value, "FunctionCall", FormatStyle::CBLSS_FunctionCall);
312+
IO.enumCase(Value, "ToBeNamed", FormatStyle::CBLSS_ToBeNamed);
313+
314+
// For backward compatibility.
315+
IO.enumCase(Value, "false", FormatStyle::CBLSS_Block);
316+
IO.enumCase(Value, "true", FormatStyle::CBLSS_ToBeNamed);
317+
}
318+
};
319+
307320
template <> struct ScalarEnumerationTraits<FormatStyle::DAGArgStyle> {
308321
static void enumeration(IO &IO, FormatStyle::DAGArgStyle &Value) {
309322
IO.enumCase(Value, "DontBreak", FormatStyle::DAS_DontBreak);
@@ -1628,7 +1641,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
16281641
LLVMStyle.CompactNamespaces = false;
16291642
LLVMStyle.ConstructorInitializerIndentWidth = 4;
16301643
LLVMStyle.ContinuationIndentWidth = 4;
1631-
LLVMStyle.Cpp11BracedListStyle = true;
1644+
LLVMStyle.Cpp11BracedListStyle = FormatStyle::CBLSS_ToBeNamed;
16321645
LLVMStyle.DerivePointerAlignment = false;
16331646
LLVMStyle.DisableFormat = false;
16341647
LLVMStyle.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
@@ -1904,7 +1917,7 @@ FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
19041917
// beneficial there. Investigate turning this on once proper string reflow
19051918
// has been implemented.
19061919
GoogleStyle.BreakStringLiterals = false;
1907-
GoogleStyle.Cpp11BracedListStyle = false;
1920+
GoogleStyle.Cpp11BracedListStyle = FormatStyle::CBLSS_Block;
19081921
GoogleStyle.SpacesInContainerLiterals = false;
19091922
} else if (Language == FormatStyle::LK_ObjC) {
19101923
GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
@@ -2000,7 +2013,7 @@ FormatStyle getMozillaStyle() {
20002013
MozillaStyle.BreakTemplateDeclarations = FormatStyle::BTDS_Yes;
20012014
MozillaStyle.ConstructorInitializerIndentWidth = 2;
20022015
MozillaStyle.ContinuationIndentWidth = 2;
2003-
MozillaStyle.Cpp11BracedListStyle = false;
2016+
MozillaStyle.Cpp11BracedListStyle = FormatStyle::CBLSS_Block;
20042017
MozillaStyle.FixNamespaceComments = false;
20052018
MozillaStyle.IndentCaseLabels = true;
20062019
MozillaStyle.ObjCSpaceAfterProperty = true;
@@ -2023,7 +2036,7 @@ FormatStyle getWebKitStyle() {
20232036
Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
20242037
Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
20252038
Style.ColumnLimit = 0;
2026-
Style.Cpp11BracedListStyle = false;
2039+
Style.Cpp11BracedListStyle = FormatStyle::CBLSS_Block;
20272040
Style.FixNamespaceComments = false;
20282041
Style.IndentWidth = 4;
20292042
Style.NamespaceIndentation = FormatStyle::NI_Inner;
@@ -2043,7 +2056,7 @@ FormatStyle getGNUStyle() {
20432056
Style.BreakBeforeBraces = FormatStyle::BS_GNU;
20442057
Style.BreakBeforeTernaryOperators = true;
20452058
Style.ColumnLimit = 79;
2046-
Style.Cpp11BracedListStyle = false;
2059+
Style.Cpp11BracedListStyle = FormatStyle::CBLSS_Block;
20472060
Style.FixNamespaceComments = false;
20482061
Style.KeepFormFeed = true;
20492062
Style.SpaceBeforeParens = FormatStyle::SBPO_Always;

‎clang/lib/Format/FormatToken.cpp‎

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,7 @@ bool FormatToken::isTypeOrIdentifier(const LangOptions &LangOpts) const {
6666

6767
bool FormatToken::isBlockIndentedInitRBrace(const FormatStyle &Style) const {
6868
assert(is(tok::r_brace));
69-
if (!Style.Cpp11BracedListStyle ||
69+
if (Style.Cpp11BracedListStyle == FormatStyle::CBLSS_Block ||
7070
Style.AlignAfterOpenBracket != FormatStyle::BAS_BlockIndent) {
7171
return false;
7272
}
@@ -88,7 +88,8 @@ bool FormatToken::opensBlockOrBlockTypeList(const FormatStyle &Style) const {
8888
return is(TT_ArrayInitializerLSquare) || is(TT_ProtoExtensionLSquare) ||
8989
(is(tok::l_brace) &&
9090
(getBlockKind() == BK_Block || is(TT_DictLiteral) ||
91-
(!Style.Cpp11BracedListStyle && NestingLevel == 0))) ||
91+
(Style.Cpp11BracedListStyle == FormatStyle::CBLSS_Block &&
92+
NestingLevel == 0))) ||
9293
(is(tok::less) && Style.isProto());
9394
}
9495

@@ -184,7 +185,8 @@ void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) {
184185
// In C++11 braced list style, we should not format in columns unless they
185186
// have many items (20 or more) or we allow bin-packing of function call
186187
// arguments.
187-
if (Style.Cpp11BracedListStyle && !Style.BinPackArguments &&
188+
if (Style.Cpp11BracedListStyle != FormatStyle::CBLSS_Block &&
189+
!Style.BinPackArguments &&
188190
(Commas.size() < 19 || !Style.BinPackLongBracedList)) {
189191
return;
190192
}
@@ -228,7 +230,7 @@ void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) {
228230
ItemEnd = Token->MatchingParen;
229231
const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment();
230232
ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd));
231-
if (Style.Cpp11BracedListStyle &&
233+
if (Style.Cpp11BracedListStyle != FormatStyle::CBLSS_Block &&
232234
!ItemEnd->Previous->isTrailingComment()) {
233235
// In Cpp11 braced list style, the } and possibly other subsequent
234236
// tokens will need to stay on a line with the last element.

0 commit comments

Comments
 (0)