Skip to content

Commit 1caf823

Browse files
leijurvleijurv
committed
[clang-format] Add BreakBeforeTemplateClose option
1 parent b9ac390 commit 1caf823

File tree

9 files changed

+206
-9
lines changed

9 files changed

+206
-9
lines changed

‎clang/docs/ClangFormatStyleOptions.rst

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3416,6 +3416,27 @@ the configuration (without a prefix: ``Auto``).
34163416

34173417

34183418

3419+
.. _BreakBeforeTemplateClose:
3420+
3421+
**BreakBeforeTemplateClose** (``Boolean``) :versionbadge:`clang-format 20` :ref:`<BreakBeforeTemplateClose>`
3422+
If ``true``, a line break will be placed before the ``>`` in a multiline
3423+
template declaration.
3424+
3425+
.. code-block:: c++
3426+
3427+
true:
3428+
template <
3429+
typename Foo,
3430+
typename Bar,
3431+
typename Baz
3432+
>
3433+
3434+
false:
3435+
template <
3436+
typename Foo,
3437+
typename Bar,
3438+
typename Baz>
3439+
34193440
.. _BreakBeforeTernaryOperators:
34203441

34213442
**BreakBeforeTernaryOperators** (``Boolean``) :versionbadge:`clang-format 3.7` :ref:`<BreakBeforeTernaryOperators>`

‎clang/docs/ReleaseNotes.rst

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -976,6 +976,7 @@ clang-format
976976
``Never``, and ``true`` to ``Always``.
977977
- Adds ``RemoveEmptyLinesInUnwrappedLines`` option.
978978
- Adds ``KeepFormFeed`` option and set it to ``true`` for ``GNU`` style.
979+
- Adds ``BreakBeforeTemplateClose`` option.
979980

980981
libclang
981982
--------

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

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2248,6 +2248,25 @@ struct FormatStyle {
22482248
/// \version 16
22492249
BreakBeforeInlineASMColonStyle BreakBeforeInlineASMColon;
22502250

2251+
/// If ``true``, a line break will be placed before the ``>`` in a multiline
2252+
/// template declaration.
2253+
/// \code
2254+
/// true:
2255+
/// template <
2256+
/// typename Foo,
2257+
/// typename Bar,
2258+
/// typename Baz
2259+
/// >
2260+
///
2261+
/// false:
2262+
/// template <
2263+
/// typename Foo,
2264+
/// typename Bar,
2265+
/// typename Baz>
2266+
/// \endcode
2267+
/// \version 20
2268+
bool BreakBeforeTemplateClose;
2269+
22512270
/// If ``true``, ternary operators will be placed after line breaks.
22522271
/// \code
22532272
/// true:
@@ -5184,6 +5203,7 @@ struct FormatStyle {
51845203
BreakBeforeBraces == R.BreakBeforeBraces &&
51855204
BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations &&
51865205
BreakBeforeInlineASMColon == R.BreakBeforeInlineASMColon &&
5206+
BreakBeforeTemplateClose == R.BreakBeforeTemplateClose &&
51875207
BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
51885208
BreakBinaryOperations == R.BreakBinaryOperations &&
51895209
BreakConstructorInitializers == R.BreakConstructorInitializers &&

‎clang/lib/Format/ContinuationIndenter.cpp

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -406,6 +406,10 @@ bool ContinuationIndenter::mustBreak(const LineState &State) {
406406
}
407407
if (CurrentState.BreakBeforeClosingParen && Current.is(tok::r_paren))
408408
return true;
409+
if (CurrentState.BreakBeforeClosingAngle &&
410+
Current.ClosesTemplateDeclaration && Style.BreakBeforeTemplateClose) {
411+
return true;
412+
}
409413
if (Style.Language == FormatStyle::LK_ObjC &&
410414
Style.ObjCBreakBeforeNestedBlockParam &&
411415
Current.ObjCSelectorNameParts > 1 &&
@@ -1234,6 +1238,9 @@ unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
12341238
Style.AlignAfterOpenBracket == FormatStyle::BAS_BlockIndent;
12351239
}
12361240

1241+
if (PreviousNonComment && PreviousNonComment->is(tok::less))
1242+
CurrentState.BreakBeforeClosingAngle = true;
1243+
12371244
if (CurrentState.AvoidBinPacking) {
12381245
// If we are breaking after '(', '{', '<', or this is the break after a ':'
12391246
// to start a member initializer list in a constructor, this should not
@@ -1370,6 +1377,10 @@ unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
13701377
State.Stack.size() > 1) {
13711378
return State.Stack[State.Stack.size() - 2].LastSpace;
13721379
}
1380+
if (Current.ClosesTemplateDeclaration && Style.BreakBeforeTemplateClose &&
1381+
State.Stack.size() > 1) {
1382+
return State.Stack[State.Stack.size() - 2].LastSpace;
1383+
}
13731384
if (NextNonComment->is(TT_TemplateString) && NextNonComment->closesScope())
13741385
return State.Stack[State.Stack.size() - 2].LastSpace;
13751386
// Field labels in a nested type should be aligned to the brace. For example

‎clang/lib/Format/ContinuationIndenter.h

Lines changed: 18 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -200,14 +200,15 @@ struct ParenState {
200200
: Tok(Tok), Indent(Indent), LastSpace(LastSpace),
201201
NestedBlockIndent(Indent), IsAligned(false),
202202
BreakBeforeClosingBrace(false), BreakBeforeClosingParen(false),
203-
AvoidBinPacking(AvoidBinPacking), BreakBeforeParameter(false),
204-
NoLineBreak(NoLineBreak), NoLineBreakInOperand(false),
205-
LastOperatorWrapped(true), ContainsLineBreak(false),
206-
ContainsUnwrappedBuilder(false), AlignColons(true),
207-
ObjCSelectorNameFound(false), HasMultipleNestedBlocks(false),
208-
NestedBlockInlined(false), IsInsideObjCArrayLiteral(false),
209-
IsCSharpGenericTypeConstraint(false), IsChainedConditional(false),
210-
IsWrappedConditional(false), UnindentOperator(false) {}
203+
BreakBeforeClosingAngle(false), AvoidBinPacking(AvoidBinPacking),
204+
BreakBeforeParameter(false), NoLineBreak(NoLineBreak),
205+
NoLineBreakInOperand(false), LastOperatorWrapped(true),
206+
ContainsLineBreak(false), ContainsUnwrappedBuilder(false),
207+
AlignColons(true), ObjCSelectorNameFound(false),
208+
HasMultipleNestedBlocks(false), NestedBlockInlined(false),
209+
IsInsideObjCArrayLiteral(false), IsCSharpGenericTypeConstraint(false),
210+
IsChainedConditional(false), IsWrappedConditional(false),
211+
UnindentOperator(false) {}
211212

212213
/// \brief The token opening this parenthesis level, or nullptr if this level
213214
/// is opened by fake parenthesis.
@@ -280,6 +281,13 @@ struct ParenState {
280281
/// was a newline after the beginning left paren.
281282
bool BreakBeforeClosingParen : 1;
282283

284+
/// Whether a newline needs to be inserted before the block's closing
285+
/// angle < >.
286+
///
287+
/// We only want to insert a newline before the closing angle if there also
288+
/// was a newline after the beginning left angle.
289+
bool BreakBeforeClosingAngle : 1;
290+
283291
/// Avoid bin packing, i.e. multiple parameters/elements on multiple
284292
/// lines, in this context.
285293
bool AvoidBinPacking : 1;
@@ -367,6 +375,8 @@ struct ParenState {
367375
return BreakBeforeClosingBrace;
368376
if (BreakBeforeClosingParen != Other.BreakBeforeClosingParen)
369377
return BreakBeforeClosingParen;
378+
if (BreakBeforeClosingAngle != Other.BreakBeforeClosingAngle)
379+
return BreakBeforeClosingAngle;
370380
if (QuestionColumn != Other.QuestionColumn)
371381
return QuestionColumn < Other.QuestionColumn;
372382
if (AvoidBinPacking != Other.AvoidBinPacking)

‎clang/lib/Format/Format.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1000,6 +1000,7 @@ template <> struct MappingTraits<FormatStyle> {
10001000
IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
10011001
IO.mapOptional("BreakBeforeInlineASMColon",
10021002
Style.BreakBeforeInlineASMColon);
1003+
IO.mapOptional("BreakBeforeTemplateClose", Style.BreakBeforeTemplateClose);
10031004
IO.mapOptional("BreakBeforeTernaryOperators",
10041005
Style.BreakBeforeTernaryOperators);
10051006
IO.mapOptional("BreakBinaryOperations", Style.BreakBinaryOperations);
@@ -1514,6 +1515,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
15141515
LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
15151516
LLVMStyle.BreakBeforeConceptDeclarations = FormatStyle::BBCDS_Always;
15161517
LLVMStyle.BreakBeforeInlineASMColon = FormatStyle::BBIAS_OnlyMultiline;
1518+
LLVMStyle.BreakBeforeTemplateClose = false;
15171519
LLVMStyle.BreakBeforeTernaryOperators = true;
15181520
LLVMStyle.BreakBinaryOperations = FormatStyle::BBO_Never;
15191521
LLVMStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;

‎clang/lib/Format/TokenAnnotator.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6254,7 +6254,7 @@ bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
62546254
return false;
62556255

62566256
if (Right.is(TT_TemplateCloser))
6257-
return false;
6257+
return Right.ClosesTemplateDeclaration && Style.BreakBeforeTemplateClose;
62586258
if (Right.is(tok::r_square) && Right.MatchingParen &&
62596259
Right.MatchingParen->is(TT_LambdaLSquare)) {
62606260
return false;

‎clang/unittests/Format/ConfigParseTest.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -162,6 +162,7 @@ TEST(ConfigParseTest, ParsesConfigurationBools) {
162162
CHECK_PARSE_BOOL(BinPackArguments);
163163
CHECK_PARSE_BOOL(BreakAdjacentStringLiterals);
164164
CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
165+
CHECK_PARSE_BOOL(BreakBeforeTemplateClose);
165166
CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
166167
CHECK_PARSE_BOOL(BreakStringLiterals);
167168
CHECK_PARSE_BOOL(CompactNamespaces);

‎clang/unittests/Format/FormatTest.cpp

Lines changed: 131 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11077,6 +11077,137 @@ TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
1107711077
Style);
1107811078
}
1107911079

11080+
TEST_F(FormatTest, BreakBeforeTemplateClose) {
11081+
FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
11082+
Style.ColumnLimit = 0;
11083+
verifyNoChange("template <typename Foo>\n"
11084+
"void foo() {}",
11085+
Style);
11086+
verifyNoChange("template <\n"
11087+
" typename Foo,\n"
11088+
" typename Bar>\n"
11089+
"void foo() {}",
11090+
Style);
11091+
// when BreakBeforeTemplateClose is off, this line break is removed:
11092+
verifyFormat("template <\n"
11093+
" typename Foo,\n"
11094+
" typename Bar>\n"
11095+
"void foo() {}",
11096+
"template <\n"
11097+
" typename Foo,\n"
11098+
" typename Bar\n"
11099+
">\n"
11100+
"void foo() {}",
11101+
Style);
11102+
Style.BreakBeforeTemplateClose = true;
11103+
// BreakBeforeTemplateClose should NOT force multiline templates
11104+
verifyNoChange("template <typename Foo>\n"
11105+
"void foo() {}",
11106+
Style);
11107+
verifyNoChange("template <typename Foo, typename Bar>\n"
11108+
"void foo() {}",
11109+
Style);
11110+
// it should allow a line break:
11111+
verifyNoChange("template <\n"
11112+
" typename Foo\n"
11113+
">\n"
11114+
"void foo() {}",
11115+
Style);
11116+
verifyNoChange("template <\n"
11117+
" typename Foo,\n"
11118+
" typename Bar\n"
11119+
">\n"
11120+
"void foo() {}",
11121+
Style);
11122+
// it should add a line break if not already present:
11123+
verifyFormat("template <\n"
11124+
" typename Foo\n"
11125+
">\n"
11126+
"void foo() {}",
11127+
"template <\n"
11128+
" typename Foo>\n"
11129+
"void foo() {}",
11130+
Style);
11131+
verifyFormat("template <\n"
11132+
" typename Foo,\n"
11133+
" typename Bar\n"
11134+
">\n"
11135+
"void foo() {}",
11136+
"template <\n"
11137+
" typename Foo,\n"
11138+
" typename Bar>\n"
11139+
"void foo() {}",
11140+
Style);
11141+
// when within an indent scope, the > should be placed appropriately:
11142+
verifyFormat("struct Baz {\n"
11143+
" template <\n"
11144+
" typename Foo,\n"
11145+
" typename Bar\n"
11146+
" >\n"
11147+
" void foo() {}\n"
11148+
"};",
11149+
"struct Baz {\n"
11150+
" template <\n"
11151+
" typename Foo,\n"
11152+
" typename Bar>\n"
11153+
" void foo() {}\n"
11154+
"};",
11155+
Style);
11156+
11157+
// now test that it handles the cases when the column limit forces wrapping
11158+
Style.ColumnLimit = 40;
11159+
// when the column limit allows it, the template should be combined back into
11160+
// one line:
11161+
verifyFormat("template <typename Foo, typename Bar>\n"
11162+
"void foo() {}",
11163+
"template <\n"
11164+
" typename Foo,\n"
11165+
" typename Bar\n"
11166+
">\n"
11167+
"void foo() {}",
11168+
Style);
11169+
// but not when the name is looong
11170+
verifyFormat("template <\n"
11171+
" typename Foo,\n"
11172+
" typename Barrrrrrrrrrrrrrrrrrrrrrrrrr\n"
11173+
">\n"
11174+
"void foo() {}",
11175+
Style);
11176+
verifyFormat("template <\n"
11177+
" typename Fooooooooooooooooooooooooooo,\n"
11178+
" typename Bar\n"
11179+
">\n"
11180+
"void foo() {}",
11181+
Style);
11182+
// additionally, long names should be split in one step:
11183+
verifyFormat(
11184+
"template <\n"
11185+
" typename Foo,\n"
11186+
" typename Barrrrrrrrrrrrrrrrrrrrrrrrrr\n"
11187+
">\n"
11188+
"void foo() {}",
11189+
"template <typename Foo, typename Barrrrrrrrrrrrrrrrrrrrrrrrrr>\n"
11190+
"void foo() {}",
11191+
Style);
11192+
verifyFormat(
11193+
"template <\n"
11194+
" typename Fooooooooooooooooooooooooooo,\n"
11195+
" typename Bar\n"
11196+
">\n"
11197+
"void foo() {}",
11198+
"template <typename Fooooooooooooooooooooooooooo, typename Bar>\n"
11199+
"void foo() {}",
11200+
Style);
11201+
// even when there is only one long name:
11202+
verifyFormat("template <\n"
11203+
" typename Fooooooooooooooooooooooooooo\n"
11204+
">\n"
11205+
"void foo() {}",
11206+
"template <typename Fooooooooooooooooooooooooooo>\n"
11207+
"void foo() {}",
11208+
Style);
11209+
}
11210+
1108011211
TEST_F(FormatTest, WrapsTemplateParameters) {
1108111212
FormatStyle Style = getLLVMStyle();
1108211213
Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;

0 commit comments

Comments
 (0)